declare type AddResultStatus = "success" | "unsupportedFormat" | "versionMismatch" | "inconsistentGraph" | "undefinedError" | "unsupportedVersion";
declare type BendDieChoiceType = "database" | "neutralAxis";
declare type BendLineEngravingMode = "none" | "upwardOnly" | "downwardOnly" | "all";
declare type CadFeatureType = "countersinking" | "throughHole";
declare type CamCommandType = "setColor";
declare type Color = "black" | "white" | "green" | "yellow" | "cyan" | "blue" | "magenta" | "none" | "red" | "lightgrey" | "lime" | "turquoise" | "violet" | "saddlebrown" | "darkorange" | "sienna" | "closedContour" | "closedInnerContour" | "closedOuterContour" | "openContour" | "engraving" | "bendLine" | "bendLineUp" | "bendLineDown" | "darkGreen";
declare type DatabasePermission = "read" | "write";
declare type DatabaseType = "mssql";
declare type DocXImageType = "png";
declare type DocXTableCellType = "text" | "image" | "tables";
declare type DocumentAlignment = "left" | "center" | "right";
declare type DocumentImageType = "png" | "svg";
declare type DocumentItemType = "paragraph" | "heading" | "table" | "image" | "barcode" | "separator" | "pageBreak";
declare type DocumentOrientation = "portrait" | "landscape";
declare type Feature = "bendMeasurementScene" | "bomExport" | "graphRepExport" | "unlimitedNumExports" | "httpServiceUnfold" | "httpServiceNestor" | "httpServiceAssemblyTree" | "httpServiceClassifier" | "lstExport" | "erpInterfaceItBlech" | "tubeDetection" | "quotationExport" | "developmentAccount";
declare type FileDialogType = "openFile" | "openFiles" | "saveFile" | "directory";
declare type FileSystemPathType = "directory" | "openFile" | "saveFile";
declare type FileType = "svg" | "dxf" | "step" | "png" | "geo";
declare type FormWidgetType = "checkBox" | "spinBox" | "dropDown" | "lineEdit" | "textEdit" | "label";
declare type GeometryEntityType = "edge" | "face";
declare type GeometrySelectorConfigFlag = "edge" | "face";
declare type GraphCreatorInputType = "step" | "twoDimRep" | "extrusion";
declare type GraphNodeProcessingState = "CreateWorkStep" | "UpdateWorkStep" | "CreateSources" | "FillFromSources" | "AfterFillFromSources" | "Finished";
declare type InputType = "undefined" | "documentGraph" | "assembly" | "layered" | "twoDimRep";
declare type LocaleType = "language" | "csv";
declare type LstEvaporateMode = "none" | "early" | "beforeEachPart";
declare type MessageBoxType = "info" | "warning" | "error" | "question";
declare type NodeConstraint = "bendDeductionThicknessInBounds" | "bendDiesAssigned" | "bendFlangeLengthInBounds" | "bendLineLengthInBounds" | "contourBendZoneUnaffected" | "sheetCuttingContourSizeInBounds" | "editingStateOk" | "dimensionsInBounds" | "materialsCompatible" | "sheetCuttingThicknessInBounds" | "tubeCuttingProfileSupported" | "semimanufacturedAvailable" | "sheetCuttingProcessCompatible" | "tubeCuttingProcessCompatible" | "tubeDetectionLicensed" | "unfoldingSimple";
declare type NodeDatumType = "processId" | "sheetMaterialId" | "tubeMaterialId" | "tubeSpecificationId" | "sheetTappingData" | "dieChoiceMap";
declare type NodeEditingStateEntryType = "missingDatum" | "invalidDatum";
declare type NodeUserDataKey = "attachments" | "bendLineEngravingMode" | "comment" | "deburrDoubleSided" | "fixedRotations" | "numCountersinks" | "numThreads" | "purchasePartMaterialId" | "sheetFilterSheetIds" | "sheetMaterialId" | "sheetTappingData" | "testReportRequired" | "tubeMaterialId" | "tubeSpecificationId" | "userDefinedMaterialCostsPerPiece" | "userDefinedScalePrices" | "userDefinedSetupTime" | "userDefinedUnitTimePerPiece";
declare type PrivateGuiDataType = "graphRep";
declare type PrivateMainWindowMenuType = "fileRun" | "fileExport";
declare type ProcessType = "undefined" | "manufacturing" | "semiManufactured" | "sheetCutting" | "laserSheetCutting" | "joining" | "externalPart" | "sheet" | "userDefinedBaseType" | "assembling" | "forceFitting" | "joiningByWelding" | "joiningByBrazing" | "bonding" | "autogenousWelding" | "arcWelding" | "gasShieldedWelding" | "migWelding" | "magWelding" | "tigWelding" | "plasmaWelding" | "laserWelding" | "weldingWithPressure" | "resistanceWelding" | "studWelding" | "forming" | "bendForming" | "bendingWithoutTool" | "dieBending" | "sheetMetalFolding" | "cutting" | "removalOperation" | "plasmaSheetCutting" | "waterJetSheetCutting" | "machining" | "milling" | "turning" | "drilling" | "threading" | "mechanicalDeburring" | "cleaning" | "coating" | "sprayPainting" | "powderCoating" | "sheetBending" | "transport" | "packaging" | "automaticMechanicalDeburring" | "manualMechanicalDeburring" | "userDefinedMachining" | "userDefinedThreading" | "userDefinedCountersinking" | "slideGrinding" | "sheetTapping" | "userDefinedTube" | "tube" | "tubeCutting";
declare type ReplyStateIndicatorJoining = "undefinedError";
declare type ReplyStateIndicatorPackaging = "undefinedError" | "insufficientPackageVolume" | "overweightParts";
declare type ReplyStateIndicatorSheet = "undefinedError" | "nestingFailed";
declare type ReplyStateIndicatorSheetBending = "undefinedError" | "multipleOuterContours" | "contourInBend" | "invalidBend" | "undetectedFeatures" | "unfoldingFailed" | "bendDeductionApplicationFailed";
declare type ReplyStateIndicatorSheetCutting = "undefinedError" | "undetectedFeatures" | "multipleOuterContours" | "unused0";
declare type ReplyStateIndicatorTransform = "undefinedError";
declare type ReplyStateIndicatorTube = "undefinedError";
declare type ReplyStateIndicatorTubeCutting = "undefinedError" | "undetectedFeatures";
declare type ReplyStateIndicatorUndefined = "undefinedError";
declare type ReplyStateIndicatoruserDefined = "undefinedError";
declare type ReplyStateIndicatoruserDefinedBase = "undefinedError";
declare type SceneElement = "cuttingContours" | "engravings" | "sheetBendingBendLineLabels" | "sheetBendingBendZones" | "sheetBendingDieAffectedSegments" | "sheetBendingLowerDieAffectZones" | "sheetBendingOverlappingAreas" | "tubeCuttingTubeContours" | "tubeCuttingVirtualCuts";
declare type SegmentType = "line" | "arc";
declare type SettingsTableKey = "bendFlangeSafetyDistance" | "dieBendingSetupTimeDistributionEnabled" | "tubeClampingLength";
declare type SheetCorner = "lowerLeft" | "upperLeft" | "lowerRight" | "upperRight";
declare type SheetUpperSideStrategy = "preferUpwardBends" | "preferDownwardBends" | "preferConvexity" | "preferConcavity";
declare type StrokeStyle = "continuous" | "dashed";
declare type TableErrorType = "referringEntryMissing" | "referredEntryMissing" | "valueInvalid" | "uniqueMemberCollision";
declare type TableMergeMode = "update" | "upsert";
declare type TableType = "sheetMaterial" | "sheetMaterialDensity" | "sheetCuttingMaterialMapping" | "sheetBendingMaterialMapping" | "bendTime" | "bendTimeParameters" | "bendRateParameters" | "bendLineConstraint" | "laserSheetCuttingGas" | "laserSheetCuttingSpeed" | "laserSheetCuttingPierceTime" | "laserSheetCuttingRate" | "laserSheetCuttingMinArea" | "laserSheetCuttingMaxThickness" | "packaging" | "transportationCosts" | "surcharge" | "process" | "processRate" | "processSetupTimeFallback" | "processUnitTimeFallback" | "sheet" | "sheetModulus" | "sheetPrice" | "upperDieGroup" | "lowerDieGroup" | "bendDeduction" | "setting" | "automaticMechanicalDeburringMaterial" | "automaticMechanicalDeburringParameters" | "dimensionConstraints" | "screwThread" | "tappingTimeParameters" | "tubeMaterial" | "tubeMaterialDensity" | "tubeProfile" | "tubeSpecification" | "tube" | "upperDie" | "lowerDie" | "upperDieUnit" | "lowerDieUnit" | "processHandlingTime" | "sheetStock" | "processIdlePeriod" | "sheetMaterialScrapValue" | "sheetPriority" | "dieGroupPriority" | "sheetCuttingMaterial" | "sheetBendingMaterial" | "tubeCuttingProcess" | "tubeCuttingProcessMapping" | "tubeCuttingSpeed" | "tubeCuttingPierceTime" | "tubePrice" | "tubeStock" | "tubeMaterialScrapValue" | "sheetCuttingProcess" | "sheetCuttingProcessMapping" | "sheetCuttingMotionParameters" | "sheetCuttingProcessToLaserCuttingGas" | "purchasePartMaterial" | "processConstraintsSheetMaterial" | "processConstraintsTubeMaterial" | "processConstraintsPurchasePartMaterial" | "consumable" | "processConsumableRate" | "sheetCuttingProcessConsumableRate" | "tubeCuttingProcessConsumableRate" | "sheetCuttingThicknessConstraints";
declare type TrumpfLoadingSystem = "manual" | "paletteChange" | "paletteChangeLiftMaster" | "onePalette" | "paletteChangeLiftMasterSort" | "paletteChangeLiftMasterSortPullingDevice";
declare type TubeProfileGeometryType = "rectangular" | "circular";
declare type TwoDimImportResultType = "partInvalid" | "engravingInvalid" | "success";
declare type UserDatumType = "string" | "number" | "boolean" | "enumeration";
declare type WidgetType = "assemblyView" | "attachmentEditor" | "bendingToolEditor" | "bulkEditor" | "calcParamEditor" | "fileDialog" | "formEditor" | "geometrySelector" | "geometryColorSelector" | "joiningSequenceEditor" | "layeredImportDialog" | "messageBox" | "processSelector" | "sheetFilterEditor" | "sheetTappingEditor" | "userDataConfigEditor";
declare type WorkStepType = "undefined" | "sheet" | "sheetCutting" | "joining" | "tubeCutting" | "sheetBending" | "userDefined" | "userDefinedBase" | "packaging" | "transform" | "tube";
declare interface DatabasePermissions {
	read: boolean;
	write: boolean;
}
declare interface GeometrySelectorConfigFlags {
	edge: boolean;
	face: boolean;
}
declare interface SceneElements {
	cuttingContours: boolean;
	engravings: boolean;
	sheetBendingBendLineLabels: boolean;
	sheetBendingBendZones: boolean;
	sheetBendingDieAffectedSegments: boolean;
	sheetBendingLowerDieAffectZones: boolean;
	sheetBendingOverlappingAreas: boolean;
	tubeCuttingTubeContours: boolean;
	tubeCuttingVirtualCuts: boolean;
}
declare interface ArrayBufferFuture { _nonexistent_ArrayBufferFuture: never; }
declare interface Assembly { _nonexistent_Assembly: never; }
declare interface AssemblyFuture { _nonexistent_AssemblyFuture: never; }
declare interface BooleanFuture { _nonexistent_BooleanFuture: never; }
declare interface Brep { _nonexistent_Brep: never; }
declare interface CadPart { _nonexistent_CadPart: never; }
declare interface DocumentGraph { _nonexistent_DocumentGraph: never; }
declare interface DracoRepresentation { _nonexistent_DracoRepresentation: never; }
declare interface GraphNodeId { _nonexistent_GraphNodeId: never; }
declare interface GraphNodeRootId { _nonexistent_GraphNodeRootId: never; }
declare interface ImportedDocumentGraph { _nonexistent_ImportedDocumentGraph: never; }
declare interface InnerOuterPolygon { _nonexistent_InnerOuterPolygon: never; }
declare interface Layered { _nonexistent_Layered: never; }
declare interface MeasurementScenesFuture { _nonexistent_MeasurementScenesFuture: never; }
declare interface Nest3ResultFuture { _nonexistent_Nest3ResultFuture: never; }
declare interface Polygon { _nonexistent_Polygon: never; }
declare interface PolygonFuture { _nonexistent_PolygonFuture: never; }
declare interface PreDocumentGraph { _nonexistent_PreDocumentGraph: never; }
declare interface ProfileShadowFuture { _nonexistent_ProfileShadowFuture: never; }
declare interface Scene { _nonexistent_Scene: never; }
declare interface SceneFuture { _nonexistent_SceneFuture: never; }
declare interface SlVertex { _nonexistent_SlVertex: never; }
declare interface TwoDimRepOptionalFuture { _nonexistent_TwoDimRepOptionalFuture: never; }
declare interface TwoDimRepresentation { _nonexistent_TwoDimRepresentation: never; }
declare interface Vertex { _nonexistent_Vertex: never; }
declare interface StringIndexedInterface {
	[index: string]: unknown;
}
type AnyTable = {
		type: "sheetMaterial";
		content: (SheetMaterial)[];
	} | {
		type: "sheetMaterialDensity";
		content: (SheetMaterialDensity)[];
	} | {
		type: "sheetCuttingMaterialMapping";
		content: (SheetCuttingMaterialMapping)[];
	} | {
		type: "sheetBendingMaterialMapping";
		content: (SheetBendingMaterialMapping)[];
	} | {
		type: "bendTime";
		content: (BendTime)[];
	} | {
		type: "bendTimeParameters";
		content: (BendTimeParameters)[];
	} | {
		type: "bendRateParameters";
		content: (BendRateParameters)[];
	} | {
		type: "bendLineConstraint";
		content: (BendLineConstraint)[];
	} | {
		type: "laserSheetCuttingGas";
		content: (LaserSheetCuttingGas)[];
	} | {
		type: "laserSheetCuttingSpeed";
		content: (LaserSheetCuttingSpeed)[];
	} | {
		type: "laserSheetCuttingPierceTime";
		content: (LaserSheetCuttingPierceTime)[];
	} | {
		type: "laserSheetCuttingRate";
		content: (LaserSheetCuttingRate)[];
	} | {
		type: "laserSheetCuttingMinArea";
		content: (LaserSheetCuttingMinArea)[];
	} | {
		type: "laserSheetCuttingMaxThickness";
		content: (LaserSheetCuttingMaxThickness)[];
	} | {
		type: "packaging";
		content: (Packaging)[];
	} | {
		type: "transportationCosts";
		content: (TransportationCosts)[];
	} | {
		type: "surcharge";
		content: (Surcharge)[];
	} | {
		type: "process";
		content: (Process)[];
	} | {
		type: "processRate";
		content: (ProcessRate)[];
	} | {
		type: "processSetupTimeFallback";
		content: (ProcessSetupTimeFallback)[];
	} | {
		type: "processUnitTimeFallback";
		content: (ProcessUnitTimeFallback)[];
	} | {
		type: "sheet";
		content: (Sheet)[];
	} | {
		type: "sheetModulus";
		content: (SheetModulus)[];
	} | {
		type: "sheetPrice";
		content: (SheetPrice)[];
	} | {
		type: "upperDieGroup";
		content: (UpperDieGroup)[];
	} | {
		type: "lowerDieGroup";
		content: (LowerDieGroup)[];
	} | {
		type: "bendDeduction";
		content: (BendDeduction)[];
	} | {
		type: "setting";
		content: (Setting)[];
	} | {
		type: "automaticMechanicalDeburringMaterial";
		content: (AutomaticMechanicalDeburringMaterial)[];
	} | {
		type: "automaticMechanicalDeburringParameters";
		content: (AutomaticMechanicalDeburringParameters)[];
	} | {
		type: "dimensionConstraints";
		content: (DimensionConstraints)[];
	} | {
		type: "screwThread";
		content: (ScrewThread)[];
	} | {
		type: "tappingTimeParameters";
		content: (TappingTimeParameters)[];
	} | {
		type: "tubeMaterial";
		content: (TubeMaterial)[];
	} | {
		type: "tubeMaterialDensity";
		content: (TubeMaterialDensity)[];
	} | {
		type: "tubeProfile";
		content: (TubeProfile)[];
	} | {
		type: "tubeSpecification";
		content: (TubeSpecification)[];
	} | {
		type: "tube";
		content: (Tube)[];
	} | {
		type: "upperDie";
		content: (UpperDie)[];
	} | {
		type: "lowerDie";
		content: (LowerDie)[];
	} | {
		type: "upperDieUnit";
		content: (UpperDieUnit)[];
	} | {
		type: "lowerDieUnit";
		content: (LowerDieUnit)[];
	} | {
		type: "processHandlingTime";
		content: (ProcessHandlingTime)[];
	} | {
		type: "sheetStock";
		content: (SheetStock)[];
	} | {
		type: "processIdlePeriod";
		content: (ProcessIdlePeriod)[];
	} | {
		type: "sheetMaterialScrapValue";
		content: (SheetMaterialScrapValue)[];
	} | {
		type: "sheetPriority";
		content: (SheetPriority)[];
	} | {
		type: "dieGroupPriority";
		content: (DieGroupPriority)[];
	} | {
		type: "sheetCuttingMaterial";
		content: (SheetCuttingMaterial)[];
	} | {
		type: "sheetBendingMaterial";
		content: (SheetBendingMaterial)[];
	} | {
		type: "tubeCuttingProcess";
		content: (TubeCuttingProcess)[];
	} | {
		type: "tubeCuttingProcessMapping";
		content: (TubeCuttingProcessMapping)[];
	} | {
		type: "tubeCuttingSpeed";
		content: (TubeCuttingSpeed)[];
	} | {
		type: "tubeCuttingPierceTime";
		content: (TubeCuttingPierceTime)[];
	} | {
		type: "tubePrice";
		content: (TubePrice)[];
	} | {
		type: "tubeStock";
		content: (TubeStock)[];
	} | {
		type: "tubeMaterialScrapValue";
		content: (TubeMaterialScrapValue)[];
	} | {
		type: "sheetCuttingProcess";
		content: (SheetCuttingProcess)[];
	} | {
		type: "sheetCuttingProcessMapping";
		content: (SheetCuttingProcessMapping)[];
	} | {
		type: "sheetCuttingMotionParameters";
		content: (SheetCuttingMotionParameters)[];
	} | {
		type: "sheetCuttingProcessToLaserCuttingGas";
		content: (SheetCuttingProcessToLaserCuttingGas)[];
	} | {
		type: "purchasePartMaterial";
		content: (PurchasePartMaterial)[];
	} | {
		type: "processConstraintsSheetMaterial";
		content: (ProcessConstraintsSheetMaterial)[];
	} | {
		type: "processConstraintsTubeMaterial";
		content: (ProcessConstraintsTubeMaterial)[];
	} | {
		type: "processConstraintsPurchasePartMaterial";
		content: (ProcessConstraintsPurchasePartMaterial)[];
	} | {
		type: "consumable";
		content: (Consumable)[];
	} | {
		type: "processConsumableRate";
		content: (ProcessConsumableRate)[];
	} | {
		type: "sheetCuttingProcessConsumableRate";
		content: (SheetCuttingProcessConsumableRate)[];
	} | {
		type: "tubeCuttingProcessConsumableRate";
		content: (TubeCuttingProcessConsumableRate)[];
	} | {
		type: "sheetCuttingThicknessConstraints";
		content: (SheetCuttingThicknessConstraints)[];
	};
declare interface ArcSegment {
	from: Point2;
	to: Point2;
	center: Point2;
	ccw: boolean;
}
declare interface ArticleAttributes {
	userData: StringIndexedInterface;
}
declare interface ArticleUpdate {
	vertex: Vertex;
	articleUserData?: StringIndexedInterface;
}
declare interface AssemblyMapEntry {
	id: string;
	assembly: Assembly;
}
declare interface AssemblyPath {
	indices: (number)[];
}
declare interface Attachment {
	name: string;
	data: string;
}
declare interface AutomaticMechanicalDeburringMaterialUniqueMembers {
	sheetMaterialId: string;
}
declare interface AutomaticMechanicalDeburringMaterial extends AutomaticMechanicalDeburringMaterialUniqueMembers{
	automaticMechanicalDeburringMaterialId: string;
}
declare interface AutomaticMechanicalDeburringParametersUniqueMembers {
	automaticMechanicalDeburringMaterialId: string;
}
declare interface AutomaticMechanicalDeburringParameters extends AutomaticMechanicalDeburringParametersUniqueMembers{
	maxDimY: number;
	unitTimeBase: number;
	speed: number;
}
declare interface BendDeductionUniqueMembers {
	sheetBendingMaterialId: string;
	upperDieGroupId: string;
	lowerDieGroupId: string;
	thickness: number;
	bendAngle: number;
}
declare interface BendDeduction extends BendDeductionUniqueMembers{
	innerRadius: number;
	sharpDeduction: number;
}
declare interface BendDieAffectDistanceEntry {
	bendDescriptor: number;
	affectDistance: number;
}
declare interface BendDieChoice {
	baseClass: CamBendDeduction;
	upperDieGroupId: string;
	lowerDieGroupId: string;
	thickness: number;
	type: BendDieChoiceType;
	sharpDeduction: number;
}
declare interface BendLineConstraintUniqueMembers {
	sheetBendingMaterialId: string;
	thickness: number;
}
declare interface BendLineConstraint extends BendLineConstraintUniqueMembers{
	maxNetLength: number;
}
declare interface BendLineData {
	constructedInnerRadius: number;
	resultingInnerRadius: number;
	bendAngle: number;
	bendDescriptor: number;
}
declare interface BendLineFlangeLength {
	flangeLengthLhs: number;
	flangeLengthRhs: number;
	bendDescriptor: number;
}
declare interface BendLineSegmentsMapEntry {
	bendDescriptor: number;
	segments: (Segment)[];
}
declare interface BendRateParametersUniqueMembers {
	sheetBendingMaterialId: string;
	thickness: number;
	bendLineNetLength: number;
}
declare interface BendRateParameters extends BendRateParametersUniqueMembers{
	hourlyRateFactor: number;
	hourlyRateDelta: number;
}
declare interface BendReplyStateContentBendDeductionApplicationFailed {
}
declare interface BendReplyStateContentContourInBend {
}
declare interface BendReplyStateContentInvalidBend {
}
declare interface BendReplyStateContentMultipleOuterContours {
}
declare interface BendReplyStateContentUndefinedError {
}
declare interface BendReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}
declare interface BendReplyStateContentUnfoldingFailed {
}
declare interface BendTimeUniqueMembers {
	mass: number;
}
declare interface BendTime extends BendTimeUniqueMembers{
	setupTime: number;
	setupTimePerBend: number;
	unitTime: number;
	unitTimePerBend: number;
}
declare interface BendTimeParametersUniqueMembers {
	sheetBendingMaterialId: string;
	thickness: number;
	bendLineNetLength: number;
}
declare interface BendTimeParameters extends BendTimeParametersUniqueMembers{
	setupTimeFactor: number;
	setupTimeDelta: number;
	setupTimePerBendFactor: number;
	setupTimePerBendDelta: number;
	unitTimeFactor: number;
	unitTimeDelta: number;
	unitTimePerBendFactor: number;
	unitTimePerBendDelta: number;
}
declare interface BendingToolEditorInputEntry {
	bendDescriptor: number;
	angle: number;
	constructedInnerRadius: number;
	bendDieChoices: (BendDieChoice)[];
}
declare interface Box2 {
	lower: Point2;
	upper: Point2;
}
declare interface Box3 {
	lower: Point3;
	upper: Point3;
}
type BulkEditorCellConfig = {
		type: "checkBox";
		content: BulkEditorCheckBoxConfig;
	} | {
		type: "spinBox";
		content: BulkEditorSpinBoxConfig;
	} | {
		type: "dropDown";
		content: BulkEditorDropDownConfig;
	} | {
		type: "lineEdit";
		content: BulkEditorLineEditConfig;
	} | {
		type: "textEdit";
		content: BulkEditorTextEditConfig;
	} | {
		type: "label";
		content: BulkEditorLabelConfig;
	};
declare interface BulkEditorCheckBoxConfig {
	initialValue?: boolean;
	isOptional: boolean;
}
declare interface BulkEditorColumnConfig {
	key: string;
	name: string;
}
declare interface BulkEditorDropDownConfig {
	initialValue?: string;
	items: (BulkEditorDropDownItem)[];
	isOptional: boolean;
}
declare interface BulkEditorDropDownItem {
	id: string;
	name: string;
}
declare interface BulkEditorLabelConfig {
	initialValue?: string;
}
declare interface BulkEditorLineEditConfig {
	initialValue?: string;
	isOptional: boolean;
}
declare interface BulkEditorSpinBoxConfig {
	initialValue?: number;
	min: number;
	max: number;
	decimals: number;
	isOptional: boolean;
}
declare interface BulkEditorTextEditConfig {
	initialValue?: string;
	isOptional: boolean;
}
declare interface CadCountersinking {
	featureDescriptor: number;
}
type CadFeature = {
		type: "countersinking";
		content: CadCountersinking;
	} | {
		type: "throughHole";
		content: CadThroughHole;
	};
declare interface CadImportConfig {
	sheetUpperSideStrategy?: SheetUpperSideStrategy;
}
declare interface CadThroughHole {
	featureDescriptor: number;
}
declare interface CamBendDeduction {
	roundDeduction: number;
	innerRadius: number;
}
type CamCommand = {
		type: "setColor";
		content: CamCommandSetColor;
	};
declare interface CamCommandSetColor {
	entities: (GeometryEntity)[];
	color: Vector3;
}
declare interface CamNestedPart {
	innerOuterPolygon: InnerOuterPolygon;
	coordinateSystem: CoordinateSystem2;
}
declare interface CamNesting {
	sheets: (CamSheet)[];
}
declare interface CamNestorConfig {
	timeout: number;
	numRelevantNestings: number;
}
declare interface CamNestorInput {
	parts: (CamNestorInputPart)[];
	targetBoundary: Polygon;
	nestingDistance: number;
	xModulus: number;
	yModulus: number;
}
declare interface CamNestorInputPart {
	iop: InnerOuterPolygon;
	minCount: number;
	maxCount: number;
	fixedRotations: (number)[];
}
declare interface CamSheet {
	dimX: number;
	dimY: number;
	multiplicity: number;
}
declare interface CamTubeNestingResult {
	inputLength: number;
	nestings: (CamTubeNestingResultNesting)[];
}
declare interface CamTubeNestingResultNesting {
	transformations: (CoordinateSystem3)[];
	multiplicity: number;
}
declare interface CamWorkStepUpdateInputSheet {
	nestorInput: CamNestorInput;
	nestorConfig: CamNestorConfig;
}
declare interface CamWorkStepUpdateInputTube {
	length: number;
	multiplicity: number;
	nestingDistance: number;
}
declare interface Camera3 {
	eye: Point3;
	center: Point3;
	up: Vector3;
}
declare interface CameraOrientation3 {
	center: Vector3;
	direction: Vector3;
	up: Vector3;
}
declare interface ConnectionProperties {
	databaseType: DatabaseType;
	name: string;
	hostName: string;
	port: number;
	databaseName: string;
	userName: string;
	password: string;
}
declare interface ConsumableUniqueMembers {
	identifier: string;
}
declare interface Consumable extends ConsumableUniqueMembers{
	name: string;
	unit: string;
	costsPerUnit: number;
	description: string;
}
declare interface CoordinateSystem2 {
	origin: Vector2;
	unitaryMatrix: Matrix2;
}
declare interface CoordinateSystem3 {
	origin: Vector3;
	unitaryMatrix: Matrix3;
}
declare interface DieChoiceAlternativesEntry {
	bendDescriptor: number;
	bendDieChoices: (BendDieChoice)[];
}
declare interface DieChoiceMapEntry {
	bendDescriptor: number;
	bendDieChoice: BendDieChoice;
}
declare interface DieGroupPriorityUniqueMembers {
	upperDieGroupId: string;
	lowerDieGroupId: string;
	sheetBendingMaterialId: string;
	sheetThickness: number;
}
declare interface DieGroupPriority extends DieGroupPriorityUniqueMembers{
	priority: number;
}
declare interface DieSelectorQuery {
	thickness: number;
	bendAngle: number;
	maxOpeningWidth: number;
}
declare interface DimensionConstraintsUniqueMembers {
	processId: string;
}
declare interface DimensionConstraints extends DimensionConstraintsUniqueMembers{
	minX: number;
	minY: number;
	minZ: number;
	maxX: number;
	maxY: number;
	maxZ: number;
}
declare interface DocXImage {
	placeholder: string;
	content: ArrayBuffer;
	type: DocXImageType;
}
type DocXTableCell = {
		type: "text";
		content: DocXText;
	} | {
		type: "image";
		content: DocXImage;
	} | {
		type: "tables";
		content: DocXTables;
	};
declare interface DocXTables {
	tables: (((DocXTableCell)[])[])[];
}
declare interface DocXText {
	placeholder: string;
	text: string;
}
declare interface DocumentBarcode {
	width: number;
	text: string;
	alignment: DocumentAlignment;
}
declare interface DocumentFormat {
	orientation: DocumentOrientation;
}
declare interface DocumentHeading {
	level: number;
	text: string;
}
declare interface DocumentImage {
	width: number;
	type: DocumentImageType;
	uuid: string;
	data: ArrayBuffer;
	alignment: DocumentAlignment;
}
type DocumentItem = {
		type: "paragraph";
		content: DocumentParagraph;
	} | {
		type: "heading";
		content: DocumentHeading;
	} | {
		type: "table";
		content: DocumentTable;
	} | {
		type: "image";
		content: DocumentImage;
	} | {
		type: "barcode";
		content: DocumentBarcode;
	} | {
		type: "separator";
		content: DocumentSeparator;
	} | {
		type: "pageBreak";
		content: DocumentPageBreak;
	};
declare interface DocumentPageBreak {
}
declare interface DocumentParagraph {
	width: number;
	text: string;
	alignment: DocumentAlignment;
}
declare interface DocumentSeparator {
}
declare interface DocumentTable {
	width: number;
	columnWidths: (number)[];
	columnHeaders: DocumentTableRow;
	rows: (DocumentTableRow)[];
}
declare interface DocumentTableCell {
	text: string;
	alignment: DocumentAlignment;
}
declare interface DocumentTableRow {
}
declare interface FormRowConfig {
	key: string;
	name: string;
	config: FormWidgetConfig;
}
declare interface FormWidgetCheckBoxConfig {
	initialValue: boolean;
}
type FormWidgetConfig = {
		type: "checkBox";
		content: FormWidgetCheckBoxConfig;
	} | {
		type: "spinBox";
		content: FormWidgetSpinBoxConfig;
	} | {
		type: "dropDown";
		content: FormWidgetDropDownConfig;
	} | {
		type: "lineEdit";
		content: FormWidgetLineEditConfig;
	} | {
		type: "textEdit";
		content: FormWidgetTextEditConfig;
	} | {
		type: "label";
		content: FormWidgetLabelConfig;
	};
declare interface FormWidgetDropDownConfig {
	initialValue: string;
	entries: (FormWidgetDropDownEntry)[];
}
declare interface FormWidgetDropDownEntry {
	id: string;
	text: string;
}
declare interface FormWidgetLabelConfig {
	initialValue: string;
}
declare interface FormWidgetLineEditConfig {
	initialValue: string;
}
declare interface FormWidgetSpinBoxConfig {
	initialValue: number;
	min: number;
	max: number;
	decimals: number;
}
declare interface FormWidgetTextEditConfig {
	initialValue: string;
}
declare interface GeometryEntity {
	assemblyPath: AssemblyPath;
	descriptor: GeometryEntityDescriptor;
}
type GeometryEntityDescriptor = {
		type: "edge";
		content: GeometryEntityDescriptorContentEdge;
	} | {
		type: "face";
		content: GeometryEntityDescriptorContentFace;
	};
declare interface GeometryEntityDescriptorContentEdge {
	value: number;
}
declare interface GeometryEntityDescriptorContentFace {
	value: number;
}
declare interface GeometrySelectionEntry {
	entities: (GeometryEntity)[];
	data: StringIndexedInterface;
}
declare interface GltfNodeVendorData {
	assembly: Assembly;
	data: StringIndexedInterface;
}
type GraphCreatorInput = {
		type: "step";
		content: GraphCreatorInputStep;
	} | {
		type: "twoDimRep";
		content: GraphCreatorInputTwoDimRep;
	} | {
		type: "extrusion";
		content: GraphCreatorInputExtrusion;
	};
declare interface GraphCreatorInputExtrusion {
	importId: string;
	innerOuterPolygon: InnerOuterPolygon;
	depth: number;
	assemblyName: string;
	multiplicity: number;
}
declare interface GraphCreatorInputStep {
	importId: string;
	data: ArrayBuffer;
	multiplicity: number;
}
declare interface GraphCreatorInputTwoDimRep {
	importId: string;
	twoDimRep: TwoDimRepresentation;
	thickness: number;
	assemblyName: string;
	multiplicity: number;
}
declare interface GraphDeserializationResult {
	status: AddResultStatus;
	graph?: ImportedDocumentGraph;
}
declare interface HandlerPackaging {
	package: Box3;
	maxWeight: number;
	masses: (number)[];
}
declare interface HandlerPostProcessCreateSources {
	attributes: (VertexWithArticleAttributes)[];
}
declare interface HandlerPostProcessSheetBending {
	upperDieAffectDistances: (number)[];
	lowerDieAffectDistances: (number)[];
}
declare interface HandlerPreProcessCreateWorkStep {
	processTable: (Process)[];
}
declare interface HttpReply {
	errorCode: number;
	data: ArrayBuffer;
}
declare interface InvalidValueTableError {
	affectedRowType: TableType;
	affectedRowIndex: number;
	affectedColumnIndex: number;
}
declare interface Joining {
	joiningSteps: (JoiningStep)[];
}
declare interface JoiningReplyStateContentUndefinedError {
}
declare interface JoiningStep {
	entries: (JoiningStepEntry)[];
	cameraOrientation?: CameraOrientation3;
	comment: string;
}
declare interface JoiningStepEntry {
	assembly: Assembly;
}
declare interface KeyValue {
	key: string;
	value: string;
}
declare interface LaserSheetCuttingGasUniqueMembers {
	identifier: string;
}
declare interface LaserSheetCuttingGas extends LaserSheetCuttingGasUniqueMembers{
	name: string;
}
declare interface LaserSheetCuttingMaxThicknessUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
}
declare interface LaserSheetCuttingMaxThickness extends LaserSheetCuttingMaxThicknessUniqueMembers{
	maxThickness: number;
	minThickness: number;
}
declare interface LaserSheetCuttingMinAreaUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
	thickness: number;
}
declare interface LaserSheetCuttingMinArea extends LaserSheetCuttingMinAreaUniqueMembers{
	area: number;
}
declare interface LaserSheetCuttingPierceTimeUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
	thickness: number;
}
declare interface LaserSheetCuttingPierceTime extends LaserSheetCuttingPierceTimeUniqueMembers{
	time: number;
}
declare interface LaserSheetCuttingRateUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
}
declare interface LaserSheetCuttingRate extends LaserSheetCuttingRateUniqueMembers{
	rate: number;
}
declare interface LaserSheetCuttingSpeedUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
	thickness: number;
}
declare interface LaserSheetCuttingSpeed extends LaserSheetCuttingSpeedUniqueMembers{
	speed: number;
}
declare interface Layer {
	descriptor: number;
	number: number;
	name: string;
}
declare interface LayeredExtraData {
	thickness: number;
	name: string;
	material: string;
}
declare interface LineSegment {
	from: Point2;
	to: Point2;
}
declare interface LowerDieUniqueMembers {
	identifier: string;
}
declare interface LowerDie extends LowerDieUniqueMembers{
	name: string;
	lowerDieGroupId: string;
	description: string;
}
declare interface LowerDieGroupUniqueMembers {
	identifier: string;
}
declare interface LowerDieGroup extends LowerDieGroupUniqueMembers{
	name: string;
	exportIdentifier: string;
	openingWidth: number;
}
declare interface LowerDieUnitUniqueMembers {
	lowerDieId: string;
	dimX: number;
}
declare interface LowerDieUnit extends LowerDieUnitUniqueMembers{
	multiplicity: number;
}
declare interface LstCreationParameters {
	programName: string;
	lttIdentifier: string;
	sheetThickness: number;
	sheetMaterial: string;
	measureSheet: boolean;
	loadingSystem: TrumpfLoadingSystem;
	evaporate: LstEvaporateMode;
	measuringCorner: SheetCorner;
	sheetMetalStop: SheetCorner;
}
declare interface Matrix2 {
	entries: [ (number), (number), (number), (number), ];
}
declare interface Matrix3 {
	entries: [ (number), (number), (number), (number), (number), (number), (number), (number), (number), ];
}
declare interface Matrix4 {
	entries: [ (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), (number), ];
}
declare interface MeasurementScene {
	scene: Scene;
	camera: Camera3;
}
declare interface Nest2PartInstance {
	descriptor: number;
	transformation: CoordinateSystem2;
}
declare interface Nest3InputBin {
	box: Box3;
	maxWeight: number;
}
declare interface Nest3Part {
	assembly: Assembly;
	multiplicity: number;
	mass: number;
	profileShadow: ProfileShadowFuture;
}
declare interface Nest3ResultBox {
	assembly: Assembly;
	weight: number;
}
declare interface NestingDissection {
	nestingDescriptor: number;
	xDissection?: number;
	yDissection?: number;
}
declare interface NewNodeParams {
	processType: ProcessType;
	processId: string;
	nodeUserData: StringIndexedInterface;
}
type NodeEditingStateEntry = {
		type: "missingDatum";
		content: NodeEditingStateEntryMissingDatum;
	} | {
		type: "invalidDatum";
		content: NodeEditingStateEntryInvalidDatum;
	};
declare interface NodeEditingStateEntryInvalidDatum {
	nodeDatumType: NodeDatumType;
	value: string;
}
declare interface NodeEditingStateEntryMissingDatum {
	nodeDatumType: NodeDatumType;
}
type NodeUpdate = {
		type: "undefined";
		content: NodeUpdateUndefined;
	} | {
		type: "sheet";
		content: NodeUpdateSheet;
	} | {
		type: "sheetCutting";
		content: NodeUpdateSheetCutting;
	} | {
		type: "joining";
		content: NodeUpdateJoining;
	} | {
		type: "tubeCutting";
		content: NodeUpdateTubeCutting;
	} | {
		type: "sheetBending";
		content: NodeUpdateSheetBending;
	} | {
		type: "userDefined";
		content: NodeUpdateUserDefined;
	} | {
		type: "userDefinedBase";
		content: NodeUpdateUserDefinedBase;
	} | {
		type: "packaging";
		content: NodeUpdatePackaging;
	} | {
		type: "transform";
		content: NodeUpdateTransform;
	} | {
		type: "tube";
		content: NodeUpdateTube;
	};
declare interface NodeUpdateJoining {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdatePackaging {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdateSheet {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdateSheetBending {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	dieChoiceMap?: (DieChoiceMapEntry)[];
	toggleUpperSide?: boolean;
	correctBends?: boolean;
}
declare interface NodeUpdateSheetCutting {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	sheetThickness?: number;
	toggleUpperSide?: boolean;
}
declare interface NodeUpdateTransform {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdateTube {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdateTubeCutting {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdateUndefined {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdateUserDefined {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUpdateUserDefinedBase {
	vertex: Vertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface NodeUserDataBase {
	attachments: (Attachment)[];
	bendLineEngravingMode: BendLineEngravingMode;
	comment: string;
	deburrDoubleSided: boolean;
	fixedRotations: (number)[];
	numCountersinks: number;
	numThreads: number;
	purchasePartMaterialId: string;
	sheetFilterSheetIds: (string)[];
	sheetMaterialId: string;
	sheetTappingData: (SheetTappingDataEntry)[];
	testReportRequired: boolean;
	tubeMaterialId: string;
	tubeSpecificationId: string;
	userDefinedMaterialCostsPerPiece: number;
	userDefinedScalePrices: (UserDefinedScalePrice)[];
	userDefinedSetupTime: number;
	userDefinedUnitTimePerPiece: number;
}
declare interface PackagingUniqueMembers {
	identifier: string;
}
declare interface Packaging extends PackagingUniqueMembers{
	name: string;
	dimX: number;
	dimY: number;
	dimZ: number;
	maxWeight: number;
	price: number;
	tr: number;
	tep: number;
	tea: number;
	packagingWeight: number;
}
declare interface PackagingReplyStateContentInsufficientPackageVolume {
}
declare interface PackagingReplyStateContentOverweightParts {
}
declare interface PackagingReplyStateContentUndefinedError {
}
declare interface Point2 {
	entries: [ (number), (number), ];
}
declare interface Point3 {
	entries: [ (number), (number), (number), ];
}
declare interface PrivateArticleCalcDataResourceEntry {
	nodeId: GraphNodeId;
	approxSemimanufacturedShare?: number;
	manufacturingPriceExclSurcharges?: number;
	manufacturingPriceInclSurcharges?: number;
	recursiveManufacturingPriceExclSurcharges?: number;
	recursiveManufacturingPriceInclSurcharges?: number;
	sellingPrice?: number;
	recursiveSellingPrice?: number;
}
declare interface PrivateArticleRepresentation {
	name: string;
	externalPartNumber: string;
	externalDrawingNumber: string;
	externalRevisionNumber: string;
	comment: string;
	multiplicity: number;
	nodeId: GraphNodeId;
	rootId: GraphNodeRootId;
	nodeIds: (GraphNodeId)[];
}
declare interface PrivateArticleSignatureNodeResourceEntry {
	nodeId: GraphNodeId;
	material: string;
	mass?: number;
	sheetThickness?: number;
}
declare interface PrivateArticleTextResourceEntry {
	nodeId: GraphNodeId;
	details: string;
}
declare interface PrivateAssemblyResourceEntry {
	nodeId: GraphNodeId;
	assembly: Assembly;
}
declare interface PrivateBinaryResourceEntry {
	nodeId: GraphNodeId;
	data: ArrayBuffer;
}
declare interface PrivateEditingNote {
	type: string;
	message: string;
}
declare interface PrivateEditingNotesResourceEntry {
	nodeId: GraphNodeId;
	notes: (PrivateEditingNote)[];
}
declare interface PrivateForceSheetMetalPartResourceEntry {
	nodeId: GraphNodeId;
	canForceFuture: BooleanFuture;
}
declare interface PrivateGraphData {
	projectName: string;
}
type PrivateGuiData = {
		type: "graphRep";
		content: PrivateGuiDataGraphRep;
	};
declare interface PrivateGuiDataGraphRep {
	nodes: (PrivateNodeRepresentation)[];
	articles: (PrivateArticleRepresentation)[];
	resources: PrivateResources;
	data: PrivateGraphData;
	sourceMults: (PrivateSourceMultEntry)[];
}
declare interface PrivateMainWindowScriptAction {
	name: string;
	modulePath: string;
	functionName: string;
	shortcut?: string;
	icon?: string;
	menuType?: PrivateMainWindowMenuType;
}
declare interface PrivateMainWindowScriptConfig {
	scripts: (PrivateMainWindowScriptAction)[];
}
declare interface PrivateManufacturingStateEntry {
	level: string;
	message: string;
}
declare interface PrivateManufacturingStateResourceEntry {
	nodeId: GraphNodeId;
	actualState: (PrivateManufacturingStateEntry)[];
	virtualState: (PrivateManufacturingStateEntry)[];
}
declare interface PrivateMeasurementScenesResourceEntry {
	nodeId: GraphNodeId;
	data: (MeasurementScene)[];
}
declare interface PrivateNodeCalcDataResourceEntry {
	nodeId: GraphNodeId;
	materialCosts?: number;
	setupTime?: number;
	unitTime?: number;
	manufacturingPriceExclSurcharges?: number;
	manufacturingPriceInclSurcharges?: number;
	sellingPrice?: number;
}
declare interface PrivateNodeRepresentation {
	nodeId: GraphNodeId;
	rootId: GraphNodeRootId;
	sourceNodeIds: (GraphNodeId)[];
	targetNodeIds: (GraphNodeId)[];
	workStepType: WorkStepType;
	processType: ProcessType;
	processId: string;
	processName: string;
	comment: string;
	hasTwoDimInput: boolean;
	hasCalcOverride: boolean;
}
declare interface PrivateNodeTextResourceEntry {
	nodeId: GraphNodeId;
	brief: string;
	details: string;
	toolTip: string;
}
declare interface PrivatePostProcessingResultCreateSourcesSheetCutting {
	source: Vertex;
	deducedDataOfSource: StringIndexedInterface;
}
declare interface PrivatePostProcessingResultCreateWorkStep {
	processType: ProcessType;
	processId: string;
	nodeUserData: StringIndexedInterface;
	articleUserData?: StringIndexedInterface;
}
declare interface PrivateProblematicGeometryResourceEntry {
	nodeId: GraphNodeId;
	hasProblematicGeometries: boolean;
}
declare 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)[];
}
declare interface PrivateSceneResourceEntry {
	nodeId: GraphNodeId;
	data: Scene;
}
declare 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)[];
}
declare interface PrivateSourceMultEntry {
	sourceArticleNodeId: GraphNodeId;
	targetArticleNodeId: GraphNodeId;
	multiplicity: number;
}
declare interface PrivateTubeTablesEditorInitData {
	tubeMaterials: (TubeMaterial)[];
	tubeMaterialDensities: (TubeMaterialDensity)[];
	tubeProfiles: (TubeProfile)[];
	tubeSpecifications: (TubeSpecification)[];
	tubes: (Tube)[];
}
declare interface ProcessUniqueMembers {
	identifier: string;
}
declare interface Process extends ProcessUniqueMembers{
	parentIdentifier: string;
	type: ProcessType;
	name: string;
	costCenter: string;
	priority: number;
	active: boolean;
	childrenActive: boolean;
	description: string;
}
declare interface ProcessConstraintsPurchasePartMaterialUniqueMembers {
	processId: string;
	purchasePartMaterialId: string;
}
declare interface ProcessConstraintsPurchasePartMaterial extends ProcessConstraintsPurchasePartMaterialUniqueMembers{
	isAllowed: boolean;
}
declare interface ProcessConstraintsSheetMaterialUniqueMembers {
	processId: string;
	sheetMaterialId: string;
}
declare interface ProcessConstraintsSheetMaterial extends ProcessConstraintsSheetMaterialUniqueMembers{
	isAllowed: boolean;
}
declare interface ProcessConstraintsTubeMaterialUniqueMembers {
	processId: string;
	tubeMaterialId: string;
}
declare interface ProcessConstraintsTubeMaterial extends ProcessConstraintsTubeMaterialUniqueMembers{
	isAllowed: boolean;
}
declare interface ProcessConsumableRateUniqueMembers {
	processId: string;
	consumableId: string;
}
declare interface ProcessConsumableRate extends ProcessConsumableRateUniqueMembers{
	unitsPerHour: number;
}
declare interface ProcessHandlingTimeUniqueMembers {
	processId: string;
	mass: number;
}
declare interface ProcessHandlingTime extends ProcessHandlingTimeUniqueMembers{
	setupTimeDelta: number;
	unitTimeDelta: number;
}
declare interface ProcessIdlePeriodUniqueMembers {
	processId: string;
}
declare interface ProcessIdlePeriod extends ProcessIdlePeriodUniqueMembers{
	time: number;
}
declare interface ProcessRateUniqueMembers {
	processId: string;
}
declare interface ProcessRate extends ProcessRateUniqueMembers{
	rate: number;
}
declare interface ProcessSetupTimeFallbackUniqueMembers {
	processId: string;
}
declare interface ProcessSetupTimeFallback extends ProcessSetupTimeFallbackUniqueMembers{
	time: number;
}
declare interface ProcessUnitTimeFallbackUniqueMembers {
	processId: string;
}
declare interface ProcessUnitTimeFallback extends ProcessUnitTimeFallbackUniqueMembers{
	time: number;
}
declare interface ProfileShadow {
	coordinateSystem: CoordinateSystem3;
	shadow: InnerOuterPolygon;
}
declare interface ProgramVersion {
	major: number;
	minor: number;
	patch: number;
}
declare interface PurchasePartMaterialUniqueMembers {
	identifier: string;
}
declare interface PurchasePartMaterial extends PurchasePartMaterialUniqueMembers{
	name: string;
	density: number;
	description: string;
}
declare interface ReferredEntryMissingTableError {
	affectedRowType: TableType;
	affectedRowIndex: number;
	affectedColumnIndex: number;
	relatedRowType: TableType;
	relatedColumnIndex: number;
	referredId: string;
}
declare interface ReferringEntryMissingTableError {
	affectedRowType: TableType;
	affectedColumnIndex: number;
	relatedRowType: TableType;
	relatedRowIndex: number;
	relatedColumnIndex: number;
}
declare interface RenderSceneSettings {
	resolution: Resolution;
	viewPort?: Box2;
}
declare interface ReplyStateIndicatorMap {
	undefined?: ReplyStateIndicatorsUndefined;
	sheet?: ReplyStateIndicatorsSheet;
	sheetCutting?: ReplyStateIndicatorsSheetCutting;
	joining?: ReplyStateIndicatorsJoining;
	tubeCutting?: ReplyStateIndicatorsTubeCutting;
	sheetBending?: ReplyStateIndicatorsSheetBending;
	userDefined?: ReplyStateIndicatorsUserDefined;
	userDefinedBase?: ReplyStateIndicatorsUserDefinedBase;
	packaging?: ReplyStateIndicatorsPackaging;
	transform?: ReplyStateIndicatorsTransform;
	tube?: ReplyStateIndicatorsTube;
}
declare interface ReplyStateIndicatorsJoining {
	replyStateIndicators: ReplyStateMapJoining;
}
declare interface ReplyStateIndicatorsPackaging {
	replyStateIndicators: ReplyStateMapPackaging;
}
declare interface ReplyStateIndicatorsSheet {
	replyStateIndicators: ReplyStateMapSheet;
}
declare interface ReplyStateIndicatorsSheetBending {
	replyStateIndicators: ReplyStateMapSheetBending;
}
declare interface ReplyStateIndicatorsSheetCutting {
	replyStateIndicators: ReplyStateMapSheetCutting;
}
declare interface ReplyStateIndicatorsTransform {
	replyStateIndicators: ReplyStateMapTransform;
}
declare interface ReplyStateIndicatorsTube {
	replyStateIndicators: ReplyStateMapTube;
}
declare interface ReplyStateIndicatorsTubeCutting {
	replyStateIndicators: ReplyStateMapTubeCutting;
}
declare interface ReplyStateIndicatorsUndefined {
	replyStateIndicators: ReplyStateMapUndefined;
}
declare interface ReplyStateIndicatorsUserDefined {
	replyStateIndicators: ReplyStateMapUserDefined;
}
declare interface ReplyStateIndicatorsUserDefinedBase {
	replyStateIndicators: ReplyStateMapUserDefinedBase;
}
declare interface ReplyStateMapJoining {
	undefinedError?: JoiningReplyStateContentUndefinedError;
}
declare interface ReplyStateMapPackaging {
	undefinedError?: PackagingReplyStateContentUndefinedError;
	insufficientPackageVolume?: PackagingReplyStateContentInsufficientPackageVolume;
	overweightParts?: PackagingReplyStateContentOverweightParts;
}
declare interface ReplyStateMapSheet {
	undefinedError?: SheetReplyStateContentUndefinedError;
	nestingFailed?: SheetReplyStateContentNestingFailedError;
}
declare interface ReplyStateMapSheetBending {
	undefinedError?: BendReplyStateContentUndefinedError;
	multipleOuterContours?: BendReplyStateContentMultipleOuterContours;
	contourInBend?: BendReplyStateContentContourInBend;
	invalidBend?: BendReplyStateContentInvalidBend;
	undetectedFeatures?: BendReplyStateContentUndetectedFeatures;
	unfoldingFailed?: BendReplyStateContentUnfoldingFailed;
	bendDeductionApplicationFailed?: BendReplyStateContentBendDeductionApplicationFailed;
}
declare interface ReplyStateMapSheetCutting {
	undefinedError?: SheetCuttingReplyStateContentUndefinedError;
	undetectedFeatures?: SheetCuttingReplyStateContentUndetectedFeatures;
	multipleOuterContours?: SheetCuttingReplyStateContentMultipleOuterContours;
	unused0?: Unused;
}
declare interface ReplyStateMapTransform {
	undefinedError?: TransformReplyStateContentUndefinedError;
}
declare interface ReplyStateMapTube {
	undefinedError?: TubeReplyStateContentUndefinedError;
}
declare interface ReplyStateMapTubeCutting {
	undefinedError?: TubeCuttingReplyStateContentUndefinedError;
	undetectedFeatures?: TubeCuttingReplyStateContentUndetectedFeatures;
}
declare interface ReplyStateMapUndefined {
	undefinedError?: UndefinedReplyStateContentUndefinedError;
}
declare interface ReplyStateMapUserDefined {
	undefinedError?: UserDefinedReplyStateContentUndefinedError;
}
declare interface ReplyStateMapUserDefinedBase {
	undefinedError?: UserDefinedBaseReplyStateContentUndefinedError;
}
declare interface Resolution {
	width: number;
	height: number;
}
declare interface SceneConfig {
	elements?: SceneElements;
	sceneId?: string;
	fontSize?: number;
	textItems?: (SceneTextItem)[];
	sheetBendingBendLineMaxEngravingLength?: number;
	sheetExtraText?: string;
	sheetNestingDissections?: (NestingDissection)[];
}
declare interface SceneLabel {
	position: Point2;
	text: string;
	fontSize: number;
}
declare interface SceneObjectData {
	zValue: number;
	bendAngle: number;
	innerRadius: number;
	upperDieGroup: string;
	lowerDieGroup: string;
	sharpDeduction: number;
}
declare interface SceneSceneData {
	material: string;
	thickness: number;
	identifier: string;
	comment: string;
	globalMaterial: string;
}
declare interface SceneStyle {
	strokeWidth?: number;
	strokeColor?: Color;
	fillColor?: Vector4;
	strokeStyle?: StrokeStyle;
	zValue?: number;
	fontSize?: number;
}
declare interface SceneTextItem {
	text: string;
	pos: Point2;
}
declare interface ScrewThreadUniqueMembers {
	identifier: string;
}
declare interface ScrewThread extends ScrewThreadUniqueMembers{
	name: string;
	coreHoleDiameter: number;
	minDepth: number;
	symmetricTolerance: number;
}
type Segment = {
		type: "line";
		content: LineSegment;
	} | {
		type: "arc";
		content: ArcSegment;
	};
declare interface SettingUniqueMembers {
	key: string;
}
declare interface Setting extends SettingUniqueMembers{
	value: string;
}
declare interface SettingsTableDataBase {
	bendFlangeSafetyDistance: number;
	dieBendingSetupTimeDistributionEnabled: boolean;
	tubeClampingLength: number;
}
declare interface SheetUniqueMembers {
	identifier: string;
}
declare interface Sheet extends SheetUniqueMembers{
	name: string;
	sheetMaterialId: string;
	dimX: number;
	dimY: number;
	thickness: number;
	description: string;
}
declare interface SheetBendingMaterialUniqueMembers {
	identifier: string;
}
declare interface SheetBendingMaterial extends SheetBendingMaterialUniqueMembers{
	name: string;
}
declare interface SheetBendingMaterialMappingUniqueMembers {
	sheetMaterialId: string;
}
declare interface SheetBendingMaterialMapping extends SheetBendingMaterialMappingUniqueMembers{
	sheetBendingMaterialId: string;
}
declare interface SheetCuttingCalcParams {
	sheetMaterialId: string;
	bendLineEngravingMode: BendLineEngravingMode;
	machineVMax: number;
	machineAMax: number;
}
declare interface SheetCuttingMaterialUniqueMembers {
	identifier: string;
}
declare interface SheetCuttingMaterial extends SheetCuttingMaterialUniqueMembers{
	name: string;
}
declare interface SheetCuttingMaterialMappingUniqueMembers {
	sheetMaterialId: string;
}
declare interface SheetCuttingMaterialMapping extends SheetCuttingMaterialMappingUniqueMembers{
	sheetCuttingMaterialId: string;
}
declare interface SheetCuttingMotionParametersUniqueMembers {
	sheetCuttingProcessId: string;
	thickness: number;
	contourArea: number;
}
declare interface SheetCuttingMotionParameters extends SheetCuttingMotionParametersUniqueMembers{
	speed: number;
	acceleration: number;
	pierceTime: number;
}
declare interface SheetCuttingProcessUniqueMembers {
	identifier: string;
}
declare interface SheetCuttingProcess extends SheetCuttingProcessUniqueMembers{
	name: string;
	description: string;
}
declare interface SheetCuttingProcessConsumableRateUniqueMembers {
	sheetCuttingProcessId: string;
	consumableId: string;
	thickness: number;
}
declare interface SheetCuttingProcessConsumableRate extends SheetCuttingProcessConsumableRateUniqueMembers{
	unitsPerHour: number;
}
declare interface SheetCuttingProcessMappingUniqueMembers {
	processId: string;
	sheetMaterialId: string;
}
declare interface SheetCuttingProcessMapping extends SheetCuttingProcessMappingUniqueMembers{
	sheetCuttingProcessId: string;
}
declare interface SheetCuttingProcessToLaserCuttingGasUniqueMembers {
	sheetCuttingProcessId: string;
}
declare interface SheetCuttingProcessToLaserCuttingGas extends SheetCuttingProcessToLaserCuttingGasUniqueMembers{
	laserSheetCuttingGasId: string;
}
declare interface SheetCuttingReplyStateContentMultipleOuterContours {
}
declare interface SheetCuttingReplyStateContentUndefinedError {
}
declare interface SheetCuttingReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}
declare interface SheetCuttingThicknessConstraintsUniqueMembers {
	sheetCuttingProcessId: string;
}
declare interface SheetCuttingThicknessConstraints extends SheetCuttingThicknessConstraintsUniqueMembers{
	minThickness: number;
	maxThickness: number;
}
declare interface SheetFilter {
	ids: (string)[];
}
declare interface SheetMaterialUniqueMembers {
	identifier: string;
}
declare interface SheetMaterial extends SheetMaterialUniqueMembers{
	name: string;
	description: string;
}
declare interface SheetMaterialDensityUniqueMembers {
	sheetMaterialId: string;
}
declare interface SheetMaterialDensity extends SheetMaterialDensityUniqueMembers{
	density: number;
}
declare interface SheetMaterialScrapValueUniqueMembers {
	sheetMaterialId: string;
}
declare interface SheetMaterialScrapValue extends SheetMaterialScrapValueUniqueMembers{
	scrapValue: number;
}
declare interface SheetModulusUniqueMembers {
	sheetId: string;
}
declare interface SheetModulus extends SheetModulusUniqueMembers{
	xModulus: number;
	yModulus: number;
	applyToAll: boolean;
}
declare interface SheetNestingPrePartition {
	compatibleTargets: (SheetNestingTarget)[];
	nestorConfig: CamNestorConfig;
	nestingDistance: number;
	sheetMaterialId?: string;
	sheetProcessId?: string;
}
declare interface SheetNestingTarget {
	vertex: Vertex;
	fixedRotations: (number)[];
	sheetFilterSheetIds: (string)[];
}
declare interface SheetPriceUniqueMembers {
	sheetId: string;
}
declare interface SheetPrice extends SheetPriceUniqueMembers{
	pricePerSheet: number;
}
declare interface SheetPriorityUniqueMembers {
	sheetId: string;
}
declare interface SheetPriority extends SheetPriorityUniqueMembers{
	priority: number;
}
declare interface SheetReplyStateContentNestingFailedError {
}
declare interface SheetReplyStateContentUndefinedError {
}
declare interface SheetStockUniqueMembers {
	sheetId: string;
}
declare interface SheetStock extends SheetStockUniqueMembers{
	count: number;
}
declare interface SheetTappingDataEntry {
	cadFeature: CadFeature;
	screwThreadId: string;
}
declare interface SheetTappingEditorCandidate {
	id: string;
	name: string;
	values: (SheetTappingEditorCandidateValue)[];
}
declare interface SheetTappingEditorCandidateValue {
	id: string;
	name: string;
}
declare interface SheetTappingEditorSelectionEntry {
	candidateId: string;
	valueId: string;
}
declare interface SlArticleUpdate {
	vertex: SlVertex;
	articleUserData?: StringIndexedInterface;
}
type SlNodeUpdate = {
		type: "undefined";
		content: SlNodeUpdateUndefined;
	} | {
		type: "sheet";
		content: SlNodeUpdateSheet;
	} | {
		type: "sheetCutting";
		content: SlNodeUpdateSheetCutting;
	} | {
		type: "joining";
		content: SlNodeUpdateJoining;
	} | {
		type: "tubeCutting";
		content: SlNodeUpdateTubeCutting;
	} | {
		type: "sheetBending";
		content: SlNodeUpdateSheetBending;
	} | {
		type: "userDefined";
		content: SlNodeUpdateUserDefined;
	} | {
		type: "userDefinedBase";
		content: SlNodeUpdateUserDefinedBase;
	} | {
		type: "packaging";
		content: SlNodeUpdatePackaging;
	} | {
		type: "transform";
		content: SlNodeUpdateTransform;
	} | {
		type: "tube";
		content: SlNodeUpdateTube;
	};
declare interface SlNodeUpdateJoining {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdatePackaging {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdateSheet {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdateSheetBending {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	dieChoiceMap?: (DieChoiceMapEntry)[];
	toggleUpperSide?: boolean;
	correctBends?: boolean;
}
declare interface SlNodeUpdateSheetCutting {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
	sheetThickness?: number;
	toggleUpperSide?: boolean;
}
declare interface SlNodeUpdateTransform {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdateTube {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdateTubeCutting {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdateUndefined {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdateUserDefined {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlNodeUpdateUserDefinedBase {
	vertex: SlVertex;
	processType?: ProcessType;
	processId?: string;
	nodeUserData?: StringIndexedInterface;
}
declare interface SlSheetNestingPrePartition {
	compatibleTargets: (SlSheetNestingTarget)[];
	nestorConfig: CamNestorConfig;
	nestingDistance: number;
	sheetMaterialId?: string;
	sheetProcessId?: string;
}
declare interface SlSheetNestingTarget {
	vertex: SlVertex;
	fixedRotations: (number)[];
	sheetFilterSheetIds: (string)[];
}
declare interface SlTubeNestingPrePartition {
	targetVertex: SlVertex;
	targetLength: number;
	nestingDistance: number;
	tubeProcessId?: string;
}
declare interface SurchargeUniqueMembers {
	name: string;
	type: string;
	value: number;
}
declare interface Surcharge extends SurchargeUniqueMembers{
	description: string;
}
type TableError = {
		type: "referringEntryMissing";
		content: ReferringEntryMissingTableError;
	} | {
		type: "referredEntryMissing";
		content: ReferredEntryMissingTableError;
	} | {
		type: "valueInvalid";
		content: InvalidValueTableError;
	} | {
		type: "uniqueMemberCollision";
		content: UniqueMemberCollisionTableError;
	};
declare interface TappingTimeParametersUniqueMembers {
	processId: string;
	screwThreadId: string;
}
declare interface TappingTimeParameters extends TappingTimeParametersUniqueMembers{
	unitTimePerMm: number;
}
declare interface TransformReplyStateContentUndefinedError {
}
declare interface TransportationCostsUniqueMembers {
	identifier: string;
}
declare interface TransportationCosts extends TransportationCostsUniqueMembers{
	name: string;
	packagingId: string;
	fixedCosts: number;
	minCosts: number;
	kmKgFactor: number;
	kmFactor: number;
	minDistance: number;
	maxDistance: number;
}
declare interface TubeUniqueMembers {
	identifier: string;
}
declare interface Tube extends TubeUniqueMembers{
	name: string;
	tubeMaterialId: string;
	tubeProfileId: string;
	tubeSpecificationId: string;
	dimX: number;
}
declare interface TubeCuttingCalcParams {
	tubeMaterialId: string;
	machineVMax: number;
	machineAMax: number;
}
declare interface TubeCuttingPierceTimeUniqueMembers {
	tubeCuttingProcessId: string;
	thickness: number;
}
declare interface TubeCuttingPierceTime extends TubeCuttingPierceTimeUniqueMembers{
	time: number;
}
declare interface TubeCuttingProcessUniqueMembers {
	identifier: string;
}
declare interface TubeCuttingProcess extends TubeCuttingProcessUniqueMembers{
	name: string;
	description: string;
}
declare interface TubeCuttingProcessConsumableRateUniqueMembers {
	tubeCuttingProcessId: string;
	consumableId: string;
	thickness: number;
}
declare interface TubeCuttingProcessConsumableRate extends TubeCuttingProcessConsumableRateUniqueMembers{
	unitsPerHour: number;
}
declare interface TubeCuttingProcessMappingUniqueMembers {
	processId: string;
	tubeMaterialId: string;
}
declare interface TubeCuttingProcessMapping extends TubeCuttingProcessMappingUniqueMembers{
	tubeCuttingProcessId: string;
}
declare interface TubeCuttingReplyStateContentUndefinedError {
}
declare interface TubeCuttingReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}
declare interface TubeCuttingSpeedUniqueMembers {
	tubeCuttingProcessId: string;
	thickness: number;
}
declare interface TubeCuttingSpeed extends TubeCuttingSpeedUniqueMembers{
	speed: number;
}
declare interface TubeMaterialUniqueMembers {
	identifier: string;
}
declare interface TubeMaterial extends TubeMaterialUniqueMembers{
	name: string;
	description: string;
}
declare interface TubeMaterialDensityUniqueMembers {
	tubeMaterialId: string;
}
declare interface TubeMaterialDensity extends TubeMaterialDensityUniqueMembers{
	density: number;
}
declare interface TubeMaterialScrapValueUniqueMembers {
	tubeMaterialId: string;
}
declare interface TubeMaterialScrapValue extends TubeMaterialScrapValueUniqueMembers{
	scrapValue: number;
}
declare interface TubeNestingPrePartition {
	targetVertex: Vertex;
	targetLength: number;
	nestingDistance: number;
	tubeProcessId?: string;
}
declare interface TubePriceUniqueMembers {
	tubeId: string;
}
declare interface TubePrice extends TubePriceUniqueMembers{
	pricePerTube: number;
}
declare interface TubeProfileUniqueMembers {
	identifier: string;
}
declare interface TubeProfile extends TubeProfileUniqueMembers{
	name: string;
	description: string;
	geometryJson: string;
}
type TubeProfileGeometry = {
		type: "rectangular";
		content: TubeProfileGeometryRectangular;
	} | {
		type: "circular";
		content: TubeProfileGeometryCircular;
	};
declare interface TubeProfileGeometryCircular {
	outerRadius: number;
	thickness: number;
}
declare interface TubeProfileGeometryRectangular {
	dimY: number;
	dimZ: number;
	thickness: number;
}
declare interface TubeReplyStateContentUndefinedError {
}
declare interface TubeSpecificationUniqueMembers {
	identifier: string;
}
declare interface TubeSpecification extends TubeSpecificationUniqueMembers{
	name: string;
	description: string;
}
declare interface TubeStockUniqueMembers {
	tubeId: string;
}
declare interface TubeStock extends TubeStockUniqueMembers{
	count: number;
}
type TwoDimImportResult = {
		type: "partInvalid";
		content: TwoDimImportResultPartInvalid;
	} | {
		type: "engravingInvalid";
		content: TwoDimImportResultEngravingInvalid;
	} | {
		type: "success";
		content: TwoDimImportResultSuccess;
	};
declare interface TwoDimImportResultEngravingInvalid {
	problematicPoint: Point2;
}
declare interface TwoDimImportResultPartInvalid {
	problematicPoint?: Point2;
}
declare interface TwoDimImportResultSuccess {
	twoDimRep: TwoDimRepresentation;
}
declare interface UiJoiningRepresentation {
	joiningSteps: (UiJoiningStepRepresentation)[];
}
declare interface UiJoiningStepEntryRepresentation {
	assembly: string;
	identifier: string;
}
declare interface UiJoiningStepRepresentation {
	entries: (UiJoiningStepEntryRepresentation)[];
	cameraOrientation?: CameraOrientation3;
	comment: string;
}
declare interface UndefinedReplyStateContentUndefinedError {
}
declare interface UniqueMemberCollisionTableError {
	affectedRowType: TableType;
	affectedRowIndex: number;
	affectedColumnIndex: number;
	relatedRowIndex: number;
}
declare interface Unused {
}
declare interface UpperDieUniqueMembers {
	identifier: string;
}
declare interface UpperDie extends UpperDieUniqueMembers{
	name: string;
	upperDieGroupId: string;
	description: string;
}
declare interface UpperDieGroupUniqueMembers {
	identifier: string;
}
declare interface UpperDieGroup extends UpperDieGroupUniqueMembers{
	name: string;
	exportIdentifier: string;
	radius: number;
}
declare interface UpperDieUnitUniqueMembers {
	upperDieId: string;
	dimX: number;
}
declare interface UpperDieUnit extends UpperDieUnitUniqueMembers{
	multiplicity: number;
}
declare interface UserDataConfig {
	entries: (UserDatumConfig)[];
}
declare interface UserDatumBooleanConfig {
	id: string;
	name: string;
}
type UserDatumConfig = {
		type: "string";
		content: UserDatumStringConfig;
	} | {
		type: "number";
		content: UserDatumNumberConfig;
	} | {
		type: "boolean";
		content: UserDatumBooleanConfig;
	} | {
		type: "enumeration";
		content: UserDatumEnumConfig;
	};
declare interface UserDatumEnumConfig {
	id: string;
	name: string;
	items: (UserDatumEnumConfigItem)[];
}
declare interface UserDatumEnumConfigItem {
	id: string;
	name: string;
}
declare interface UserDatumNumberConfig {
	id: string;
	name: string;
	min: number;
	max: number;
	decimals: number;
}
declare interface UserDatumStringConfig {
	id: string;
	name: string;
}
declare interface UserDefinedBaseReplyStateContentUndefinedError {
}
declare interface UserDefinedReplyStateContentUndefinedError {
}
declare interface UserDefinedScalePrice {
	scaleValue: number;
	price: number;
}
declare interface Vector2 {
	entries: [ (number), (number), ];
}
declare interface Vector3 {
	entries: [ (number), (number), (number), ];
}
declare interface Vector4 {
	entries: [ (number), (number), (number), (number), ];
}
declare interface VertexWithArticleAttributes {
	vertex: Vertex;
	articleAttributes: ArticleAttributes;
}
declare interface VertexWithMultiplicity {
	vertex: Vertex;
	multiplicity: number;
}
declare interface VertexWithProcessTypeData {
	vertex: Vertex;
	processId: string;
	forced: boolean;
}
declare interface VertexWithSheetThickness {
	vertex: Vertex;
	sheetThickness: number;
}
declare interface VertexWithUserData {
	vertex: Vertex;
	userData: StringIndexedInterface;
}
declare interface VertexWithWorkStepType {
	vertex: Vertex;
	workStepType: WorkStepType;
}
type ViolatedNodeConstraint = {
		type: "bendDeductionThicknessInBounds";
		content: ViolatedNodeConstraintBendDeductionThicknessInBounds;
	} | {
		type: "bendDiesAssigned";
		content: ViolatedNodeConstraintBendDiesAssigned;
	} | {
		type: "bendFlangeLengthInBounds";
		content: ViolatedNodeConstraintBendFlangeLengthInBounds;
	} | {
		type: "bendLineLengthInBounds";
		content: ViolatedNodeConstraintBendLineLengthInBounds;
	} | {
		type: "contourBendZoneUnaffected";
		content: ViolatedNodeConstraintContourBendZoneUnaffected;
	} | {
		type: "sheetCuttingContourSizeInBounds";
		content: ViolatedNodeConstraintSheetCuttingContourSizeInBounds;
	} | {
		type: "editingStateOk";
		content: ViolatedNodeConstraintEditingStateOk;
	} | {
		type: "dimensionsInBounds";
		content: ViolatedNodeConstraintDimensionsInBounds;
	} | {
		type: "materialsCompatible";
		content: ViolatedNodeConstraintMaterialsCompatible;
	} | {
		type: "sheetCuttingThicknessInBounds";
		content: ViolatedNodeConstraintSheetCuttingThicknessInBounds;
	} | {
		type: "tubeCuttingProfileSupported";
		content: ViolatedNodeConstraintTubeCuttingProfileSupported;
	} | {
		type: "semimanufacturedAvailable";
		content: ViolatedNodeConstraintSemimanufacturedAvailable;
	} | {
		type: "sheetCuttingProcessCompatible";
		content: ViolatedNodeConstraintSheetCuttingProcessCompatible;
	} | {
		type: "tubeCuttingProcessCompatible";
		content: ViolatedNodeConstraintTubeCuttingProcessCompatible;
	} | {
		type: "tubeDetectionLicensed";
		content: ViolatedNodeConstraintTubeDetectionLicensed;
	} | {
		type: "unfoldingSimple";
		content: ViolatedNodeConstraintUnfoldingSimpl;
	};
declare interface ViolatedNodeConstraintBendDeductionThicknessInBounds {
}
declare interface ViolatedNodeConstraintBendDiesAssigned {
}
declare interface ViolatedNodeConstraintBendFlangeLengthInBounds {
	bendDescriptor: number;
	flangeLength0: number;
	flangeLength1: number;
	requiredOpeningWidth: number;
	actualOpeningWidth: number;
}
declare interface ViolatedNodeConstraintBendLineLengthInBounds {
	bendDescriptor: number;
	actualNetLength: number;
	maxAllowedNetLength: number;
}
declare interface ViolatedNodeConstraintContourBendZoneUnaffected {
}
declare interface ViolatedNodeConstraintDimensionsInBounds {
	actualDimensions: [ (number), (number), (number), ];
	violatedLowerConstaints?: [ (number), (number), (number), ];
	violatedUpperConstaints?: [ (number), (number), (number), ];
}
declare interface ViolatedNodeConstraintEditingStateOk {
	dataMissing: boolean;
	dataInvalid: boolean;
}
declare interface ViolatedNodeConstraintMaterialsCompatible {
	incompatibleSheetMaterialIds: (string)[];
	incompatibleTubeMaterialIds: (string)[];
	incompatiblePurchasePartMaterialIds: (string)[];
}
declare interface ViolatedNodeConstraintSemimanufacturedAvailable {
}
declare interface ViolatedNodeConstraintSheetCuttingContourSizeInBounds {
}
declare interface ViolatedNodeConstraintSheetCuttingProcessCompatible {
}
declare interface ViolatedNodeConstraintSheetCuttingThicknessInBounds {
	minThickness: number;
	maxThickness: number;
}
declare interface ViolatedNodeConstraintTubeCuttingProcessCompatible {
}
declare interface ViolatedNodeConstraintTubeCuttingProfileSupported {
}
declare interface ViolatedNodeConstraintTubeDetectionLicensed {
}
declare interface ViolatedNodeConstraintUnfoldingSimpl {
}
type WidgetConfig = {
		type: "assemblyView";
		content: WidgetConfigAssemblyView;
	} | {
		type: "attachmentEditor";
		content: WidgetConfigAttachmentEditor;
	} | {
		type: "bendingToolEditor";
		content: WidgetConfigBendingToolEditor;
	} | {
		type: "bulkEditor";
		content: WidgetConfigBulkEditor;
	} | {
		type: "calcParamEditor";
		content: WidgetConfigCalcParamEditor;
	} | {
		type: "fileDialog";
		content: WidgetConfigFileDialog;
	} | {
		type: "formEditor";
		content: WidgetConfigFormEditor;
	} | {
		type: "geometrySelector";
		content: WidgetConfigGeometrySelector;
	} | {
		type: "geometryColorSelector";
		content: WidgetConfigGeometryColorSelector;
	} | {
		type: "joiningSequenceEditor";
		content: WidgetConfigJoiningSequenceEditor;
	} | {
		type: "layeredImportDialog";
		content: WidgetConfigLayeredImportDialog;
	} | {
		type: "messageBox";
		content: WidgetConfigMessageBox;
	} | {
		type: "processSelector";
		content: WidgetConfigProcessSelector;
	} | {
		type: "sheetFilterEditor";
		content: WidgetConfigSheetFilterEditor;
	} | {
		type: "sheetTappingEditor";
		content: WidgetConfigSheetTappingEditor;
	} | {
		type: "userDataConfigEditor";
		content: WidgetConfigUserDataConfigEditor;
	};
declare interface WidgetConfigAssemblyView {
	assembly: Assembly;
}
declare interface WidgetConfigAttachmentEditor {
	initialValue: WidgetResultAttachmentEditor;
}
declare interface WidgetConfigBendingToolEditor {
	input: (BendingToolEditorInputEntry)[];
	initialValue: WidgetResultBendingToolEditor;
}
declare interface WidgetConfigBulkEditor {
	columnConfigs: (BulkEditorColumnConfig)[];
	rowConfigs: ((BulkEditorCellConfig)[])[];
	widgetState?: string;
}
declare interface WidgetConfigCalcParamEditor {
	initialValue: WidgetResultCalcParamEditor;
	materialCostsPerPieceSuggestion?: number;
	setupTimeSuggestion?: number;
	unitTimePerPieceSuggestion?: number;
}
declare interface WidgetConfigFileDialog {
	type: FileDialogType;
	title: string;
	defaultPath: string;
	filter: string;
}
declare interface WidgetConfigFormEditor {
	rows: (FormRowConfig)[];
}
declare interface WidgetConfigGeometryColorSelector {
	flags: GeometrySelectorConfigFlags;
	assembly: Assembly;
	formEditorConfig: WidgetConfigFormEditor;
	colorDataKey: string;
	initialValue: WidgetResultGeometryColorSelector;
}
declare interface WidgetConfigGeometrySelector {
	flags: GeometrySelectorConfigFlags;
	assembly: Assembly;
	formEditorConfig: WidgetConfigFormEditor;
	initialValue: WidgetResultGeometrySelector;
}
declare interface WidgetConfigJoiningSequenceEditor {
	articleName: string;
	assemblyMap: (AssemblyMapEntry)[];
	initialValue: WidgetResultJoiningSequenceEditor;
}
declare interface WidgetConfigLayeredImportDialog {
	title: string;
	layered: Layered;
	thickness: number;
	name: string;
	material: string;
}
declare interface WidgetConfigMessageBox {
	type: MessageBoxType;
	title: string;
	text: string;
}
declare interface WidgetConfigProcessSelector {
	processTable: (Process)[];
	supportedWorkStepTypes: (WorkStepType)[];
	initialValue: WidgetResultProcessSelector;
}
declare interface WidgetConfigSheetFilterEditor {
	sheets: (string)[];
	initialValue: WidgetResultSheetFilterEditor;
}
declare interface WidgetConfigSheetTappingEditor {
	base64Scene: string;
	candidates: (SheetTappingEditorCandidate)[];
	initialValue: WidgetResultSheetTappingEditor;
}
declare interface WidgetConfigUserDataConfigEditor {
	initialValue: WidgetResultUserDataConfigEditor;
}
type WidgetResult = {
		type: "assemblyView";
		content: WidgetResultAssemblyView;
	} | {
		type: "attachmentEditor";
		content: WidgetResultAttachmentEditor;
	} | {
		type: "bendingToolEditor";
		content: WidgetResultBendingToolEditor;
	} | {
		type: "bulkEditor";
		content: WidgetResultBulkEditor;
	} | {
		type: "calcParamEditor";
		content: WidgetResultCalcParamEditor;
	} | {
		type: "fileDialog";
		content: WidgetResultFileDialog;
	} | {
		type: "formEditor";
		content: WidgetResultFormEditor;
	} | {
		type: "geometrySelector";
		content: WidgetResultGeometrySelector;
	} | {
		type: "geometryColorSelector";
		content: WidgetResultGeometryColorSelector;
	} | {
		type: "joiningSequenceEditor";
		content: WidgetResultJoiningSequenceEditor;
	} | {
		type: "layeredImportDialog";
		content: WidgetResultLayeredImportDialog;
	} | {
		type: "messageBox";
		content: WidgetResultMessageBox;
	} | {
		type: "processSelector";
		content: WidgetResultProcessSelector;
	} | {
		type: "sheetFilterEditor";
		content: WidgetResultSheetFilterEditor;
	} | {
		type: "sheetTappingEditor";
		content: WidgetResultSheetTappingEditor;
	} | {
		type: "userDataConfigEditor";
		content: WidgetResultUserDataConfigEditor;
	};
declare interface WidgetResultAssemblyView {
}
declare interface WidgetResultAttachmentEditor {
	attachments: (Attachment)[];
}
declare interface WidgetResultBendingToolEditor {
	dieChoiceMap: (DieChoiceMapEntry)[];
}
declare interface WidgetResultBulkEditor {
	rows?: (StringIndexedInterface)[];
	widgetState: string;
}
declare interface WidgetResultCalcParamEditor {
	materialCostsPerPiece?: number;
	setupTime?: number;
	unitTimePerPiece?: number;
	userDefinedScalePrices: (UserDefinedScalePrice)[];
}
declare interface WidgetResultFileDialog {
	paths: (string)[];
}
declare interface WidgetResultFormEditor {
	values: StringIndexedInterface;
}
declare interface WidgetResultGeometryColorSelector {
	selection: (GeometrySelectionEntry)[];
}
declare interface WidgetResultGeometrySelector {
	selection: (GeometrySelectionEntry)[];
}
declare interface WidgetResultJoiningSequenceEditor {
	joining: UiJoiningRepresentation;
}
declare interface WidgetResultLayeredImportDialog {
	twoDimRep: TwoDimRepresentation;
	thickness: number;
}
declare interface WidgetResultMessageBox {
	accepted: boolean;
}
declare interface WidgetResultProcessSelector {
	processId: string;
	forced: boolean;
}
declare interface WidgetResultSheetFilterEditor {
	filter: SheetFilter;
}
declare interface WidgetResultSheetTappingEditor {
	selection: (SheetTappingEditorSelectionEntry)[];
}
declare interface WidgetResultUserDataConfigEditor {
	configJson: string;
}
declare interface WorkStepTypeChangeResult {
	success: boolean;
	preGraph: PreDocumentGraph;
	changedVertices: (SlVertex)[];
}
declare namespace wsi4 {
		function throwError(message: string): never;
		function quit(): void;
		function isFeatureEnabled(feature: Feature): boolean;
		function setFeature(feature: Feature, value: boolean): void;
		function version(): ProgramVersion;

	namespace cad {
		function features(part: CadPart): (CadFeature)[];
		function coreHoleDiameter(throughHole: CadThroughHole, part: CadPart): number;
		function thickness(part: CadPart): number;
	}
	namespace calc {
		function sheetCuttingUnitTimePerPiece(vertex: Vertex, params: SheetCuttingCalcParams): number|undefined;
		function tubeCuttingUnitTimePerPiece(vertex: Vertex, params: TubeCuttingCalcParams): number|undefined;
	}
	namespace cam {namespace bend {
		function selectDieGroups(query: DieSelectorQuery, innerRadius: number, sheetBendingMaterialId: string|undefined): (BendDieChoice)[];
		function extractBendZones(twoDimRep: TwoDimRepresentation): (InnerOuterPolygon)[];
		function affectedSegments(twoDimRep: TwoDimRepresentation, bendDieAffectDistances: readonly Readonly<BendDieAffectDistanceEntry>[]): (Segment)[];
		function dieChoicesClose(lhs: BendDieChoice, rhs: BendDieChoice): boolean;
		function maxLowerDieOpeningWidth(bendLineData: BendLineData, flangeLength: BendLineFlangeLength, extraFlangeLength: number): number;
		function dieAffectDistanceMap(dieChoiceMap: (DieChoiceMapEntry)[], bendLineDataMap: (BendLineData)[], thickness: number): (BendDieAffectDistanceEntry)[];
	}}
	namespace cam {namespace nest2 {
		function asyncNest(nestorInput: CamNestorInput, nestorConfig: CamNestorConfig): TwoDimRepOptionalFuture;
		function nestingDescriptors(twoDimRep: TwoDimRepresentation): (number)[];
		function partDescriptors(twoDimRep: TwoDimRepresentation): (number)[];
		function partDescriptorFromIop(twoDimRep: TwoDimRepresentation, iop: InnerOuterPolygon): number|undefined;
		function partDescriptorFromTwoDimRep(nestingTwoDimRep: TwoDimRepresentation, partTwoDimRep: TwoDimRepresentation): number|undefined;
		function partIop(twoDimRep: TwoDimRepresentation, partDescriptor: number): InnerOuterPolygon;
		function nesting(twoDimRep: TwoDimRepresentation, nestingDescriptor: number): (Nest2PartInstance)[];
		function nestingBoundingBox(twoDimRep: TwoDimRepresentation, nestingDescriptor: number): Box2;
		function nestingTargetBoundary(twoDimRep: TwoDimRepresentation, nestingDescriptor: number): Polygon;
		function nestingMultiplicity(twoDimRep: TwoDimRepresentation, nestingDescriptor: number): number;
		function addNestingToScene(scene: Scene, twoDimRep: TwoDimRepresentation, nestingDescriptor: number, partStyle: SceneStyle): Scene;
		function netVolumeNestedParts(twoDimRep: TwoDimRepresentation, nestingDescriptor: number, innerContourAreaThreshold: number): number;
	}}
	namespace cam {namespace nest3 {
		function asyncNest(bin: Nest3InputBin, parts: readonly Readonly<Nest3Part>[], timeLimitInMilliseconds: number): Nest3ResultFuture;
	}}
	namespace cam {namespace util {
		function extractInnerOuterPolygons(twoDimRep: TwoDimRepresentation): (InnerOuterPolygon)[];
		function extractOverlappingAreas(twoDimRep: TwoDimRepresentation): (InnerOuterPolygon)[];
		function extractNesting(twoDimRep: TwoDimRepresentation): CamNesting|undefined;
		function extractNestingParts(twoDimRep: TwoDimRepresentation): ((CamNestedPart)[])[]|undefined;
		function extractEngravings(twoDimRep: TwoDimRepresentation): Scene;
		function computeNestingBoundingBoxes(twoDimRep: TwoDimRepresentation): (Box2)[];
		function twoDimRepFromLayered(layered: Layered, cuttingLayers: readonly Readonly<number>[], engravingLayers: readonly Readonly<number>[], tolerance: number, scaleFactor: number): TwoDimImportResult;
		function twoDimRepFromInnerOuterPolygon(innerOuterPolygon: InnerOuterPolygon): TwoDimRepresentation;
		function twoDimRepVolume(twoDimRep: TwoDimRepresentation): number;
		function boundingBox2(twoDimRep: TwoDimRepresentation): Box2;
		function createLst(twoDimRep: TwoDimRepresentation, parameters: LstCreationParameters): string;
		function cuttingContourCount(twoDimRep: TwoDimRepresentation): number;
		function cuttingContourLength(twoDimRep: TwoDimRepresentation): number;
		function addInnerOuterPolygonsToScene(scene: Scene, twoDimRep: TwoDimRepresentation, style: SceneStyle): Scene;
	}}
	namespace classifier {
		function classify(data: ArrayBuffer): InputType;
	}
	namespace documentCreator {
		function clear(): void;
		function addRow(row: (DocumentItem)[]): void;
		function pdf(): ArrayBuffer;
		function renderIntoPdf(rows: ((DocumentItem)[])[], format: DocumentFormat): ArrayBuffer;
		function renderIntoHtml(rows: ((DocumentItem)[])[], format: DocumentFormat): string;
		function generateDocX(input: ArrayBuffer, tables: (((DocXTableCell)[])[])[]): ArrayBuffer;
	}
	namespace geo {namespace assembly {
		function coordinateSystem(assembly: Assembly): CoordinateSystem3;
		function worldCoordinateSystem(assembly: Assembly): CoordinateSystem3;
		function brep(assembly: Assembly): Brep|undefined;
		function subAssemblies(assembly: Assembly): (Assembly)[];
		function recursiveSubAssemblies(assembly: Assembly): (Assembly)[];
		function name(assembly: Assembly): string;
		function createFileContent(assembly: Assembly, fileType: FileType): ArrayBuffer;
		function createStep(assembly: Assembly): ArrayBuffer;
		function computeDefaultCamera(assembly: Assembly): Camera3;
		function renderIntoPng(assembly: Assembly, camera: Camera3, resolution: Resolution): ArrayBuffer;
		function asyncRenderIntoPng(assembly: Assembly, camera: Camera3, resolution: Resolution): ArrayBufferFuture;
		function gltf(assembly: Assembly, dracoRepresentation: DracoRepresentation, globalVendorData: StringIndexedInterface, nodeVendorDatas: readonly Readonly<GltfNodeVendorData>[]): ArrayBuffer;
		function resolvePath(root: Assembly, path: AssemblyPath): Assembly|undefined;
		function computePath(root: Assembly, target: Assembly): AssemblyPath|undefined;
		function setEntityColors(assembly: Assembly, entities: (GeometryEntity)[], color: Vector3): Assembly;
		function fromIop(iop: InnerOuterPolygon, depth: number, name: string): Assembly;
		function setCoordinateSystem(assembly: Assembly, coordinateSystem: CoordinateSystem3): Assembly;
	}}
	namespace geo {namespace brep {
		function toPolyJson(brep: Brep): string;
		function area(brep: Brep): number;
		function faceArea(brep: Brep, fd: number): number;
		function dracoRepresentation(breps: (Brep)[]): DracoRepresentation;
		function faces(brep: Brep): (GeometryEntityDescriptor)[];
		function entityColor(brep: Brep, descriptor: GeometryEntityDescriptor): Vector3;
	}}
	namespace geo {namespace util {
		function createScene(sceneData: SceneSceneData): Scene;
		function serializeScene(scene: Scene): ArrayBuffer;
		function addInnerOuterPolygonsToScene(scene: Scene, innerOuterPolygons: readonly Readonly<InnerOuterPolygon>[], style: SceneStyle): Scene;
		function addPolygonsToScene(scene: Scene, polygons: readonly Readonly<Polygon>[], style: SceneStyle): Scene;
		function addSegmentsToScene(scene: Scene, segments: readonly Readonly<Segment>[], style: SceneStyle): Scene;
		function addLabelsToScene(scene: Scene, labels: readonly Readonly<SceneLabel>[]): Scene;
		function combineScenes(scenes: readonly Readonly<Scene>[]): Scene;
		function outerPolygon(iop: InnerOuterPolygon): Polygon;
		function innerPolygons(iop: InnerOuterPolygon): (Polygon)[];
		function circumference(geometricObject: Polygon): number;
		function pathLength(path: readonly Readonly<Segment>[]): number;
		function volume(object: Polygon|InnerOuterPolygon|Assembly): number;
		function boundingBox2d(geometricObject: Polygon|InnerOuterPolygon|Layered|readonly Readonly<InnerOuterPolygon>[]): Box2;
		function boundingBox3d(geometricObject: Assembly): Box3;
		function sceneBoundingBox(scene: Scene): Box2;
		function isIsomorphic(first: Assembly, second: Assembly): boolean;
		function createCoordinateSystem(origin: Vector3, xAxis: Vector3, yAxis: Vector3): CoordinateSystem3;
		function applyCoordinateSystem(parentCs: CoordinateSystem3, childCs: CoordinateSystem3): CoordinateSystem3;
		function invertCoordinateSystem(coordinateSystem: CoordinateSystem3): CoordinateSystem3;
		function toProjectiveTransformationMatrix(coordinateSystem: CoordinateSystem3): Matrix4;
		function createLayered(inputData: ArrayBuffer): Layered|undefined;
		function layers(layered: Layered): (Layer)[];
		function layersToScene(layered: Layered, layerDescriptors: readonly Readonly<number>[], sceneStyle: SceneStyle): Scene;
		function addLayersToScene(scene: Scene, layered: Layered, layerDescriptors: readonly Readonly<number>[], sceneStyle: SceneStyle): Scene;
		function layerDescriptorWithNumber(layered: Layered, layerNumber: number): number|undefined;
		function isLayerEmpty(layered: Layered, layerDescriptor: number): boolean;
		function extractInnerOuterPolygon(layered: Layered): InnerOuterPolygon|undefined;
		function createLayeredExtraData(inputData: ArrayBuffer): LayeredExtraData;
		function layerPaths(layered: Layered, layerDescriptor: number): ((Segment)[])[];
		function layerBoundingBox(layered: Layered, layerDescriptor: number): Box2;
		function renderScene(scene: Scene, fileType: FileType, renderSettings: RenderSceneSettings): ArrayBuffer;
		function rotationMatrix(u: Vector3, v: Vector3): Matrix3;
		function dump(innerOuterPolygon: InnerOuterPolygon): void;
		function createIop(segments: readonly Readonly<Segment>[]): InnerOuterPolygon|undefined;
		function isCircle(polygon: Polygon): boolean;
		function circleRadius(polygon: Polygon): number;
		function circleCenter(polygon: Polygon): Point2;
		function centroid(polygon: Polygon): Point2;
		function sceneSegments(scene: Scene): (Segment)[];
		function sceneSegmentsWithStyle(scene: Scene, styleFilter: SceneStyle): (Segment)[];
		function tsp(points: readonly Readonly<Point2>[]): (number)[];
		function polygonSegments(polygon: Polygon): (Segment)[];
		function transformIop(iop: InnerOuterPolygon, transformation: CoordinateSystem2): InnerOuterPolygon;
		function pathsIsomorphic(lhs: ((Segment)[])[], rhs: ((Segment)[])[], tol: number): boolean;
		function partiallyContained(path: (Segment)[], polygon: Polygon): boolean;
	}}
	namespace graph {
		function vertices(): (Vertex)[];
		function userData(): StringIndexedInterface;
		function serialize(): ArrayBuffer;
		function undirectedConnectedComponents(): ((Vertex)[])[];
		function serializeUndirectedConnectedComponent(vertex: Vertex, userData: StringIndexedInterface): ArrayBuffer;
		function serializeSubgraph(vertex: Vertex, userData: StringIndexedInterface): ArrayBuffer;
		function article(vertex: Vertex): (Vertex)[];
		function articles(): ((Vertex)[])[];
		function sources(vertex: Vertex): (Vertex)[];
		function targets(vertex: Vertex): (Vertex)[];
		function reaching(vertex: Vertex): (Vertex)[];
		function reachable(vertex: Vertex): (Vertex)[];
		function sourceMultiplicity(sourceVertex: Vertex, targetVertex: Vertex): number;
		function isDeletableArticle(vertex: Vertex): boolean;
		function currentUuid(): string;
		function semimanufacturedSourceShare(vertex: Vertex): number;
		function get(): DocumentGraph;
	}
	namespace graphManipulator {
		function clear(): void;
		function set(graph: DocumentGraph): void;
		function merge(graph: DocumentGraph): void;
		function undo(): boolean;
		function redo(): boolean;
		function clearUndoHistory(): boolean;
		function maxHistorySize(): number;
		function setMaxHistorySize(maxSize: number): boolean;
		function changeImportMultiplicities(vertexData: readonly Readonly<VertexWithMultiplicity>[], sheetNestingPrePartitions: readonly Readonly<SheetNestingPrePartition>[], tubeNestingDistance: number): void;
		function changeJoining(vertex: Vertex, joining: Joining): void;
		function deleteNodes(vertices: readonly Readonly<Vertex>[]): void;
		function deleteArticles(vertices: readonly Readonly<Vertex>[], sheetNestingPrePartitions: readonly Readonly<SheetNestingPrePartition>[]): boolean;
		function changeWorkStepTypes(vertexData: readonly Readonly<VertexWithWorkStepType>[]): WorkStepTypeChangeResult;
		function appendNode(source: Vertex, params: NewNodeParams): Vertex;
		function prependNode(target: Vertex, params: NewNodeParams): Vertex;
		function changeGraphUserData(userData: StringIndexedInterface): void;
		function setCommands(vertex: Vertex, commands: readonly Readonly<CamCommand>[]): void;
		function applyUpdates(nodeUpdates: (NodeUpdate)[], articleUpdates: (ArticleUpdate)[], sheetNestingPrePartitions: (SheetNestingPrePartition)[], tubeNestingPrePartition: (TubeNestingPrePartition)[]): void;
		function createUserDefinedBaseNode(processId: string, nodeUserData: StringIndexedInterface, articleUserData: StringIndexedInterface): Vertex;
	}
	namespace internal {
		function emitGuiData(guiData: PrivateGuiData): void;
		function isCompatibleToNodeUserDatum(key: NodeUserDataKey, wst: WorkStepType, pt: ProcessType, isInitial: boolean): boolean;
		function defaultSettingsTableValue(key: SettingsTableKey): number|string|boolean;
	}
	namespace io {namespace fs {
		function exists(path: string): boolean;
		function mkpath(path: string): boolean;
		function cleanFileName(name: string, replacement: string): string;
		function cleanRelativeDirPath(path: string, replacement: string): string;
		function cleanAbsoluteDirPath(path: string, replacement: string): string;
		function readFile(path: string): ArrayBuffer|undefined;
		function writeFile(path: string, content: ArrayBuffer): boolean;
		function symlink(targetPath: string, linkPath: string): boolean;
		function rm(path: string): boolean;
		function canonicalFilePath(path: string): string;
		function canonicalPath(path: string): string;
		function baseName(path: string): string;
		function completeBaseName(path: string): string;
		function createTmpDir(): string;
	}}
	namespace io {namespace net {namespace http {
		function get(url: string): HttpReply;
		function post(url: string, mimeType: string, data: ArrayBuffer): HttpReply;
		function put(url: string, mimeType: string, data: ArrayBuffer): HttpReply;
		function del(url: string): HttpReply;
	}}}
	namespace io {namespace settings {
		function read(key: string): string|undefined;
		function write(key: string, value: string): void;
		function remove(key: string): void;
	}}
	namespace io {namespace sql {
		function connect(properties: ConnectionProperties): boolean;
		function execQuery(connection: string, queryString: string): (StringIndexedInterface)[]|undefined;
		function listDrivers(): (string)[];
	}}
	namespace locale {
		function system(): string;
		function floatToString(value: number, locale: string, precision: number): string;
		function decimalPoint(locale: string): string;
	}
	namespace node {
		function nodeId(vertex: Vertex): GraphNodeId;
		function rootId(vertex: Vertex): GraphNodeRootId;
		function vertexFromNodeId(nodeId: GraphNodeId): Vertex|undefined;
		function vertexFromRootId(rootId: GraphNodeRootId): Vertex|undefined;
		function multiplicity(vertex: Vertex): number;
		function processId(vertex: Vertex): string;
		function processType(vertex: Vertex): ProcessType;
		function allowedProcessIds(vertex: Vertex): (string)[];
		function userData(vertex: Vertex): StringIndexedInterface;
		function articleUserData(vertex: Vertex): StringIndexedInterface;
		function deducedData(vertex: Vertex): StringIndexedInterface;
		function isImport(vertex: Vertex): boolean;
		function importMultiplicity(vertex: Vertex): number|undefined;
		function importId(vertex: Vertex): string|undefined;
		function workStepType(vertex: Vertex): WorkStepType;
		function sheetThickness(vertex: Vertex): number|undefined;
		function articleAttributes(vertex: Vertex): ArticleAttributes;
		function isInitial(vertex: Vertex): boolean;
		function flipSide(vertex: Vertex): boolean|undefined;
		function bendCorrection(vertex: Vertex): boolean|undefined;
		function packagingContainerWeights(vertex: Vertex): (number)[]|undefined;
		function joining(vertex: Vertex): Joining|undefined;
		function dieChoiceMap(vertex: Vertex): (DieChoiceMapEntry)[]|undefined;
		function dieChoiceAlternatives(vertex: Vertex, sheetMaterialIdOverride: string|undefined): (DieChoiceAlternativesEntry)[];
		function sheetFilter(vertex: Vertex): SheetFilter|undefined;
		function checkWorkStepAvailability(vertex: Vertex, workStepTypes: (WorkStepType)[]): (WorkStepType)[];
		function twoDimRep(vertex: Vertex): TwoDimRepresentation|undefined;
		function assembly(vertex: Vertex): Assembly|undefined;
		function inputAssembly(vertex: Vertex): Assembly|undefined;
		function bendLineSegmentsMap(vertex: Vertex): (BendLineSegmentsMapEntry)[];
		function computeBendLineData(vertex: Vertex): (BendLineData)[]|undefined;
		function computeBendLineFlangeLengths(vertex: Vertex): (BendLineFlangeLength)[]|undefined;
		function bendMeasurementScenes(vertex: Vertex, fontSize: number, resolution: Resolution): (MeasurementScene)[];
		function asyncBendMeasurementScenes(vertex: Vertex, fontSize: number, resolution: Resolution): MeasurementScenesFuture;
		function forcedProcessType(vertex: Vertex): boolean;
		function dump(vertex: Vertex): string;
		function camReplyStateIndicators(vertex: Vertex): ReplyStateIndicatorMap;
		function commands(vertex: Vertex): (CamCommand)[];
		function twoDimRepTransformation(vertex: Vertex): CoordinateSystem3|undefined;
		function hasProblematicGeometries(vertex: Vertex): boolean;
		function asyncCanForceSheetMetalPart(vertex: Vertex): BooleanFuture;
		function asyncProfileShadow(vertex: Vertex): ProfileShadowFuture;
		function tubeProfileGeometry(vertex: Vertex): TubeProfileGeometry|undefined;
		function profileExtrusionLength(vertex: Vertex): number;
		function tubeNestingResult(vertex: Vertex): CamTubeNestingResult|undefined;
		function layered(vertex: Vertex): Layered|undefined;
		function part(vertex: Vertex): undefined|CadPart;
		function twoDimProjection(vertex: Vertex, feature: CadFeature): (Segment)[];
		function hasTwoDimInput(vertex: Vertex): boolean;
		function editingState(vertex: Vertex): (NodeEditingStateEntry)[];
		function violatedConstraints(vertex: Vertex): (ViolatedNodeConstraint)[];
		function findAssociatedSheet(vertex: Vertex): Sheet|undefined;
		function findAssociatedTube(vertex: Vertex): Tube|undefined;
		function asyncScene(vertex: Vertex, config: SceneConfig): SceneFuture;
		function tubeCuttingNetVolume3(vertex: Vertex): number;
		function mass(vertex: Vertex): number|undefined;
	}
	namespace sharedData {
		function read(): StringIndexedInterface;
		function positionalArguments(): (string)[];
		function write(data: StringIndexedInterface): void;
		function scriptArgs(): (string)[];
	}
	namespace sl {namespace graph {
		function create(input: readonly Readonly<GraphCreatorInput>[], config: CadImportConfig): PreDocumentGraph;
		function deserialize(data: ArrayBuffer): GraphDeserializationResult;
		function mergePreGraph(graphToMergeInto: PreDocumentGraph|DocumentGraph, preGraph: PreDocumentGraph): PreDocumentGraph;
		function finalizePreGraph(graph: PreDocumentGraph, nodeUpdates: (SlNodeUpdate)[], articleUpdates: (SlArticleUpdate)[], sheetNestingPrePartition: (SlSheetNestingPrePartition)[], tubeNestingPrePartition: (SlTubeNestingPrePartition)[]): DocumentGraph;
		function finalizeImportedGraph(graph: ImportedDocumentGraph, nodeUpdates: (SlNodeUpdate)[], articleUpdates: (SlArticleUpdate)[], sheetNestingPrePartition: (SlSheetNestingPrePartition)[], tubeNestingPrePartition: (SlTubeNestingPrePartition)[], importId: string): DocumentGraph;
		function dump(graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): string;
		function vertices(graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (SlVertex)[];
		function articles(graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): ((SlVertex)[])[];
		function reaching(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (SlVertex)[];
		function reachable(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (SlVertex)[];
		function sources(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (SlVertex)[];
		function targets(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (SlVertex)[];
		function article(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (SlVertex)[];
	}}
	namespace sl {namespace node {
		function dump(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): string;
		function rootId(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): GraphNodeRootId;
		function importId(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): string|undefined;
		function vertexFromNodeId(nodeId: GraphNodeId, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): SlVertex|undefined;
		function vertexFromRootId(rootId: GraphNodeRootId, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): SlVertex|undefined;
		function multiplicity(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): number;
		function workStepType(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): WorkStepType;
		function part(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): CadPart;
		function inputAssembly(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): Assembly|undefined;
		function assembly(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): Assembly|undefined;
		function twoDimRep(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): undefined|TwoDimRepresentation;
		function bendLineData(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (BendLineData)[];
		function dieChoiceAlternatives(vertex: SlVertex, sheetMaterialIdOverride: string|undefined, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (DieChoiceAlternativesEntry)[];
		function bendLineFlangeLengths(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): (BendLineFlangeLength)[];
		function tubeProfileGeometry(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): TubeProfileGeometry|undefined;
		function profileExtrusionLength(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): number;
		function nodeUserData(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): StringIndexedInterface;
		function articleUserData(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): StringIndexedInterface;
		function processType(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): ProcessType;
		function processId(vertex: SlVertex, graph: PreDocumentGraph|ImportedDocumentGraph|DocumentGraph): string;
	}}
	namespace tables {
		function get(identifier: TableType): AnyTable;
		function getDefault(identifier: TableType): AnyTable;
		function setInternalTable(anyTable: AnyTable): void;
		function mergeIntoInternalTables(anyTables: (AnyTable)[], mergeMode: TableMergeMode): void;
		function setExternalTable(anyTable: AnyTable): void;
		function isInternalTable(type: TableType): boolean;
		function isExternalTable(type: TableType): boolean;
		function serialize(tableTypes: readonly Readonly<TableType>[]): ArrayBuffer;
		function deserialize(data: ArrayBuffer): undefined|(AnyTable)[];
		function findErrors(): (TableError)[];
		function commit(): void;
		function name(tableType: TableType): string;
		function toJson(tableType: TableType): string;
		function parseJson(tableType: TableType, json: string): undefined|AnyTable;
		function permissions(): DatabasePermissions;
	}
	namespace ui {
		function openUrl(url: string): void;
		function openFile(filePath: string): void;
		function show(config: WidgetConfig): undefined|WidgetResult;
	}
	namespace util {
		function translate(key: string): string;
		function toNumberString(value: number, digits: number): string;
		function toCurrencyString(value: number, digits: number): string;
		function toXml(json: string): string;
		function toBase64(data: ArrayBuffer): ArrayBuffer;
		function fromBase64(data: ArrayBuffer): ArrayBuffer;
		function arrayBufferToString(data: ArrayBuffer): string;
		function stringToArrayBuffer(data: string): ArrayBuffer;
		function stringToLatin1(data: string): ArrayBuffer;
		function compress(data: ArrayBuffer): ArrayBuffer;
		function uncompress(data: ArrayBuffer): ArrayBuffer;
		function createFileContentFromScene(scene: Scene, fileType: FileType): string|undefined;
		function toKey(object: Vertex|GraphNodeId|GraphNodeRootId|Assembly|Brep|TwoDimRepresentation): string;
		function toNumber(object: Vertex|GraphNodeId|GraphNodeRootId): number;
		function warn(message: string): void;
		function error(message: string): void;
		function info(message: string): void;
		function programInfo(): string;
		function isDebug(): boolean;
		function setDebug(debugOn: boolean): void;
		function parseCsv(input: string, delimiter: string): undefined|((string)[])[];
		function getFutureResult(future: ArrayBufferFuture|MeasurementScenesFuture|BooleanFuture|PolygonFuture|Nest3ResultFuture|TwoDimRepOptionalFuture|ProfileShadowFuture|SceneFuture): ArrayBuffer|(MeasurementScene)[]|boolean|Polygon|(Nest3ResultBox)[]|TwoDimRepresentation|ProfileShadow|Scene;
		function createUuid(): string;
		function deserializeUserDataConfig(data: string): UserDataConfig|undefined;
		function telemetry(message: string, keyValues: readonly Readonly<KeyValue>[]): void;
	}}