WSi4 1.25.7

./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 AnyBomComponentDetails {
	index: number;
	data: BomComponentDetailsJoining;
}

function isAnyBomComponentDetails(arg: unknown) : arg is AnyBomComponentDetails;

interface AnyBomWorkStepDetails {
	index: number;
	data: BomWorkStepDetailsGeneric;
}

function isAnyBomWorkStepDetails(arg: unknown) : arg is AnyBomWorkStepDetails;

interface AnyCadFeatureDetails {
	index: number;
	data: CadFeatureDetailsCountersink;
}

function isAnyCadFeatureDetails(arg: unknown) : arg is AnyCadFeatureDetails;

interface AnyDataSource {
	index: number;
	data: DataSourceFilePath;
}

function isAnyDataSource(arg: unknown) : arg is AnyDataSource;

interface AnyErpStandardExportConfig {
	index: number;
	data: ErpStandardExportConfigTsGraphRep;
}

function isAnyErpStandardExportConfig(arg: unknown) : arg is AnyErpStandardExportConfig;

interface AnyErpStandardInterfaceConfig {
	index: number;
	data: ErpStandardInterfaceConfigTsGraphRep;
}

function isAnyErpStandardInterfaceConfig(arg: unknown) : arg is AnyErpStandardInterfaceConfig;

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 AppInput {
	projectUserData?: StringIndexedInterface;
	erpExportConfig?: AnyErpStandardExportConfig;
	inputFileEntries?: (InputFileEntry)[];
}

function isAppInput(arg: unknown) : arg is AppInput;

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

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

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 Bom {
	version: BomVersion;
	creator: string;
	projectName: string;
	components: (BomComponent)[];
	userData: StringIndexedInterface;
	graphSerializations: (BomGraphSerialization)[];
}

function isBom(arg: unknown) : arg is Bom;

interface BomAnnotation2 {
	point: BomPoint2;
	text: string;
}

function isBomAnnotation2(arg: unknown) : arg is BomAnnotation2;

interface BomAttachment {
	name: string;
	base64: string;
}

function isBomAttachment(arg: unknown) : arg is BomAttachment;

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

function isBomBendLine(arg: unknown) : arg is BomBendLine;

interface BomComponent {
	componentDescriptor: string;
	name: string;
	quantity: number;
	isImportComponent: boolean;
	sourceComponents: (BomSourceComponent)[];
	targetComponentDescriptors: (string)[];
	dimensions3: BomDimensions3;
	mass?: number;
	comment?: string;
	importId?: string;
	externalPartNumber?: string;
	externalDrawingNumber?: string;
	externalRevisionNumber?: string;
	details: AnyBomComponentDetails;
	sellingPrices: (BomScalePrice)[];
	workSteps: (BomWorkStep)[];
	userData?: StringIndexedInterface;
	generatedFiles: (BomGeneratedFile)[];
	attachments: (BomAttachment)[];
}

function isBomComponent(arg: unknown) : arg is BomComponent;

interface BomComponentDetailsJoining {
}

function isBomComponentDetailsJoining(arg: unknown) : arg is BomComponentDetailsJoining;

interface BomComponentDetailsPurchasePart {
}

function isBomComponentDetailsPurchasePart(arg: unknown) : arg is BomComponentDetailsPurchasePart;

interface BomComponentDetailsSheetMetalPart {
	thickness: number;
	area2: number;
	dimensions2: BomDimensions2;
	sheetMaterialId?: string;
	sheetConsumption?: BomSheetConsumption;
	millTestReportRequired: boolean;
}

function isBomComponentDetailsSheetMetalPart(arg: unknown) : arg is BomComponentDetailsSheetMetalPart;

interface BomComponentDetailsTubePart {
	extrusionLength: number;
	volume: number;
	profileGeometry: BomTubeProfileGeometry;
	tubeMaterialId?: string;
	tubeSpecificationId?: string;
	tubeConsumption?: BomTubeConsumption;
	millTestReportRequired: boolean;
}

function isBomComponentDetailsTubePart(arg: unknown) : arg is BomComponentDetailsTubePart;

interface BomCountersink {
	innerRadius: number;
	outerRadius: number;
	angle: number;
	depth: number;
}

function isBomCountersink(arg: unknown) : arg is BomCountersink;

interface BomDimensions2 {
	x: number;
	y: number;
}

function isBomDimensions2(arg: unknown) : arg is BomDimensions2;

interface BomDimensions3 {
	x: number;
	y: number;
	z: number;
}

function isBomDimensions3(arg: unknown) : arg is BomDimensions3;

interface BomGeneratedFile {
	type: BomGeneratedFileType;
	plainText?: string;
	base64?: string;
}

function isBomGeneratedFile(arg: unknown) : arg is BomGeneratedFile;

interface BomGraphSerialization {
	componentDescriptors: (string)[];
	base64: string;
}

function isBomGraphSerialization(arg: unknown) : arg is BomGraphSerialization;

interface BomPoint2 {
	x: number;
	y: number;
}

function isBomPoint2(arg: unknown) : arg is BomPoint2;

interface BomScalePrice {
	scaleValue: number;
	unitPrice: number;
}

function isBomScalePrice(arg: unknown) : arg is BomScalePrice;

interface BomSheetConsumption {
	sheetId: string;
	sheetDimensions: BomDimensions2;
	netConsumptionSheetsPerPart: number;
	grossConsumptionSheetsPerPart: number;
	netConsumptionMassPerPart: number;
	grossConsumptionMassPerPart: number;
	materialCostPerPart: number;
	setupCost: number;
	unitCostPerPart: number;
}

function isBomSheetConsumption(arg: unknown) : arg is BomSheetConsumption;

interface BomSourceComponent {
	componentDescriptor: string;
	quantity: number;
}

function isBomSourceComponent(arg: unknown) : arg is BomSourceComponent;

interface BomTubeConsumption {
	tubeId: string;
	tubeLength: number;
	netConsumptionTubesPerPart: number;
	grossConsumptionTubesPerPart: number;
	netConsumptionMassPerPart: number;
	grossConsumptionMassPerPart: number;
	materialCostPerPart: number;
	setupCost: number;
	unitCostPerPart: number;
}

function isBomTubeConsumption(arg: unknown) : arg is BomTubeConsumption;

interface BomTubeProfileGeometry {
	index: number;
	data: BomTubeProfileGeometryCircular;
}

function isBomTubeProfileGeometry(arg: unknown) : arg is BomTubeProfileGeometry;

interface BomTubeProfileGeometryCircular {
	thickness: number;
	diameter: number;
}

function isBomTubeProfileGeometryCircular(arg: unknown) : arg is BomTubeProfileGeometryCircular;

interface BomTubeProfileGeometryRectangular {
	thickness: number;
	dimensions2: BomDimensions2;
}

function isBomTubeProfileGeometryRectangular(arg: unknown) : arg is BomTubeProfileGeometryRectangular;

interface BomWorkStep {
	processType: ProcessType;
	costCenter?: string;
	comment?: string;
	setupTime?: number;
	unitTimePerPart?: number;
	materialCostPerPart?: number;
	setupCost?: number;
	unitCostPerPart?: number;
	userDefinedManufacturingCosts?: (BomScalePrice)[];
	details: AnyBomWorkStepDetails;
	generatedFiles: (BomGeneratedFile)[];
	attachments: (BomAttachment)[];
}

function isBomWorkStep(arg: unknown) : arg is BomWorkStep;

interface BomWorkStepDetailsCoating {
	coatingId?: string;
	coatingAreaPerPart: number;
}

function isBomWorkStepDetailsCoating(arg: unknown) : arg is BomWorkStepDetailsCoating;

interface BomWorkStepDetailsCountersinking {
	countersinks: (BomCountersink)[];
}

function isBomWorkStepDetailsCountersinking(arg: unknown) : arg is BomWorkStepDetailsCountersinking;

interface BomWorkStepDetailsGeneric {
}

function isBomWorkStepDetailsGeneric(arg: unknown) : arg is BomWorkStepDetailsGeneric;

interface BomWorkStepDetailsMechanicalDeburring {
	doubleSided: boolean;
}

function isBomWorkStepDetailsMechanicalDeburring(arg: unknown) : arg is BomWorkStepDetailsMechanicalDeburring;

interface BomWorkStepDetailsSheetBending {
	bendLines: (BomBendLine)[];
}

function isBomWorkStepDetailsSheetBending(arg: unknown) : arg is BomWorkStepDetailsSheetBending;

interface BomWorkStepDetailsSheetCutting {
	contourLength: number;
	contourCount: number;
	fixedRotations?: (number)[];
}

function isBomWorkStepDetailsSheetCutting(arg: unknown) : arg is BomWorkStepDetailsSheetCutting;

interface BomWorkStepDetailsSheetTapping {
	annotations: (BomAnnotation2)[];
}

function isBomWorkStepDetailsSheetTapping(arg: unknown) : arg is BomWorkStepDetailsSheetTapping;

interface BomWorkStepDetailsTubeCutting {
	contourLength: number;
	contourCount: number;
}

function isBomWorkStepDetailsTubeCutting(arg: unknown) : arg is BomWorkStepDetailsTubeCutting;

interface BomWorkStepDetailsUserDefinedCountersinking {
	count: number;
}

function isBomWorkStepDetailsUserDefinedCountersinking(arg: unknown) : arg is BomWorkStepDetailsUserDefinedCountersinking;

interface BomWorkStepDetailsUserDefinedThreading {
	count: number;
}

function isBomWorkStepDetailsUserDefinedThreading(arg: unknown) : arg is BomWorkStepDetailsUserDefinedThreading;

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 CadFeatureDetailsCountersink {
	innerRadius: number;
	outerRadius: number;
	angle: number;
	depth: number;
	surfaceFlag: SheetSurfaceFlag;
}

function isCadFeatureDetailsCountersink(arg: unknown) : arg is CadFeatureDetailsCountersink;

interface CadFeatureDetailsThroughHole {
	radius: number;
}

function isCadFeatureDetailsThroughHole(arg: unknown) : arg is CadFeatureDetailsThroughHole;

interface CadFeatureGroup {
	index: number;
	descriptors: (number)[];
}

function isCadFeatureGroup(arg: unknown) : arg is CadFeatureGroup;

interface CadImportConfig {
	sheetUpperSideStrategy?: SheetUpperSideStrategy;
}

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

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 CamCommandApplyCadFeatures {
	descriptors: (number)[];
}

function isCamCommandApplyCadFeatures(arg: unknown) : arg is CamCommandApplyCadFeatures;

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

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

interface DataSourceFileContent {
	contentType: FileContentType;
	data: string;
}

function isDataSourceFileContent(arg: unknown) : arg is DataSourceFileContent;

interface DataSourceFilePath {
	path: string;
}

function isDataSourceFilePath(arg: unknown) : arg is DataSourceFilePath;

interface DefaultCalcJson {
	displayName: string;
	json: string;
}

function isDefaultCalcJson(arg: unknown) : arg is DefaultCalcJson;

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: (DocumentTableCell)[];
	rows: ((DocumentTableCell)[])[];
}

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

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

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

interface ErpStandardExportConfigBom {
	bomVersion: BomVersion;
	serverUrl?: string;
	filePath?: string;
	articleNameMaxLength?: number;
	erpExportModeEnabled?: boolean;
	exportFlags?: BomExportFlags;
}

function isErpStandardExportConfigBom(arg: unknown) : arg is ErpStandardExportConfigBom;

interface ErpStandardExportConfigTsGraphRep {
	serverUrl?: string;
	filePath?: string;
	articleNameMaxLength?: number;
	erpExportModeEnabled?: boolean;
	resourceTypes?: TsGraphRepResourceTypes;
}

function isErpStandardExportConfigTsGraphRep(arg: unknown) : arg is ErpStandardExportConfigTsGraphRep;

interface ErpStandardInterfaceConfigBom {
	bomVersion: BomVersion;
	exportFlags: BomExportFlags;
}

function isErpStandardInterfaceConfigBom(arg: unknown) : arg is ErpStandardInterfaceConfigBom;

interface ErpStandardInterfaceConfigTsGraphRep {
	graphRepVersion: TsGraphRepVersion;
	resourceTypes: TsGraphRepResourceTypes;
}

function isErpStandardInterfaceConfigTsGraphRep(arg: unknown) : arg is ErpStandardInterfaceConfigTsGraphRep;

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 {
	importUuid: string;
	userImportId: string;
	innerOuterPolygon: InnerOuterPolygon;
	depth: number;
	assemblyName: string;
	multiplicity: number;
}

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

interface GraphCreatorInputStep {
	importUuid: string;
	userImportId: string;
	data: ArrayBuffer;
	multiplicity: number;
}

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

interface GraphCreatorInputTwoDimRep {
	importUuid: string;
	userImportId: 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 GuiSheetExtraData {
	extraText: string;
	nestingDissections: (NestingDissection)[];
}

function isGuiSheetExtraData(arg: unknown) : arg is GuiSheetExtraData;

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

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

interface HandlerPostProcessCreateSources {
}

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 InitialSheetFilter {
	sheetId?: string;
	sheetMaterialId?: string;
}

function isInitialSheetFilter(arg: unknown) : arg is InitialSheetFilter;

interface InitialTubeFilter {
	tubeId?: string;
	tubeMaterialId?: string;
	tubeSpecificationId?: string;
}

function isInitialTubeFilter(arg: unknown) : arg is InitialTubeFilter;

interface InputFileEntry {
	dataSource: AnyDataSource;
	importId?: string;
	multiplicity?: number;
	articleName?: string;
	sheetThickness?: number;
	sheetId?: string;
	sheetMaterialId?: string;
	tubeId?: string;
	tubeMaterialId?: string;
	tubeSpecificationId?: string;
}

function isInputFileEntry(arg: unknown) : arg is InputFileEntry;

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 {
	bendDescriptor: number;
	constructedInnerRadius: number;
	resultingInnerRadius: number;
}

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

interface NodeIssueBendZoneAffectsContour {
}

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

interface NodeIssueCadFeatureUnhandled {
}

function isNodeIssueCadFeatureUnhandled(arg: unknown) : arg is NodeIssueCadFeatureUnhandled;

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;
	constructedInnerRadius: number;
	closestResultingInnerRadius: number;
}

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

interface NodeIssueDimensionConstraintViolated {
	actualDimensions: [ (number), (number), (number), ];
	violatedLowerConstraints?: [ (number), (number), (number), ];
	violatedUpperConstraints?: [ (number), (number), (number), ];
}

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

interface NodeIssueFeatureNotLicensed {
	feature: Feature;
}

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;
	tubeFilterTubeIds: (string)[];
	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 PrivateMainWindowErpConfig {
	standardExportToThirdPartyEnabled: boolean;
	standardExportToFileEnabled: boolean;
	erpExportModeEnabled: boolean;
	articleNameMaxLength?: number;
}

function isPrivateMainWindowErpConfig(arg: unknown) : arg is PrivateMainWindowErpConfig;

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)[];
	erpConfig: PrivateMainWindowErpConfig;
}

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;
	guiSheetExtraData?: GuiSheetExtraData;
	fixedRotation?: number;
}

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;
	erpStandardInterfaceConfig: AnyErpStandardInterfaceConfig;
	sheetNestingDistance: number;
	sheetUpperSideStrategy: SheetUpperSideStrategy;
	tubeClampingLength: number;
	tubeNestingDistance: 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;