WSi4 1.22.5

WSi4 > var buffer = wsi4.io.fs.readFile("/absolute/path/to/cad/file.step");
{
    "error": "",
    "return": null,
    "runId": "0",
    "type": "Success"
}

WSi4 > var type = wsi4.classifier.classify(buffer);
{
    "error": "",
    "return": "null",
    "runId": "1",
    "type": "Success"
}

WSi4 > console.log(type);
js: Assembly
{
    "error": "",
    "return": null,
    "runId": "2",
    "type": "Success"
}

WSi4 > wsi4.graphManipulator.add([{type : type, content : {data: buffer, id : ""}}]);
{
    "error": "",
    "return": true,
    "runId": "3",
    "type": "Success"
}

WSi4 > :help wsi4.graphManipulator.add

wsi4.graphManipulator.add(Input[] input)

Add data to graph
help graphManipulator.add

WSi4 > function print(val) {
function print(val) {

WSi4 > console.log(val);
function print(val) {
console.log(val);

WSi4 > }
{
    "error": "",
    "return": null,
    "runId": "7",
    "type": "Success"
}


WSi4 > print("hello world");
js: hello world
{
    "error": "",
    "return": null,
    "runId": "8",
    "type": "Success"
}

{
	"modulePath" : "relative/path/to/module.js",
	"functionName" : "computeSomething",
	"args" : ["optional", "function", "arguments"]
}

const arrayBuffer = wsi4.io.fs.readFile("/path/to/global/material/table.json");
const jsonString = wsi4.util.arrayBufferToString(arrayBuffer);
const table = JSON.parse(jsonString);

// `content` must conform to the interface associated with `type`
wsi4.tables.setExternalTable({
	type: TableType.sheetMaterial,
	content: table,
});

const jsonString = wsi4.io.net.http.get("https://server/wsi4/sheetMaterial");
const table = JSON.parse(jsonString);

// `content` must conform to the interface associated with `type`
wsi4.tables.setExternalTable({
	type: TableType.sheetMaterial,
	content: table,
);

./wsi4cli --key <key> [--db-name <db-name>] --module "opt/cli/dbsync.js" -- [--mode <update / upsert / replace>] /path/to/dir

./wsi4cli --key <key> --db-name <db-name> --module "opt/cli/dbsync.js" -- /path/to/dir

./wsi4cli --key <key> --db-name <db-name> --module "opt/cli/dbsync.js" -- --mode update /path/to/dir

./wsi4cli --key <key> --db-name <db-name> --module "opt/cli/dbsync.js" -- --mode upsert /path/to/dir

./wsi4cli --key <key> --db-name <db-name> --module "opt/cli/dbsync.js" -- --mode replace /path/to/dir

interface StringIndexedInterface {
	[index: string]: unknown;
}

function isStringIndexedInterface(arg: unknown) : arg is StringIndexedInterface;

interface AnyNodeIssue {
	index: number;
	data: NodeIssueBendDeductionApplicationFailed;
}

function isAnyNodeIssue(arg: unknown) : arg is AnyNodeIssue;

interface AnyTable {
	index: number;
	data: (SheetMaterial)[];
}

function isAnyTable(arg: unknown) : arg is AnyTable;

interface ArcSegment {
	from: Point2;
	to: Point2;
	center: Point2;
	ccw: boolean;
}

function isArcSegment(arg: unknown) : arg is ArcSegment;

interface ArticleAttributes {
	userData: StringIndexedInterface;
}

function isArticleAttributes(arg: unknown) : arg is ArticleAttributes;

interface ArticleUpdate {
	vertex: Vertex;
	articleUserData?: StringIndexedInterface;
}

function isArticleUpdate(arg: unknown) : arg is ArticleUpdate;

interface AssemblyMapEntry {
	id: string;
	assembly: Assembly;
}

function isAssemblyMapEntry(arg: unknown) : arg is AssemblyMapEntry;

interface AssemblyPath {
	indices: (number)[];
}

function isAssemblyPath(arg: unknown) : arg is AssemblyPath;

interface Attachment {
	name: string;
	data: string;
}

function isAttachment(arg: unknown) : arg is Attachment;

interface BendDieAffectDistanceEntry {
	bendDescriptor: number;
	affectDistance: number;
}

function isBendDieAffectDistanceEntry(arg: unknown) : arg is BendDieAffectDistanceEntry;

interface BendDieChoice {
	baseClass: CamBendDeduction;
	upperDieGroupId: string;
	lowerDieGroupId: string;
	thickness: number;
	type: BendDieChoiceType;
	sharpDeduction: number;
}

function isBendDieChoice(arg: unknown) : arg is BendDieChoice;

interface BendLineData {
	constructedInnerRadius: number;
	resultingInnerRadius: number;
	bendAngle: number;
	bendDescriptor: number;
}

function isBendLineData(arg: unknown) : arg is BendLineData;

interface BendLineFlangeLength {
	flangeLengthLhs: number;
	flangeLengthRhs: number;
	bendDescriptor: number;
}

function isBendLineFlangeLength(arg: unknown) : arg is BendLineFlangeLength;

interface BendLineSegmentsMapEntry {
	bendDescriptor: number;
	segments: (Segment)[];
}

function isBendLineSegmentsMapEntry(arg: unknown) : arg is BendLineSegmentsMapEntry;

interface BendingToolEditorInputEntry {
	bendDescriptor: number;
	angle: number;
	constructedInnerRadius: number;
	bendDieChoices: (BendDieChoice)[];
}

function isBendingToolEditorInputEntry(arg: unknown) : arg is BendingToolEditorInputEntry;

interface Box2 {
	lower: Point2;
	upper: Point2;
}

function isBox2(arg: unknown) : arg is Box2;

interface Box3 {
	lower: Point3;
	upper: Point3;
}

function isBox3(arg: unknown) : arg is Box3;

interface BulkEditorCellConfig {
	index: number;
	data: BulkEditorCheckBoxConfig;
}

function isBulkEditorCellConfig(arg: unknown) : arg is BulkEditorCellConfig;

interface BulkEditorCheckBoxConfig {
	initialValue?: boolean;
	isOptional: boolean;
}

function isBulkEditorCheckBoxConfig(arg: unknown) : arg is BulkEditorCheckBoxConfig;

interface BulkEditorColumnConfig {
	key: string;
	name: string;
}

function isBulkEditorColumnConfig(arg: unknown) : arg is BulkEditorColumnConfig;

interface BulkEditorDropDownConfig {
	initialValue?: string;
	items: (BulkEditorDropDownItem)[];
	isOptional: boolean;
}

function isBulkEditorDropDownConfig(arg: unknown) : arg is BulkEditorDropDownConfig;

interface BulkEditorDropDownItem {
	id: string;
	name: string;
}

function isBulkEditorDropDownItem(arg: unknown) : arg is BulkEditorDropDownItem;

interface BulkEditorLabelConfig {
	initialValue?: string;
}

function isBulkEditorLabelConfig(arg: unknown) : arg is BulkEditorLabelConfig;

interface BulkEditorLineEditConfig {
	initialValue?: string;
	isOptional: boolean;
}

function isBulkEditorLineEditConfig(arg: unknown) : arg is BulkEditorLineEditConfig;

interface BulkEditorSpinBoxConfig {
	initialValue?: number;
	min: number;
	max: number;
	decimals: number;
	isOptional: boolean;
}

function isBulkEditorSpinBoxConfig(arg: unknown) : arg is BulkEditorSpinBoxConfig;

interface BulkEditorTextEditConfig {
	initialValue?: string;
	isOptional: boolean;
}

function isBulkEditorTextEditConfig(arg: unknown) : arg is BulkEditorTextEditConfig;

interface CadCountersinking {
	featureDescriptor: number;
}

function isCadCountersinking(arg: unknown) : arg is CadCountersinking;

interface CadFeature {
	index: number;
	data: CadCountersinking;
}

function isCadFeature(arg: unknown) : arg is CadFeature;

interface CadImportConfig {
	sheetUpperSideStrategy?: SheetUpperSideStrategy;
}

function isCadImportConfig(arg: unknown) : arg is CadImportConfig;

interface CadThroughHole {
	featureDescriptor: number;
}

function isCadThroughHole(arg: unknown) : arg is CadThroughHole;

interface CamBendDeduction {
	roundDeduction: number;
	innerRadius: number;
}

function isCamBendDeduction(arg: unknown) : arg is CamBendDeduction;

interface CamCommand {
	index: number;
	data: CamCommandSetColor;
}

function isCamCommand(arg: unknown) : arg is CamCommand;

interface CamCommandSetCoatingColor {
	coatingMode: CamCoatingMode;
	color: Vector4;
}

function isCamCommandSetCoatingColor(arg: unknown) : arg is CamCommandSetCoatingColor;

interface CamCommandSetColor {
	entities: (GeometryEntity)[];
	color: Vector3;
}

function isCamCommandSetColor(arg: unknown) : arg is CamCommandSetColor;

interface CamNestedPart {
	innerOuterPolygon: InnerOuterPolygon;
	coordinateSystem: CoordinateSystem2;
}

function isCamNestedPart(arg: unknown) : arg is CamNestedPart;

interface CamNesting {
	sheets: (CamSheet)[];
}

function isCamNesting(arg: unknown) : arg is CamNesting;

interface CamNestorConfig {
	timeout: number;
	numRelevantNestings: number;
}

function isCamNestorConfig(arg: unknown) : arg is CamNestorConfig;

interface CamNestorInput {
	parts: (CamNestorInputPart)[];
	targetBoundary: Polygon;
	nestingDistance: number;
	xModulus: number;
	yModulus: number;
}

function isCamNestorInput(arg: unknown) : arg is CamNestorInput;

interface CamNestorInputPart {
	iop: InnerOuterPolygon;
	minCount: number;
	maxCount: number;
	fixedRotations: (number)[];
}

function isCamNestorInputPart(arg: unknown) : arg is CamNestorInputPart;

interface CamSheet {
	dimX: number;
	dimY: number;
	multiplicity: number;
}

function isCamSheet(arg: unknown) : arg is CamSheet;

interface CamTubeNestingResult {
	inputLength: number;
	nestings: (CamTubeNestingResultNesting)[];
}

function isCamTubeNestingResult(arg: unknown) : arg is CamTubeNestingResult;

interface CamTubeNestingResultNesting {
	transformations: (CoordinateSystem3)[];
	multiplicity: number;
}

function isCamTubeNestingResultNesting(arg: unknown) : arg is CamTubeNestingResultNesting;

interface CamWorkStepUpdateInputSheet {
	nestorInput: CamNestorInput;
	nestorConfig: CamNestorConfig;
}

function isCamWorkStepUpdateInputSheet(arg: unknown) : arg is CamWorkStepUpdateInputSheet;

interface CamWorkStepUpdateInputTube {
	length: number;
	multiplicity: number;
	nestingDistance: number;
}

function isCamWorkStepUpdateInputTube(arg: unknown) : arg is CamWorkStepUpdateInputTube;

interface Camera3 {
	eye: Point3;
	center: Point3;
	up: Vector3;
}

function isCamera3(arg: unknown) : arg is Camera3;

interface CameraOrientation3 {
	center: Vector3;
	direction: Vector3;
	up: Vector3;
}

function isCameraOrientation3(arg: unknown) : arg is CameraOrientation3;

interface ConnectionProperties {
	databaseType: DatabaseType;
	name: string;
	hostName: string;
	port: number;
	databaseName: string;
	userName: string;
	password: string;
}

function isConnectionProperties(arg: unknown) : arg is ConnectionProperties;

interface ConsistencyTableError {
	affectedRowType: TableType;
	details: string;
}

function isConsistencyTableError(arg: unknown) : arg is ConsistencyTableError;

interface CoordinateSystem2 {
	origin: Vector2;
	unitaryMatrix: Matrix2;
}

function isCoordinateSystem2(arg: unknown) : arg is CoordinateSystem2;

interface CoordinateSystem3 {
	origin: Vector3;
	unitaryMatrix: Matrix3;
}

function isCoordinateSystem3(arg: unknown) : arg is CoordinateSystem3;

interface CustomCalculationResult {
	displayName: string;
	unit: string;
	value: undefined|number;
}

function isCustomCalculationResult(arg: unknown) : arg is CustomCalculationResult;

interface DieChoiceAlternativesEntry {
	bendDescriptor: number;
	bendDieChoices: (BendDieChoice)[];
}

function isDieChoiceAlternativesEntry(arg: unknown) : arg is DieChoiceAlternativesEntry;

interface DieChoiceMapEntry {
	bendDescriptor: number;
	bendDieChoice: BendDieChoice;
}

function isDieChoiceMapEntry(arg: unknown) : arg is DieChoiceMapEntry;

interface DieSelectorQuery {
	thickness: number;
	bendAngle: number;
	maxOpeningWidth: number;
	resultingRadiusFactor: number;
}

function isDieSelectorQuery(arg: unknown) : arg is DieSelectorQuery;

interface DocXImage {
	placeholder: string;
	content: ArrayBuffer;
	type: DocXImageType;
}

function isDocXImage(arg: unknown) : arg is DocXImage;

interface DocXTableCell {
	index: number;
	data: DocXText;
}

function isDocXTableCell(arg: unknown) : arg is DocXTableCell;

interface DocXTables {
	tables: (((DocXTableCell)[])[])[];
}

function isDocXTables(arg: unknown) : arg is DocXTables;

interface DocXText {
	placeholder: string;
	text: string;
}

function isDocXText(arg: unknown) : arg is DocXText;

interface DocumentBarcode {
	width: number;
	text: string;
	alignment: DocumentAlignment;
}

function isDocumentBarcode(arg: unknown) : arg is DocumentBarcode;

interface DocumentFormat {
	orientation: DocumentOrientation;
}

function isDocumentFormat(arg: unknown) : arg is DocumentFormat;

interface DocumentHeading {
	level: number;
	text: string;
}

function isDocumentHeading(arg: unknown) : arg is DocumentHeading;

interface DocumentImage {
	width: number;
	type: DocumentImageType;
	uuid: string;
	data: ArrayBuffer;
	alignment: DocumentAlignment;
}

function isDocumentImage(arg: unknown) : arg is DocumentImage;

interface DocumentItem {
	index: number;
	data: DocumentParagraph;
}

function isDocumentItem(arg: unknown) : arg is DocumentItem;

interface DocumentPageBreak {
}

function isDocumentPageBreak(arg: unknown) : arg is DocumentPageBreak;

interface DocumentParagraph {
	width: number;
	text: string;
	alignment: DocumentAlignment;
}

function isDocumentParagraph(arg: unknown) : arg is DocumentParagraph;

interface DocumentSeparator {
}

function isDocumentSeparator(arg: unknown) : arg is DocumentSeparator;

interface DocumentTable {
	width: number;
	columnWidths: (number)[];
	columnHeaders: DocumentTableRow;
	rows: (DocumentTableRow)[];
}

function isDocumentTable(arg: unknown) : arg is DocumentTable;

interface DocumentTableCell {
	text: string;
	alignment: DocumentAlignment;
}

function isDocumentTableCell(arg: unknown) : arg is DocumentTableCell;

interface DocumentTableRow {
}

function isDocumentTableRow(arg: unknown) : arg is DocumentTableRow;

interface FormRowConfig {
	key: string;
	name: string;
	config: FormWidgetConfig;
}

function isFormRowConfig(arg: unknown) : arg is FormRowConfig;

interface FormWidgetCheckBoxConfig {
	initialValue: boolean;
}

function isFormWidgetCheckBoxConfig(arg: unknown) : arg is FormWidgetCheckBoxConfig;

interface FormWidgetConfig {
	index: number;
	data: FormWidgetCheckBoxConfig;
}

function isFormWidgetConfig(arg: unknown) : arg is FormWidgetConfig;

interface FormWidgetDropDownConfig {
	initialValue: string;
	entries: (FormWidgetDropDownEntry)[];
}

function isFormWidgetDropDownConfig(arg: unknown) : arg is FormWidgetDropDownConfig;

interface FormWidgetDropDownEntry {
	id: string;
	text: string;
}

function isFormWidgetDropDownEntry(arg: unknown) : arg is FormWidgetDropDownEntry;

interface FormWidgetLabelConfig {
	initialValue: string;
}

function isFormWidgetLabelConfig(arg: unknown) : arg is FormWidgetLabelConfig;

interface FormWidgetLineEditConfig {
	initialValue: string;
	validatorRegex?: string;
}

function isFormWidgetLineEditConfig(arg: unknown) : arg is FormWidgetLineEditConfig;

interface FormWidgetSpinBoxConfig {
	initialValue: number;
	min: number;
	max: number;
	decimals: number;
}

function isFormWidgetSpinBoxConfig(arg: unknown) : arg is FormWidgetSpinBoxConfig;

interface FormWidgetTextEditConfig {
	initialValue: string;
}

function isFormWidgetTextEditConfig(arg: unknown) : arg is FormWidgetTextEditConfig;

interface GeometryEntity {
	assemblyPath: AssemblyPath;
	descriptor: GeometryEntityDescriptor;
}

function isGeometryEntity(arg: unknown) : arg is GeometryEntity;

interface GeometryEntityDescriptor {
	index: number;
	data: GeometryEntityDescriptorContentEdge;
}

function isGeometryEntityDescriptor(arg: unknown) : arg is GeometryEntityDescriptor;

interface GeometryEntityDescriptorContentEdge {
	value: number;
}

function isGeometryEntityDescriptorContentEdge(arg: unknown) : arg is GeometryEntityDescriptorContentEdge;

interface GeometryEntityDescriptorContentFace {
	value: number;
}

function isGeometryEntityDescriptorContentFace(arg: unknown) : arg is GeometryEntityDescriptorContentFace;

interface GltfNodeVendorData {
	assembly: Assembly;
	data: StringIndexedInterface;
}

function isGltfNodeVendorData(arg: unknown) : arg is GltfNodeVendorData;

interface GraphCreatorInput {
	index: number;
	data: GraphCreatorInputStep;
}

function isGraphCreatorInput(arg: unknown) : arg is GraphCreatorInput;

interface GraphCreatorInputExtrusion {
	importId: string;
	innerOuterPolygon: InnerOuterPolygon;
	depth: number;
	assemblyName: string;
	multiplicity: number;
}

function isGraphCreatorInputExtrusion(arg: unknown) : arg is GraphCreatorInputExtrusion;

interface GraphCreatorInputStep {
	importId: string;
	data: ArrayBuffer;
	multiplicity: number;
}

function isGraphCreatorInputStep(arg: unknown) : arg is GraphCreatorInputStep;

interface GraphCreatorInputTwoDimRep {
	importId: string;
	twoDimRep: TwoDimRepresentation;
	thickness: number;
	assemblyName: string;
	multiplicity: number;
}

function isGraphCreatorInputTwoDimRep(arg: unknown) : arg is GraphCreatorInputTwoDimRep;

interface GraphDeserializationResult {
	status: AddResultStatus;
	graph?: ImportedDocumentGraph;
}

function isGraphDeserializationResult(arg: unknown) : arg is GraphDeserializationResult;

interface HandlerPackaging {
	package: Box3;
	maxWeight: number;
	masses: (number)[];
}

function isHandlerPackaging(arg: unknown) : arg is HandlerPackaging;

interface HandlerPostProcessCreateSources {
	attributes: (VertexWithArticleAttributes)[];
}

function isHandlerPostProcessCreateSources(arg: unknown) : arg is HandlerPostProcessCreateSources;

interface HandlerPostProcessSheetBending {
	upperDieAffectDistances: (number)[];
	lowerDieAffectDistances: (number)[];
}

function isHandlerPostProcessSheetBending(arg: unknown) : arg is HandlerPostProcessSheetBending;

interface HandlerPreProcessCreateWorkStep {
	processTable: (Process)[];
}

function isHandlerPreProcessCreateWorkStep(arg: unknown) : arg is HandlerPreProcessCreateWorkStep;

interface HttpReply {
	errorCode: number;
	data: ArrayBuffer;
}

function isHttpReply(arg: unknown) : arg is HttpReply;

interface InvalidValueTableError {
	affectedRowType: TableType;
	affectedRowIndex: number;
	affectedColumnIndex: number;
	details: string;
}

function isInvalidValueTableError(arg: unknown) : arg is InvalidValueTableError;

interface Joining {
	joiningSteps: (JoiningStep)[];
}

function isJoining(arg: unknown) : arg is Joining;

interface JoiningStep {
	entries: (JoiningStepEntry)[];
	cameraOrientation?: CameraOrientation3;
	comment: string;
}

function isJoiningStep(arg: unknown) : arg is JoiningStep;

interface JoiningStepEntry {
	assembly: Assembly;
}

function isJoiningStepEntry(arg: unknown) : arg is JoiningStepEntry;

interface KeyValue {
	key: string;
	value: string;
}

function isKeyValue(arg: unknown) : arg is KeyValue;

interface Layer {
	descriptor: number;
	number: number;
	name: string;
}

function isLayer(arg: unknown) : arg is Layer;

interface LayeredExtraData {
	thickness: number;
	name: string;
	material: string;
}

function isLayeredExtraData(arg: unknown) : arg is LayeredExtraData;

interface LineSegment {
	from: Point2;
	to: Point2;
}

function isLineSegment(arg: unknown) : arg is LineSegment;

interface LstCreationParameters {
	programName: string;
	lttIdentifier: string;
	sheetThickness: number;
	sheetMaterial: string;
	measureSheet: boolean;
	loadingSystem: TrumpfLoadingSystem;
	evaporate: LstEvaporateMode;
	measuringCorner: SheetCorner;
	sheetMetalStop: SheetCorner;
}

function isLstCreationParameters(arg: unknown) : arg is LstCreationParameters;

interface Matrix2 {
	entries: [ (number), (number), (number), (number), ];
}

function isMatrix2(arg: unknown) : arg is Matrix2;

interface Matrix3 {
	entries: [ (number), (number), (number), (number), (number), (number), (number), (number), (number), ];
}

function isMatrix3(arg: unknown) : arg is Matrix3;

interface Matrix4 {
	entries: [ (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), ];
}

function isMatrix4(arg: unknown) : arg is Matrix4;

interface MeasurementScene {
	scene: Scene;
	camera: Camera3;
}

function isMeasurementScene(arg: unknown) : arg is MeasurementScene;

interface Nest2PartInstance {
	descriptor: number;
	transformation: CoordinateSystem2;
}

function isNest2PartInstance(arg: unknown) : arg is Nest2PartInstance;

interface Nest3InputBin {
	box: Box3;
	maxWeight: number;
}

function isNest3InputBin(arg: unknown) : arg is Nest3InputBin;

interface Nest3Part {
	assembly: Assembly;
	multiplicity: number;
	mass: number;
	profileShadow: ProfileShadowFuture;
}

function isNest3Part(arg: unknown) : arg is Nest3Part;

interface Nest3ResultBox {
	assembly: Assembly;
	weight: number;
}

function isNest3ResultBox(arg: unknown) : arg is Nest3ResultBox;

interface NestingDissection {
	nestingDescriptor: number;
	xDissection?: number;
	yDissection?: number;
}

function isNestingDissection(arg: unknown) : arg is NestingDissection;

interface NewNodeParams {
	processType: ProcessType;
	processId: string;
	nodeUserData: StringIndexedInterface;
}

function isNewNodeParams(arg: unknown) : arg is NewNodeParams;

interface NodeIssueBendDeductionApplicationFailed {
}

function isNodeIssueBendDeductionApplicationFailed(arg: unknown) : arg is NodeIssueBendDeductionApplicationFailed;

interface NodeIssueBendDeductionThicknessDeviation {
}

function isNodeIssueBendDeductionThicknessDeviation(arg: unknown) : arg is NodeIssueBendDeductionThicknessDeviation;

interface NodeIssueBendDieChoiceFailed {
	flangeLenghtIssues: (NodeIssueDieChoiceFailedFlangeLengthIssue)[];
	radiusIssues: (NodeIssueDieChoiceFailedRadiusIssue)[];
	parameterIssues: (NodeIssueDieChoiceFailedParameterIssue)[];
}

function isNodeIssueBendDieChoiceFailed(arg: unknown) : arg is NodeIssueBendDieChoiceFailed;

interface NodeIssueBendFlangeTooShort {
	bendDescriptor: number;
	flangeLength0: number;
	flangeLength1: number;
	requiredOpeningWidth: number;
	actualOpeningWidth: number;
}

function isNodeIssueBendFlangeTooShort(arg: unknown) : arg is NodeIssueBendFlangeTooShort;

interface NodeIssueBendLineLengthConstraintViolated {
	bendDescriptor: number;
	actualNetLength: number;
	maxAllowedNetLength: number;
}

function isNodeIssueBendLineLengthConstraintViolated(arg: unknown) : arg is NodeIssueBendLineLengthConstraintViolated;

interface NodeIssueBendRadiusDeviation {
	violatingDescriptors: (number)[];
}

function isNodeIssueBendRadiusDeviation(arg: unknown) : arg is NodeIssueBendRadiusDeviation;

interface NodeIssueBendZoneAffectsContour {
}

function isNodeIssueBendZoneAffectsContour(arg: unknown) : arg is NodeIssueBendZoneAffectsContour;

interface NodeIssueClassificationEnforceable {
}

function isNodeIssueClassificationEnforceable(arg: unknown) : arg is NodeIssueClassificationEnforceable;

interface NodeIssueDatumInvalid {
	nodeDatumType: NodeDatumType;
	value: string;
}

function isNodeIssueDatumInvalid(arg: unknown) : arg is NodeIssueDatumInvalid;

interface NodeIssueDatumMissing {
	nodeDatumType: NodeDatumType;
}

function isNodeIssueDatumMissing(arg: unknown) : arg is NodeIssueDatumMissing;

interface NodeIssueDieChoiceFailedFlangeLengthIssue {
	bendDescriptor: number;
	actualLength: number;
	minLength: number;
}

function isNodeIssueDieChoiceFailedFlangeLengthIssue(arg: unknown) : arg is NodeIssueDieChoiceFailedFlangeLengthIssue;

interface NodeIssueDieChoiceFailedParameterIssue {
	bendDescriptor: number;
}

function isNodeIssueDieChoiceFailedParameterIssue(arg: unknown) : arg is NodeIssueDieChoiceFailedParameterIssue;

interface NodeIssueDieChoiceFailedRadiusIssue {
	bendDescriptor: number;
	closesResultingRadius: number;
}

function isNodeIssueDieChoiceFailedRadiusIssue(arg: unknown) : arg is NodeIssueDieChoiceFailedRadiusIssue;

interface NodeIssueDimensionConstraintViolated {
	actualDimensions: [ (number), (number), (number), ];
	violatedLowerConstaints?: [ (number), (number), (number), ];
	violatedUpperConstaints?: [ (number), (number), (number), ];
}

function isNodeIssueDimensionConstraintViolated(arg: unknown) : arg is NodeIssueDimensionConstraintViolated;

interface NodeIssueFeatureNotLicensed {
}

function isNodeIssueFeatureNotLicensed(arg: unknown) : arg is NodeIssueFeatureNotLicensed;

interface NodeIssueMaterialIncompatible {
	incompatibleSheetMaterialIds: (string)[];
	incompatibleTubeMaterialIds: (string)[];
	incompatiblePurchasePartMaterialIds: (string)[];
}

function isNodeIssueMaterialIncompatible(arg: unknown) : arg is NodeIssueMaterialIncompatible;

interface NodeIssueNestingFailed {
}

function isNodeIssueNestingFailed(arg: unknown) : arg is NodeIssueNestingFailed;

interface NodeIssueNestingTwoDimRepresentationInvalid {
}

function isNodeIssueNestingTwoDimRepresentationInvalid(arg: unknown) : arg is NodeIssueNestingTwoDimRepresentationInvalid;

interface NodeIssueSemimanufacturedNotAvailable {
}

function isNodeIssueSemimanufacturedNotAvailable(arg: unknown) : arg is NodeIssueSemimanufacturedNotAvailable;

interface NodeIssueSheetThicknessConstraintViolated {
	minThickness: number;
	maxThickness: number;
}

function isNodeIssueSheetThicknessConstraintViolated(arg: unknown) : arg is NodeIssueSheetThicknessConstraintViolated;

interface NodeIssueTubeProfileNotSupported {
}

function isNodeIssueTubeProfileNotSupported(arg: unknown) : arg is NodeIssueTubeProfileNotSupported;

interface NodeIssueUnclassifiedGeometryPartiallyUnclassified {
}

function isNodeIssueUnclassifiedGeometryPartiallyUnclassified(arg: unknown) : arg is NodeIssueUnclassifiedGeometryPartiallyUnclassified;

interface NodeIssueUnexpected {
}

function isNodeIssueUnexpected(arg: unknown) : arg is NodeIssueUnexpected;

interface NodeIssueUnfoldingFailed {
}

function isNodeIssueUnfoldingFailed(arg: unknown) : arg is NodeIssueUnfoldingFailed;

interface NodeIssueUnfoldingNotSimple {
}

function isNodeIssueUnfoldingNotSimple(arg: unknown) : arg is NodeIssueUnfoldingNotSimple;

interface NodeUpdate {
	index: number;
	data: NodeUpdateUndefined;
}

function isNodeUpdate(arg: unknown) : arg is NodeUpdate;

interface NodeUpdateJoining {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateJoining(arg: unknown) : arg is NodeUpdateJoining;

interface NodeUpdatePackaging {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdatePackaging(arg: unknown) : arg is NodeUpdatePackaging;

interface NodeUpdateSheet {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateSheet(arg: unknown) : arg is NodeUpdateSheet;

interface NodeUpdateSheetBending {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	dieChoiceMap?: (DieChoiceMapEntry)[];
	toggleUpperSide?: boolean;
	correctBends?: boolean;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateSheetBending(arg: unknown) : arg is NodeUpdateSheetBending;

interface NodeUpdateSheetCutting {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	sheetThickness?: number;
	toggleUpperSide?: boolean;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateSheetCutting(arg: unknown) : arg is NodeUpdateSheetCutting;

interface NodeUpdateTransform {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateTransform(arg: unknown) : arg is NodeUpdateTransform;

interface NodeUpdateTube {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateTube(arg: unknown) : arg is NodeUpdateTube;

interface NodeUpdateTubeCutting {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateTubeCutting(arg: unknown) : arg is NodeUpdateTubeCutting;

interface NodeUpdateUndefined {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateUndefined(arg: unknown) : arg is NodeUpdateUndefined;

interface NodeUpdateUserDefined {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateUserDefined(arg: unknown) : arg is NodeUpdateUserDefined;

interface NodeUpdateUserDefinedBase {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isNodeUpdateUserDefinedBase(arg: unknown) : arg is NodeUpdateUserDefinedBase;

interface NodeUserDataBase {
	attachments: (Attachment)[];
	bendLineEngravingMode: BendLineEngravingMode;
	coatingId: string;
	comment: string;
	deburrDoubleSided: boolean;
	fixedRotations: (number)[];
	numCountersinks: number;
	numThreads: number;
	purchasePartMaterialId: string;
	sheetFilterSheetIds: (string)[];
	sheetMaterialId: string;
	sheetTappingData: (SheetTappingDataEntry)[];
	testReportRequired: boolean;
	tubeMaterialId: string;
	tubeSpecificationId: string;
	userDefinedMaterialCostsPerPiece: number;
	userDefinedScalePrices: (UserDefinedScalePrice)[];
	userDefinedSetupTime: number;
	userDefinedUnitTimePerPiece: number;
}

function isNodeUserDataBase(arg: unknown) : arg is NodeUserDataBase;

interface Point2 {
	entries: [ (number), (number), ];
}

function isPoint2(arg: unknown) : arg is Point2;

interface Point3 {
	entries: [ (number), (number), (number), ];
}

function isPoint3(arg: unknown) : arg is Point3;

interface PrivateArticleCalcDataResourceEntry {
	nodeId: GraphNodeId;
	approxSemimanufacturedShare?: number;
	manufacturingPriceExclSurcharges?: number;
	manufacturingPriceInclSurcharges?: number;
	recursiveManufacturingPriceExclSurcharges?: number;
	recursiveManufacturingPriceInclSurcharges?: number;
	sellingPrice?: number;
	recursiveSellingPrice?: number;
}

function isPrivateArticleCalcDataResourceEntry(arg: unknown) : arg is PrivateArticleCalcDataResourceEntry;

interface PrivateArticleRepresentation {
	name: string;
	externalPartNumber: string;
	externalDrawingNumber: string;
	externalRevisionNumber: string;
	comment: string;
	multiplicity: number;
	nodeId: GraphNodeId;
	rootId: GraphNodeRootId;
	nodeIds: (GraphNodeId)[];
}

function isPrivateArticleRepresentation(arg: unknown) : arg is PrivateArticleRepresentation;

interface PrivateArticleSignatureNodeResourceEntry {
	nodeId: GraphNodeId;
	material: string;
	mass?: number;
	sheetThickness?: number;
}

function isPrivateArticleSignatureNodeResourceEntry(arg: unknown) : arg is PrivateArticleSignatureNodeResourceEntry;

interface PrivateArticleTextResourceEntry {
	nodeId: GraphNodeId;
	details: string;
}

function isPrivateArticleTextResourceEntry(arg: unknown) : arg is PrivateArticleTextResourceEntry;

interface PrivateAssemblyResourceEntry {
	nodeId: GraphNodeId;
	assembly: Assembly;
}

function isPrivateAssemblyResourceEntry(arg: unknown) : arg is PrivateAssemblyResourceEntry;

interface PrivateBinaryResourceEntry {
	nodeId: GraphNodeId;
	data: ArrayBuffer;
}

function isPrivateBinaryResourceEntry(arg: unknown) : arg is PrivateBinaryResourceEntry;

interface PrivateGraphData {
	projectName: string;
}

function isPrivateGraphData(arg: unknown) : arg is PrivateGraphData;

interface PrivateGuiData {
	index: number;
	data: PrivateGuiDataGraphRep;
}

function isPrivateGuiData(arg: unknown) : arg is PrivateGuiData;

interface PrivateGuiDataGraphRep {
	nodes: (PrivateNodeRepresentation)[];
	articles: (PrivateArticleRepresentation)[];
	resources: PrivateResources;
	data: PrivateGraphData;
	sourceMults: (PrivateSourceMultEntry)[];
}

function isPrivateGuiDataGraphRep(arg: unknown) : arg is PrivateGuiDataGraphRep;

interface PrivateMainWindowScriptAction {
	name: string;
	modulePath: string;
	functionName: string;
	shortcut?: string;
	icon?: string;
	menuType?: PrivateMainWindowMenuType;
}

function isPrivateMainWindowScriptAction(arg: unknown) : arg is PrivateMainWindowScriptAction;

interface PrivateMainWindowScriptConfig {
	scripts: (PrivateMainWindowScriptAction)[];
}

function isPrivateMainWindowScriptConfig(arg: unknown) : arg is PrivateMainWindowScriptConfig;

interface PrivateMeasurementScenesResourceEntry {
	nodeId: GraphNodeId;
	data: (MeasurementScene)[];
}

function isPrivateMeasurementScenesResourceEntry(arg: unknown) : arg is PrivateMeasurementScenesResourceEntry;

interface PrivateNodeCalcDataResourceEntry {
	nodeId: GraphNodeId;
	materialCosts?: number;
	setupTime?: number;
	unitTime?: number;
	manufacturingPriceExclSurcharges?: number;
	manufacturingPriceInclSurcharges?: number;
	sellingPrice?: number;
}

function isPrivateNodeCalcDataResourceEntry(arg: unknown) : arg is PrivateNodeCalcDataResourceEntry;

interface PrivateNodeIssueResourceEntry {
	nodeId: GraphNodeId;
	issues: (AnyNodeIssue)[];
}

function isPrivateNodeIssueResourceEntry(arg: unknown) : arg is PrivateNodeIssueResourceEntry;

interface PrivateNodeRepresentation {
	nodeId: GraphNodeId;
	rootId: GraphNodeRootId;
	sourceNodeIds: (GraphNodeId)[];
	targetNodeIds: (GraphNodeId)[];
	workStepType: WorkStepType;
	processType: ProcessType;
	processId: string;
	processName: string;
	comment: string;
	hasTwoDimInput: boolean;
	hasCalcOverride: boolean;
	hasCalcUserInput: boolean;
}

function isPrivateNodeRepresentation(arg: unknown) : arg is PrivateNodeRepresentation;

interface PrivateNodeTextResourceEntry {
	nodeId: GraphNodeId;
	brief: string;
	details: string;
	toolTip: string;
}

function isPrivateNodeTextResourceEntry(arg: unknown) : arg is PrivateNodeTextResourceEntry;

interface PrivatePostProcessingResultCreateSourcesSheetCutting {
	source: Vertex;
	deducedDataOfSource: StringIndexedInterface;
}

function isPrivatePostProcessingResultCreateSourcesSheetCutting(arg: unknown) : arg is PrivatePostProcessingResultCreateSourcesSheetCutting;

interface PrivatePostProcessingResultCreateWorkStep {
	processType: ProcessType;
	processId: string;
	nodeUserData: StringIndexedInterface;
	articleUserData?: StringIndexedInterface;
}

function isPrivatePostProcessingResultCreateWorkStep(arg: unknown) : arg is PrivatePostProcessingResultCreateWorkStep;

interface PrivateProblematicGeometryResourceEntry {
	nodeId: GraphNodeId;
	hasProblematicGeometries: boolean;
}

function isPrivateProblematicGeometryResourceEntry(arg: unknown) : arg is PrivateProblematicGeometryResourceEntry;

interface PrivateResources {
	pngs: (PrivateBinaryResourceEntry)[];
	inputAssemblies: (PrivateAssemblyResourceEntry)[];
	outputAssemblies: (PrivateAssemblyResourceEntry)[];
	defaultScenes: (PrivateSceneResourceEntry)[];
	bendZoneScenes: (PrivateSceneResourceEntry)[];
	lowerDieAffectZoneScenes: (PrivateSceneResourceEntry)[];
	technicalDrawingScenes: (PrivateMeasurementScenesResourceEntry)[];
	tubeOutlineScenes: (PrivateSceneResourceEntry)[];
	nodeIssues: (PrivateNodeIssueResourceEntry)[];
	nodeTexts: (PrivateNodeTextResourceEntry)[];
	articleTexts: (PrivateArticleTextResourceEntry)[];
	articleCalcData: (PrivateArticleCalcDataResourceEntry)[];
	articleSignatureNodeData: (PrivateArticleSignatureNodeResourceEntry)[];
	nodeCalcData: (PrivateNodeCalcDataResourceEntry)[];
	nodeProblematicGeometryData: (PrivateProblematicGeometryResourceEntry)[];
}

function isPrivateResources(arg: unknown) : arg is PrivateResources;

interface PrivateSceneResourceEntry {
	nodeId: GraphNodeId;
	data: Scene;
}

function isPrivateSceneResourceEntry(arg: unknown) : arg is PrivateSceneResourceEntry;

interface PrivateSheetTablesEditorInitData {
	sheetMaterials: (SheetMaterial)[];
	sheetMaterialDensities: (SheetMaterialDensity)[];
	sheetMaterialScrapValues: (SheetMaterialScrapValue)[];
	sheets: (Sheet)[];
	sheetPrices: (SheetPrice)[];
	sheetStocks: (SheetStock)[];
	sheetModuli: (SheetModulus)[];
	sheetPriorities: (SheetPriority)[];
	sheetCuttingMaterials: (SheetCuttingMaterial)[];
	sheetBendingMaterials: (SheetBendingMaterial)[];
	sheetCuttingMaterialMappings: (SheetCuttingMaterialMapping)[];
	sheetBendingMaterialMappings: (SheetBendingMaterialMapping)[];
}

function isPrivateSheetTablesEditorInitData(arg: unknown) : arg is PrivateSheetTablesEditorInitData;

interface PrivateSourceMultEntry {
	sourceArticleNodeId: GraphNodeId;
	targetArticleNodeId: GraphNodeId;
	multiplicity: number;
}

function isPrivateSourceMultEntry(arg: unknown) : arg is PrivateSourceMultEntry;

interface PrivateTubeTablesEditorInitData {
	tubeMaterials: (TubeMaterial)[];
	tubeMaterialDensities: (TubeMaterialDensity)[];
	tubeProfiles: (TubeProfile)[];
	tubeSpecifications: (TubeSpecification)[];
	tubes: (Tube)[];
}

function isPrivateTubeTablesEditorInitData(arg: unknown) : arg is PrivateTubeTablesEditorInitData;

interface ProfileShadow {
	coordinateSystem: CoordinateSystem3;
	shadow: InnerOuterPolygon;
}

function isProfileShadow(arg: unknown) : arg is ProfileShadow;

interface ProgramVersion {
	major: number;
	minor: number;
	patch: number;
}

function isProgramVersion(arg: unknown) : arg is ProgramVersion;

interface ReferredEntryMissingTableError {
	affectedRowType: TableType;
	affectedRowIndex: number;
	affectedColumnIndex: number;
	relatedRowType: TableType;
	relatedColumnIndex: number;
	referredId: string;
}

function isReferredEntryMissingTableError(arg: unknown) : arg is ReferredEntryMissingTableError;

interface ReferringEntryMissingTableError {
	affectedRowType: TableType;
	affectedColumnIndex: number;
	relatedRowType: TableType;
	relatedRowIndex: number;
	relatedColumnIndex: number;
}

function isReferringEntryMissingTableError(arg: unknown) : arg is ReferringEntryMissingTableError;

interface RenderSceneSettings {
	resolution?: Resolution;
	viewPort?: Box2;
	sheetMaterialId?: string;
	thickness?: number;
	geoName?: string;
}

function isRenderSceneSettings(arg: unknown) : arg is RenderSceneSettings;

interface Resolution {
	width: number;
	height: number;
}

function isResolution(arg: unknown) : arg is Resolution;

interface SceneConfig {
	elements?: SceneElements;
	fontSize?: number;
	textItems?: (SceneTextItem)[];
	sheetBendingBendLineMaxEngravingLength?: number;
	sheetExtraText?: string;
	sheetNestingDissections?: (NestingDissection)[];
}

function isSceneConfig(arg: unknown) : arg is SceneConfig;

interface SceneLabel {
	position: Point2;
	text: string;
	fontSize: number;
}

function isSceneLabel(arg: unknown) : arg is SceneLabel;

interface SceneObjectData {
	zValue: number;
	bendAngle: number;
	innerRadius: number;
	upperDieGroup: string;
	lowerDieGroup: string;
	sharpDeduction: number;
}

function isSceneObjectData(arg: unknown) : arg is SceneObjectData;

interface SceneSceneData {
}

function isSceneSceneData(arg: unknown) : arg is SceneSceneData;

interface SceneStyle {
	strokeWidth?: number;
	strokeColor?: Color;
	fillColor?: Vector4;
	strokeStyle?: StrokeStyle;
	zValue?: number;
	fontSize?: number;
}

function isSceneStyle(arg: unknown) : arg is SceneStyle;

interface SceneTextItem {
	text: string;
	pos: Point2;
}

function isSceneTextItem(arg: unknown) : arg is SceneTextItem;

interface Segment {
	index: number;
	data: LineSegment;
}

function isSegment(arg: unknown) : arg is Segment;

interface SettingsTableDataBase {
	bendFlangeSafetyDistance: number;
	dieBendingSetupTimeDistributionEnabled: boolean;
	dieChoiceRadiusFactorSoftLimit: number;
	dieChoiceRadiusFactorHardLimit: number;
	tubeClampingLength: number;
}

function isSettingsTableDataBase(arg: unknown) : arg is SettingsTableDataBase;

interface SheetCuttingCalcParams {
	sheetMaterialId: string;
	bendLineEngravingMode: BendLineEngravingMode;
	machineVMax: number;
	machineAMax: number;
}

function isSheetCuttingCalcParams(arg: unknown) : arg is SheetCuttingCalcParams;

interface SheetFilter {
	ids: (string)[];
}

function isSheetFilter(arg: unknown) : arg is SheetFilter;

interface SheetNestingPrePartition {
	compatibleTargets: (SheetNestingTarget)[];
	nestorConfig: CamNestorConfig;
	nestingDistance: number;
	sheetMaterialId?: string;
	sheetProcessId?: string;
}

function isSheetNestingPrePartition(arg: unknown) : arg is SheetNestingPrePartition;

interface SheetNestingTarget {
	vertex: Vertex;
	fixedRotations: (number)[];
	sheetFilterSheetIds: (string)[];
}

function isSheetNestingTarget(arg: unknown) : arg is SheetNestingTarget;

interface SheetTappingDataEntry {
	cadFeature: CadFeature;
	screwThreadId: string;
}

function isSheetTappingDataEntry(arg: unknown) : arg is SheetTappingDataEntry;

interface SheetTappingEditorCandidate {
	id: string;
	name: string;
	values: (SheetTappingEditorCandidateValue)[];
}

function isSheetTappingEditorCandidate(arg: unknown) : arg is SheetTappingEditorCandidate;

interface SheetTappingEditorCandidateValue {
	id: string;
	name: string;
}

function isSheetTappingEditorCandidateValue(arg: unknown) : arg is SheetTappingEditorCandidateValue;

interface SheetTappingEditorSelectionEntry {
	candidateId: string;
	valueId: string;
}

function isSheetTappingEditorSelectionEntry(arg: unknown) : arg is SheetTappingEditorSelectionEntry;

interface SlArticleUpdate {
	vertex: SlVertex;
	articleUserData?: StringIndexedInterface;
}

function isSlArticleUpdate(arg: unknown) : arg is SlArticleUpdate;

interface SlNodeUpdate {
	index: number;
	data: SlNodeUpdateUndefined;
}

function isSlNodeUpdate(arg: unknown) : arg is SlNodeUpdate;

interface SlNodeUpdateJoining {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateJoining(arg: unknown) : arg is SlNodeUpdateJoining;

interface SlNodeUpdatePackaging {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdatePackaging(arg: unknown) : arg is SlNodeUpdatePackaging;

interface SlNodeUpdateSheet {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateSheet(arg: unknown) : arg is SlNodeUpdateSheet;

interface SlNodeUpdateSheetBending {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	dieChoiceMap?: (DieChoiceMapEntry)[];
	toggleUpperSide?: boolean;
	correctBends?: boolean;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateSheetBending(arg: unknown) : arg is SlNodeUpdateSheetBending;

interface SlNodeUpdateSheetCutting {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	sheetThickness?: number;
	toggleUpperSide?: boolean;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateSheetCutting(arg: unknown) : arg is SlNodeUpdateSheetCutting;

interface SlNodeUpdateTransform {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateTransform(arg: unknown) : arg is SlNodeUpdateTransform;

interface SlNodeUpdateTube {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateTube(arg: unknown) : arg is SlNodeUpdateTube;

interface SlNodeUpdateTubeCutting {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateTubeCutting(arg: unknown) : arg is SlNodeUpdateTubeCutting;

interface SlNodeUpdateUndefined {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateUndefined(arg: unknown) : arg is SlNodeUpdateUndefined;

interface SlNodeUpdateUserDefined {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateUserDefined(arg: unknown) : arg is SlNodeUpdateUserDefined;

interface SlNodeUpdateUserDefinedBase {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	calcUserInputs?: (AnyCalcUserInput)[];
}

function isSlNodeUpdateUserDefinedBase(arg: unknown) : arg is SlNodeUpdateUserDefinedBase;

interface SlSheetNestingPrePartition {
	compatibleTargets: (SlSheetNestingTarget)[];
	nestorConfig: CamNestorConfig;
	nestingDistance: number;
	sheetMaterialId?: string;
	sheetProcessId?: string;
}

function isSlSheetNestingPrePartition(arg: unknown) : arg is SlSheetNestingPrePartition;

interface SlSheetNestingTarget {
	vertex: SlVertex;
	fixedRotations: (number)[];
	sheetFilterSheetIds: (string)[];
}

function isSlSheetNestingTarget(arg: unknown) : arg is SlSheetNestingTarget;

interface SlTubeNestingPrePartition {
	targetVertex: SlVertex;
	targetLength: number;
	nestingDistance: number;
	tubeProcessId?: string;
}

function isSlTubeNestingPrePartition(arg: unknown) : arg is SlTubeNestingPrePartition;

interface TableError {
	index: number;
	data: ReferringEntryMissingTableError;
}

function isTableError(arg: unknown) : arg is TableError;

interface TubeCuttingCalcParams {
	tubeMaterialId: string;
	machineVMax: number;
	machineAMax: number;
}

function isTubeCuttingCalcParams(arg: unknown) : arg is TubeCuttingCalcParams;

interface TubeNestingPrePartition {
	targetVertex: Vertex;
	targetLength: number;
	nestingDistance: number;
	tubeProcessId?: string;
}

function isTubeNestingPrePartition(arg: unknown) : arg is TubeNestingPrePartition;

interface TubeProfileGeometry {
	index: number;
	data: TubeProfileGeometryRectangular;
}

function isTubeProfileGeometry(arg: unknown) : arg is TubeProfileGeometry;

interface TubeProfileGeometryCircular {
	outerRadius: number;
	thickness: number;
}

function isTubeProfileGeometryCircular(arg: unknown) : arg is TubeProfileGeometryCircular;

interface TubeProfileGeometryRectangular {
	dimY: number;
	dimZ: number;
	thickness: number;
}

function isTubeProfileGeometryRectangular(arg: unknown) : arg is TubeProfileGeometryRectangular;