WSi4 1.19.17

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 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 BendReplyStateContentBendDeductionApplicationFailed {
}

function isBendReplyStateContentBendDeductionApplicationFailed(arg: unknown) : arg is BendReplyStateContentBendDeductionApplicationFailed;

interface BendReplyStateContentContourInBend {
}

function isBendReplyStateContentContourInBend(arg: unknown) : arg is BendReplyStateContentContourInBend;

interface BendReplyStateContentInvalidBend {
}

function isBendReplyStateContentInvalidBend(arg: unknown) : arg is BendReplyStateContentInvalidBend;

interface BendReplyStateContentMultipleOuterContours {
}

function isBendReplyStateContentMultipleOuterContours(arg: unknown) : arg is BendReplyStateContentMultipleOuterContours;

interface BendReplyStateContentUndefinedError {
}

function isBendReplyStateContentUndefinedError(arg: unknown) : arg is BendReplyStateContentUndefinedError;

interface BendReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}

function isBendReplyStateContentUndetectedFeatures(arg: unknown) : arg is BendReplyStateContentUndetectedFeatures;

interface BendReplyStateContentUnfoldingFailed {
}

function isBendReplyStateContentUnfoldingFailed(arg: unknown) : arg is BendReplyStateContentUnfoldingFailed;

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 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 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;
}

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 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 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;
}

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;
}

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 GeometrySelectionEntry {
	entities: (GeometryEntity)[];
	data: StringIndexedInterface;
}

function isGeometrySelectionEntry(arg: unknown) : arg is GeometrySelectionEntry;

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;
}

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

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

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

interface JoiningReplyStateContentUndefinedError {
}

function isJoiningReplyStateContentUndefinedError(arg: unknown) : arg is JoiningReplyStateContentUndefinedError;

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 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 NodeEditingStateEntry {
	index: number;
	data: NodeEditingStateEntryMissingDatum;
}

function isNodeEditingStateEntry(arg: unknown) : arg is NodeEditingStateEntry;

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

function isNodeEditingStateEntryInvalidDatum(arg: unknown) : arg is NodeEditingStateEntryInvalidDatum;

interface NodeEditingStateEntryMissingDatum {
	nodeDatumType: NodeDatumType;
}

function isNodeEditingStateEntryMissingDatum(arg: unknown) : arg is NodeEditingStateEntryMissingDatum;

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

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

interface NodeUpdateJoining {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUpdatePackaging {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUpdateSheet {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

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

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

interface NodeUpdateSheetCutting {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	sheetThickness?: number;
	toggleUpperSide?: boolean;
}

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

interface NodeUpdateTransform {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUpdateTube {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUpdateTubeCutting {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUpdateUndefined {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUpdateUserDefined {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUpdateUserDefinedBase {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface NodeUserDataBase {
	bendLineEngravingMode: BendLineEngravingMode;
	purchasePartMaterialId: string;
	sheetMaterialId: string;
	tubeMaterialId: string;
	tubeSpecificationId: string;
	sheetFilterSheetIds: (string)[];
	sheetTappingData: (SheetTappingDataEntry)[];
}

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

interface PackagingReplyStateContentInsufficientPackageVolume {
}

function isPackagingReplyStateContentInsufficientPackageVolume(arg: unknown) : arg is PackagingReplyStateContentInsufficientPackageVolume;

interface PackagingReplyStateContentOverweightParts {
}

function isPackagingReplyStateContentOverweightParts(arg: unknown) : arg is PackagingReplyStateContentOverweightParts;

interface PackagingReplyStateContentUndefinedError {
}

function isPackagingReplyStateContentUndefinedError(arg: unknown) : arg is PackagingReplyStateContentUndefinedError;

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 PrivateEditingNote {
	type: string;
	message: string;
}

function isPrivateEditingNote(arg: unknown) : arg is PrivateEditingNote;

interface PrivateEditingNotesResourceEntry {
	nodeId: GraphNodeId;
	notes: (PrivateEditingNote)[];
}

function isPrivateEditingNotesResourceEntry(arg: unknown) : arg is PrivateEditingNotesResourceEntry;

interface PrivateForceSheetMetalPartResourceEntry {
	nodeId: GraphNodeId;
	canForceFuture: BooleanFuture;
}

function isPrivateForceSheetMetalPartResourceEntry(arg: unknown) : arg is PrivateForceSheetMetalPartResourceEntry;

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 PrivateManufacturingStateEntry {
	level: string;
	message: string;
}

function isPrivateManufacturingStateEntry(arg: unknown) : arg is PrivateManufacturingStateEntry;

interface PrivateManufacturingStateResourceEntry {
	nodeId: GraphNodeId;
	actualState: (PrivateManufacturingStateEntry)[];
	virtualState: (PrivateManufacturingStateEntry)[];
}

function isPrivateManufacturingStateResourceEntry(arg: unknown) : arg is PrivateManufacturingStateResourceEntry;

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 PrivateNodeRepresentation {
	nodeId: GraphNodeId;
	rootId: GraphNodeRootId;
	sourceNodeIds: (GraphNodeId)[];
	targetNodeIds: (GraphNodeId)[];
	workStepType: WorkStepType;
	processType: ProcessType;
	processId: string;
	processName: string;
	comment: string;
	hasTwoDimInput: boolean;
	hasCalcOverride: 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)[];
	editingNotes: (PrivateEditingNotesResourceEntry)[];
	manufacturingStates: (PrivateManufacturingStateResourceEntry)[];
	nodeTexts: (PrivateNodeTextResourceEntry)[];
	articleTexts: (PrivateArticleTextResourceEntry)[];
	articleCalcData: (PrivateArticleCalcDataResourceEntry)[];
	articleSignatureNodeData: (PrivateArticleSignatureNodeResourceEntry)[];
	nodeCalcData: (PrivateNodeCalcDataResourceEntry)[];
	nodeProblematicGeometryData: (PrivateProblematicGeometryResourceEntry)[];
	nodeForceSheetMetalPartData: (PrivateForceSheetMetalPartResourceEntry)[];
}

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;
}

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

interface ReplyStateIndicatorMap {
	undefined?: ReplyStateIndicatorsUndefined;
	sheet?: ReplyStateIndicatorsSheet;
	sheetCutting?: ReplyStateIndicatorsSheetCutting;
	joining?: ReplyStateIndicatorsJoining;
	tubeCutting?: ReplyStateIndicatorsTubeCutting;
	sheetBending?: ReplyStateIndicatorsSheetBending;
	userDefined?: ReplyStateIndicatorsUserDefined;
	userDefinedBase?: ReplyStateIndicatorsUserDefinedBase;
	packaging?: ReplyStateIndicatorsPackaging;
	transform?: ReplyStateIndicatorsTransform;
	tube?: ReplyStateIndicatorsTube;
}

function isReplyStateIndicatorMap(arg: unknown) : arg is ReplyStateIndicatorMap;

interface ReplyStateIndicatorsJoining {
	replyStateIndicators: ReplyStateMapJoining;
}

function isReplyStateIndicatorsJoining(arg: unknown) : arg is ReplyStateIndicatorsJoining;

interface ReplyStateIndicatorsPackaging {
	replyStateIndicators: ReplyStateMapPackaging;
}

function isReplyStateIndicatorsPackaging(arg: unknown) : arg is ReplyStateIndicatorsPackaging;

interface ReplyStateIndicatorsSheet {
	replyStateIndicators: ReplyStateMapSheet;
}

function isReplyStateIndicatorsSheet(arg: unknown) : arg is ReplyStateIndicatorsSheet;

interface ReplyStateIndicatorsSheetBending {
	replyStateIndicators: ReplyStateMapSheetBending;
}

function isReplyStateIndicatorsSheetBending(arg: unknown) : arg is ReplyStateIndicatorsSheetBending;

interface ReplyStateIndicatorsSheetCutting {
	replyStateIndicators: ReplyStateMapSheetCutting;
}

function isReplyStateIndicatorsSheetCutting(arg: unknown) : arg is ReplyStateIndicatorsSheetCutting;

interface ReplyStateIndicatorsTransform {
	replyStateIndicators: ReplyStateMapTransform;
}

function isReplyStateIndicatorsTransform(arg: unknown) : arg is ReplyStateIndicatorsTransform;

interface ReplyStateIndicatorsTube {
	replyStateIndicators: ReplyStateMapTube;
}

function isReplyStateIndicatorsTube(arg: unknown) : arg is ReplyStateIndicatorsTube;

interface ReplyStateIndicatorsTubeCutting {
	replyStateIndicators: ReplyStateMapTubeCutting;
}

function isReplyStateIndicatorsTubeCutting(arg: unknown) : arg is ReplyStateIndicatorsTubeCutting;

interface ReplyStateIndicatorsUndefined {
	replyStateIndicators: ReplyStateMapUndefined;
}

function isReplyStateIndicatorsUndefined(arg: unknown) : arg is ReplyStateIndicatorsUndefined;

interface ReplyStateIndicatorsUserDefined {
	replyStateIndicators: ReplyStateMapUserDefined;
}

function isReplyStateIndicatorsUserDefined(arg: unknown) : arg is ReplyStateIndicatorsUserDefined;

interface ReplyStateIndicatorsUserDefinedBase {
	replyStateIndicators: ReplyStateMapUserDefinedBase;
}

function isReplyStateIndicatorsUserDefinedBase(arg: unknown) : arg is ReplyStateIndicatorsUserDefinedBase;

interface ReplyStateMapJoining {
	undefinedError?: JoiningReplyStateContentUndefinedError;
}

function isReplyStateMapJoining(arg: unknown) : arg is ReplyStateMapJoining;

interface ReplyStateMapPackaging {
	undefinedError?: PackagingReplyStateContentUndefinedError;
	insufficientPackageVolume?: PackagingReplyStateContentInsufficientPackageVolume;
	overweightParts?: PackagingReplyStateContentOverweightParts;
}

function isReplyStateMapPackaging(arg: unknown) : arg is ReplyStateMapPackaging;

interface ReplyStateMapSheet {
	undefinedError?: SheetReplyStateContentUndefinedError;
	nestingFailed?: SheetReplyStateContentNestingFailedError;
}

function isReplyStateMapSheet(arg: unknown) : arg is ReplyStateMapSheet;

interface ReplyStateMapSheetBending {
	undefinedError?: BendReplyStateContentUndefinedError;
	multipleOuterContours?: BendReplyStateContentMultipleOuterContours;
	contourInBend?: BendReplyStateContentContourInBend;
	invalidBend?: BendReplyStateContentInvalidBend;
	undetectedFeatures?: BendReplyStateContentUndetectedFeatures;
	unfoldingFailed?: BendReplyStateContentUnfoldingFailed;
	bendDeductionApplicationFailed?: BendReplyStateContentBendDeductionApplicationFailed;
}

function isReplyStateMapSheetBending(arg: unknown) : arg is ReplyStateMapSheetBending;

interface ReplyStateMapSheetCutting {
	undefinedError?: SheetCuttingReplyStateContentUndefinedError;
	undetectedFeatures?: SheetCuttingReplyStateContentUndetectedFeatures;
	multipleOuterContours?: SheetCuttingReplyStateContentMultipleOuterContours;
	unused0?: Unused;
}

function isReplyStateMapSheetCutting(arg: unknown) : arg is ReplyStateMapSheetCutting;

interface ReplyStateMapTransform {
	undefinedError?: TransformReplyStateContentUndefinedError;
}

function isReplyStateMapTransform(arg: unknown) : arg is ReplyStateMapTransform;

interface ReplyStateMapTube {
	undefinedError?: TubeReplyStateContentUndefinedError;
}

function isReplyStateMapTube(arg: unknown) : arg is ReplyStateMapTube;

interface ReplyStateMapTubeCutting {
	undefinedError?: TubeCuttingReplyStateContentUndefinedError;
	undetectedFeatures?: TubeCuttingReplyStateContentUndetectedFeatures;
}

function isReplyStateMapTubeCutting(arg: unknown) : arg is ReplyStateMapTubeCutting;

interface ReplyStateMapUndefined {
	undefinedError?: UndefinedReplyStateContentUndefinedError;
}

function isReplyStateMapUndefined(arg: unknown) : arg is ReplyStateMapUndefined;

interface ReplyStateMapUserDefined {
	undefinedError?: UserDefinedReplyStateContentUndefinedError;
}

function isReplyStateMapUserDefined(arg: unknown) : arg is ReplyStateMapUserDefined;

interface ReplyStateMapUserDefinedBase {
	undefinedError?: UserDefinedBaseReplyStateContentUndefinedError;
}

function isReplyStateMapUserDefinedBase(arg: unknown) : arg is ReplyStateMapUserDefinedBase;

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

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

interface SceneConfig {
	elements?: SceneElements;
	sceneId?: string;
	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 {
	material: string;
	thickness: number;
	identifier: string;
	comment: string;
	globalMaterial: string;
}

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;
	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 SheetCuttingReplyStateContentMultipleOuterContours {
}

function isSheetCuttingReplyStateContentMultipleOuterContours(arg: unknown) : arg is SheetCuttingReplyStateContentMultipleOuterContours;

interface SheetCuttingReplyStateContentUndefinedError {
}

function isSheetCuttingReplyStateContentUndefinedError(arg: unknown) : arg is SheetCuttingReplyStateContentUndefinedError;

interface SheetCuttingReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}

function isSheetCuttingReplyStateContentUndetectedFeatures(arg: unknown) : arg is SheetCuttingReplyStateContentUndetectedFeatures;

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 SheetReplyStateContentNestingFailedError {
}

function isSheetReplyStateContentNestingFailedError(arg: unknown) : arg is SheetReplyStateContentNestingFailedError;

interface SheetReplyStateContentUndefinedError {
}

function isSheetReplyStateContentUndefinedError(arg: unknown) : arg is SheetReplyStateContentUndefinedError;

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;
}

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

interface SlNodeUpdatePackaging {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface SlNodeUpdateSheet {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

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

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

interface SlNodeUpdateSheetCutting {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	sheetThickness?: number;
	toggleUpperSide?: boolean;
}

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

interface SlNodeUpdateTransform {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface SlNodeUpdateTube {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface SlNodeUpdateTubeCutting {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface SlNodeUpdateUndefined {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface SlNodeUpdateUserDefined {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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

interface SlNodeUpdateUserDefinedBase {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}

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 TransformReplyStateContentUndefinedError {
}

function isTransformReplyStateContentUndefinedError(arg: unknown) : arg is TransformReplyStateContentUndefinedError;

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

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