declare type FileType = "svg" | "dxf" | "step" | "png" | "geo";
declare type InputType = "undefined" | "documentGraph" | "assembly" | "layered" | "twoDimRep";
declare type DatabaseType = "mssql";
declare type FileSystemPathType = "directory" | "openFile" | "saveFile";
declare type WorkStepType = "undefined" | "sheet" | "sheetCutting" | "joining" | "tubeCutting" | "sheetBending" | "userDefined" | "userDefinedBase" | "packaging" | "transform" | "tube";
declare type BendDieChoiceType = "database" | "neutralAxis";
declare type DocumentItemType = "paragraph" | "heading" | "table" | "image" | "barcode" | "separator" | "pageBreak";
declare type DocumentAlignment = "left" | "center" | "right";
declare type DocumentImageType = "png" | "svg";
declare type DocumentOrientation = "portrait" | "landscape";
declare type GraphNodeProcessingState = "CreateWorkStep" | "UpdateWorkStep" | "CreateSources" | "FillFromSources" | "AfterFillFromSources" | "Finished";
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 TubeProfileGeometryType = "rectangular" | "circular";
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";
declare type TableErrorType = "referringEntryMissing" | "referredEntryMissing" | "valueInvalid" | "uniqueMemberCollision";
declare type Feature = "bendMeasurementScene" | "bomExport" | "graphRepExport" | "unlimitedNumExports" | "httpServiceUnfold" | "httpServiceNestor" | "httpServiceAssemblyTree" | "lstExport" | "erpInterfaceItBlech" | "tubeDetection" | "quotationExport";
declare type ReplyStateIndicatorPackaging = "undefinedError" | "insufficientPackageVolume" | "overweightParts";
declare type ReplyStateIndicatorTransform = "undefinedError";
declare type ReplyStateIndicatoruserDefined = "undefinedError";
declare type ReplyStateIndicatoruserDefinedBase = "undefinedError";
declare type ReplyStateIndicatorUndefined = "undefinedError";
declare type ReplyStateIndicatorTubeCutting = "undefinedError" | "undetectedFeatures";
declare type ReplyStateIndicatorJoining = "undefinedError";
declare type ReplyStateIndicatorSheet = "undefinedError" | "nestingFailed";
declare type ReplyStateIndicatorSheetCutting = "undefinedError" | "undetectedFeatures" | "multipleOuterContours" | "unused0";
declare type ReplyStateIndicatorSheetBending = "undefinedError" | "multipleOuterContours" | "contourInBend" | "invalidBend" | "undetectedFeatures";
declare type ReplyStateIndicatorTube = "undefinedError";
declare type FileDialogType = "openFile" | "openFiles" | "saveFile" | "directory";
declare type FormWidgetType = "checkBox" | "spinBox" | "dropDown" | "lineEdit" | "textEdit" | "label";
declare type MessageBoxType = "info" | "warning" | "error" | "question";
declare type GeometrySelectorConfigFlag = "edge" | "face";
declare type WidgetType = "assemblyView" | "attachmentEditor" | "bendingToolEditor" | "calcParamEditor" | "fileDialog" | "formEditor" | "geometrySelector" | "geometryColorSelector" | "joiningSequenceEditor" | "layeredImportDialog" | "messageBox" | "processSelector" | "sheetFilterEditor" | "sheetTappingEditor";
declare type SegmentType = "line" | "arc";
declare type GeometryEntityType = "edge" | "face";
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";
declare type StrokeStyle = "continuous" | "dashed";
declare type PrivateGuiDataType = "graphRep";
declare type TwoDimImportResultType = "partInvalid" | "engravingInvalid" | "success";
declare type DatabasePermission = "read" | "write";
declare type LocaleType = "language" | "csv";
declare type AddResultStatus = "success" | "unsupportedFormat" | "versionMismatch" | "inconsistentGraph" | "undefinedError" | "unsupportedVersion";
declare type TrumpfLoadingSystem = "manual" | "paletteChange" | "paletteChangeLiftMaster" | "onePalette" | "paletteChangeLiftMasterSort" | "paletteChangeLiftMasterSortPullingDevice";
declare type LstEvaporateMode = "none" | "early" | "beforeEachPart";
declare type SheetCorner = "lowerLeft" | "upperLeft" | "lowerRight" | "upperRight";
declare type CadFeatureType = "countersinking" | "throughHole";
declare type DocXTableCellType = "text" | "image" | "tables";
declare type DocXImageType = "png" | "svg";
declare interface Polygon { _nonexistent_Polygon: never; }
declare interface InnerOuterPolygon { _nonexistent_InnerOuterPolygon: never; }
declare interface Scene { _nonexistent_Scene: never; }
declare interface Layered { _nonexistent_Layered: never; }
declare interface Brep { _nonexistent_Brep: never; }
declare interface Assembly { _nonexistent_Assembly: never; }
declare interface TwoDimRepresentation { _nonexistent_TwoDimRepresentation: never; }
declare interface CadPart { _nonexistent_CadPart: never; }
declare interface Vertex { _nonexistent_Vertex: never; }
declare interface GraphNodeId { _nonexistent_GraphNodeId: never; }
declare interface GraphNodeRootId { _nonexistent_GraphNodeRootId: never; }
declare interface ArrayBufferFuture { _nonexistent_ArrayBufferFuture: never; }
declare interface MeasurementScenesFuture { _nonexistent_MeasurementScenesFuture: never; }
declare interface BooleanFuture { _nonexistent_BooleanFuture: never; }
declare interface PolygonFuture { _nonexistent_PolygonFuture: never; }
declare interface TwoDimRepOptionalFuture { _nonexistent_TwoDimRepOptionalFuture: never; }
declare interface Nest3ResultFuture { _nonexistent_Nest3ResultFuture: never; }
declare interface StringIndexedInterface {
	[index: string]: unknown;
}
declare interface BendReplyStateContentUndefinedError {
}
declare interface BendReplyStateContentContourInBend {
}
declare interface BendReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}
declare interface BendReplyStateContentInvalidBend {
}
declare interface BendReplyStateContentMultipleOuterContours {
}
declare interface SheetCuttingReplyStateContentUndefinedError {
}
declare interface SheetCuttingReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}
declare interface SheetCuttingReplyStateContentMultipleOuterContours {
}
declare interface Unused {
}
declare interface PackagingReplyStateContentUndefinedError {
}
declare interface PackagingReplyStateContentInsufficientPackageVolume {
}
declare interface PackagingReplyStateContentOverweightParts {
}
declare interface TransformReplyStateContentUndefinedError {
}
declare interface JoiningReplyStateContentUndefinedError {
}
declare interface SheetReplyStateContentUndefinedError {
}
declare interface SheetReplyStateContentNestingFailedError {
}
declare interface UndefinedReplyStateContentUndefinedError {
}
declare interface UserDefinedReplyStateContentUndefinedError {
}
declare interface UserDefinedBaseReplyStateContentUndefinedError {
}
declare interface TubeCuttingReplyStateContentUndefinedError {
}
declare interface TubeCuttingReplyStateContentUndetectedFeatures {
	unassignedFaceDescriptors: (number)[];
}
declare interface TubeReplyStateContentUndefinedError {
}
declare interface ReplyStateMapSheet {
	undefinedError?: SheetReplyStateContentUndefinedError;
	nestingFailed?: SheetReplyStateContentNestingFailedError;
}
declare interface ReplyStateMapSheetBending {
	undefinedError?: BendReplyStateContentUndefinedError;
	multipleOuterContours?: BendReplyStateContentMultipleOuterContours;
	contourInBend?: BendReplyStateContentContourInBend;
	invalidBend?: BendReplyStateContentInvalidBend;
	undetectedFeatures?: BendReplyStateContentUndetectedFeatures;
}
declare interface ReplyStateMapJoining {
	undefinedError?: JoiningReplyStateContentUndefinedError;
}
declare interface ReplyStateMapSheetCutting {
	undefinedError?: SheetCuttingReplyStateContentUndefinedError;
	undetectedFeatures?: SheetCuttingReplyStateContentUndetectedFeatures;
	multipleOuterContours?: SheetCuttingReplyStateContentMultipleOuterContours;
	unused0?: Unused;
}
declare interface ReplyStateMapPackaging {
	undefinedError?: PackagingReplyStateContentUndefinedError;
	insufficientPackageVolume?: PackagingReplyStateContentInsufficientPackageVolume;
	overweightParts?: PackagingReplyStateContentOverweightParts;
}
declare interface ReplyStateMapTransform {
	undefinedError?: TransformReplyStateContentUndefinedError;
}
declare interface ReplyStateMapTube {
	undefinedError?: TubeReplyStateContentUndefinedError;
}
declare interface ReplyStateMapUndefined {
	undefinedError?: UndefinedReplyStateContentUndefinedError;
}
declare interface ReplyStateMapUserDefined {
	undefinedError?: UserDefinedReplyStateContentUndefinedError;
}
declare interface ReplyStateMapUserDefinedBase {
	undefinedError?: UserDefinedBaseReplyStateContentUndefinedError;
}
declare interface ReplyStateMapTubeCutting {
	undefinedError?: TubeCuttingReplyStateContentUndefinedError;
	undetectedFeatures?: TubeCuttingReplyStateContentUndetectedFeatures;
}
declare interface ReplyStateIndicatorsUndefined {
	replyStateIndicators: ReplyStateMapUndefined;
}
declare interface ReplyStateIndicatorsSheet {
	replyStateIndicators: ReplyStateMapSheet;
}
declare interface ReplyStateIndicatorsSheetCutting {
	replyStateIndicators: ReplyStateMapSheetCutting;
}
declare interface ReplyStateIndicatorsJoining {
	replyStateIndicators: ReplyStateMapJoining;
}
declare interface ReplyStateIndicatorsTubeCutting {
	replyStateIndicators: ReplyStateMapTubeCutting;
}
declare interface ReplyStateIndicatorsUserDefined {
	replyStateIndicators: ReplyStateMapUserDefined;
}
declare interface ReplyStateIndicatorsUserDefinedBase {
	replyStateIndicators: ReplyStateMapUserDefinedBase;
}
declare interface ReplyStateIndicatorsSheetBending {
	replyStateIndicators: ReplyStateMapSheetBending;
}
declare interface ReplyStateIndicatorsPackaging {
	replyStateIndicators: ReplyStateMapPackaging;
}
declare interface ReplyStateIndicatorsTransform {
	replyStateIndicators: ReplyStateMapTransform;
}
declare interface ReplyStateIndicatorsTube {
	replyStateIndicators: ReplyStateMapTube;
}
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 CamNestedPart {
	innerOuterPolygon: InnerOuterPolygon;
	coordinateSystem: CoordinateSystem2;
}
declare interface CamSheet {
	dimX: number;
	dimY: number;
	multiplicity: number;
}
declare interface CamNesting {
	sheets: (CamSheet)[];
}
declare interface CamTubeNestingResultNesting {
	transformations: (CoordinateSystem3)[];
	multiplicity: number;
}
declare interface CamTubeNestingResult {
	inputLength: number;
	nestings: (CamTubeNestingResultNesting)[];
}
declare interface Box2 {
	lower: Point2;
	upper: Point2;
}
declare interface Box3 {
	lower: Point3;
	upper: Point3;
}
declare interface Point2 {
	entries: [ (number), (number), ];
}
declare interface Point3 {
	entries: [ (number), (number), (number), ];
}
declare interface Vector2 {
	entries: [ (number), (number), ];
}
declare interface Vector3 {
	entries: [ (number), (number), (number), ];
}
declare interface Vector4 {
	entries: [ (number), (number), (number), (number), ];
}
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 CoordinateSystem2 {
	origin: Vector2;
	unitaryMatrix: Matrix2;
}
declare interface CoordinateSystem3 {
	origin: Vector3;
	unitaryMatrix: Matrix3;
}
declare interface ConnectionProperties {
	databaseType: DatabaseType;
	name: string;
	hostName: string;
	port: number;
	databaseName: string;
	userName: string;
	password: string;
}
declare interface ArticleAttributes {
	userData: StringIndexedInterface;
}
declare interface DieSelectorQuery {
	thickness: number;
	bendAngle: number;
	maxOpeningWidth: number;
}
declare interface CamBendDeduction {
	roundDeduction: number;
	innerRadius: number;
}
declare interface BendDieChoice {
	baseClass: CamBendDeduction;
	upperDieGroupId: string;
	lowerDieGroupId: string;
	thickness: number;
	type: BendDieChoiceType;
	sharpDeduction: number;
}
declare interface DieChoiceMapEntry {
	bendDescriptor: number;
	bendDieChoice: BendDieChoice;
}
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 SceneLabel {
	position: Point2;
	text: string;
}
declare interface Layer {
	descriptor: number;
	number: number;
	name: string;
}
declare interface AddResult {
	id: string;
	status: AddResultStatus;
	vertices: (Vertex)[];
}
declare interface BendLineData {
	constructedInnerRadius: number;
	resultingInnerRadius: number;
	bendAngle: number;
	bendDescriptor: number;
	segments: (Segment)[];
}
declare interface BendLineFlangeLength {
	flangeLengthLhs: number;
	flangeLengthRhs: number;
	bendDescriptor: number;
}
declare interface MeasurementScene {
	scene: Scene;
	camera: Camera3;
}
declare interface DocumentParagraph {
	width: number;
	text: string;
	alignment: DocumentAlignment;
}
declare interface DocumentSeparator {
}
declare interface DocumentHeading {
	level: number;
	text: string;
}
declare interface DocumentBarcode {
	width: number;
	text: string;
	alignment: DocumentAlignment;
}
declare interface DocumentImage {
	width: number;
	type: DocumentImageType;
	uuid: string;
	data: ArrayBuffer;
	alignment: DocumentAlignment;
}
declare interface DocumentTable {
	width: number;
	columnWidths: (number)[];
	columnHeaders: DocumentTableRow;
	rows: (DocumentTableRow)[];
}
declare interface DocumentTableCell {
	text: string;
	alignment: DocumentAlignment;
}
declare interface DocumentTableRow {
}
declare interface DocumentPageBreak {
}
declare interface DocumentItem {
	type: DocumentItemType;
	content: DocumentParagraph|DocumentHeading|DocumentTable|DocumentImage|DocumentBarcode|DocumentSeparator|DocumentPageBreak;
}
declare interface DocumentFormat {
	orientation: DocumentOrientation;
}
declare interface Camera3 {
	eye: Point3;
	center: Point3;
	up: Vector3;
}
declare interface InputContentUndefined {
}
declare interface InputContentDocumentGraph {
	data: ArrayBuffer;
	id: string;
}
declare interface InputContentAssembly {
	data: ArrayBuffer;
	id: string;
}
declare interface InputContentLayered {
	data: Layered;
	thickness: number;
	tolerance: number;
	name: string;
	id: string;
}
declare interface InputContentTwoDimRep {
	twoDimRep: TwoDimRepresentation;
	thickness: number;
	name: string;
	id: string;
}
declare interface Input {
	type: InputType;
	content: InputContentUndefined|InputContentDocumentGraph|InputContentAssembly|InputContentLayered|InputContentTwoDimRep;
}
declare interface IdRefPair {
	id: string;
	reference: Assembly|Brep|TwoDimRepresentation;
}
declare interface CadCountersinking {
	featureDescriptor: number;
}
declare interface CadThroughHole {
	featureDescriptor: number;
}
declare interface CadFeature {
	type: CadFeatureType;
	content: CadCountersinking|CadThroughHole;
}
declare interface CameraOrientation3 {
	center: Vector3;
	direction: Vector3;
	up: Vector3;
}
declare interface JoiningStepEntry {
	assembly: Assembly;
}
declare interface JoiningStep {
	entries: (JoiningStepEntry)[];
	cameraOrientation?: CameraOrientation3;
	comment: string;
}
declare interface Joining {
	joiningSteps: (JoiningStep)[];
}
declare interface SheetFilter {
	ids: (string)[];
}
declare interface VertexWithProcessTypeData {
	vertex: Vertex;
	processId: string;
	forced: boolean;
}
declare interface VertexWithUserData {
	vertex: Vertex;
	userData: StringIndexedInterface;
}
declare interface VertexWithMultiplicity {
	vertex: Vertex;
	multiplicity: number;
}
declare interface HandlerPackaging {
	package: Box3;
	maxWeight: number;
	masses: (number)[];
}
declare interface HandlerPostProcessSheetBending {
	upperDieAffectDistances: (number)[];
	lowerDieAffectDistances: (number)[];
}
declare interface VertexWithArticleAttributes {
	vertex: Vertex;
	articleAttributes: ArticleAttributes;
}
declare interface HandlerPostProcessCreateSources {
	attributes: (VertexWithArticleAttributes)[];
}
declare interface HandlerPreProcessCreateWorkStep {
	processTable: (Process)[];
}
declare interface PrivatePostProcessingResultCreateWorkStep {
	processType: ProcessType;
	processId: string;
	nodeUserData: StringIndexedInterface;
	articleUserData?: StringIndexedInterface;
}
declare interface PrivatePostProcessingResultCreateSourcesSheetCutting {
	source: Vertex;
	deducedDataOfSource: StringIndexedInterface;
}
declare interface UiJoiningStepEntryRepresentation {
	assembly: string;
	identifier: string;
}
declare interface UiJoiningStepRepresentation {
	entries: (UiJoiningStepEntryRepresentation)[];
	cameraOrientation?: CameraOrientation3;
	comment: string;
}
declare interface UiJoiningRepresentation {
	joiningSteps: (UiJoiningStepRepresentation)[];
}
declare interface Attachment {
	name: string;
	data: string;
}
declare interface FormWidgetCheckBoxConfig {
	initialValue: boolean;
}
declare interface FormWidgetSpinBoxConfig {
	initialValue: number;
	min: number;
	max: number;
	decimals: number;
}
declare interface FormWidgetDropDownEntry {
	id: string;
	text: string;
}
declare interface FormWidgetDropDownConfig {
	initialValue: string;
	entries: (FormWidgetDropDownEntry)[];
}
declare interface FormWidgetLineEditConfig {
	initialValue: string;
}
declare interface FormWidgetTextEditConfig {
	initialValue: string;
}
declare interface FormWidgetLabelConfig {
	initialValue: string;
}
declare interface FormWidgetConfig {
	type: FormWidgetType;
	content: FormWidgetCheckBoxConfig|FormWidgetSpinBoxConfig|FormWidgetDropDownConfig|FormWidgetLineEditConfig|FormWidgetTextEditConfig|FormWidgetLabelConfig;
}
declare interface FormRowConfig {
	key: string;
	name: string;
	config: FormWidgetConfig;
}
declare interface GeometrySelectionEntry {
	entities: (GeometryEntity)[];
	data: StringIndexedInterface;
}
declare interface SheetTappingEditorCandidateValue {
	id: string;
	name: string;
}
declare interface SheetTappingEditorCandidate {
	id: string;
	name: string;
	values: (SheetTappingEditorCandidateValue)[];
}
declare interface SheetTappingEditorSelectionEntry {
	candidateId: string;
	valueId: string;
}
declare interface UserDefinedScalePrice {
	scaleValue: number;
	price: number;
}
declare interface BendingToolEditorInputEntry {
	bendDescriptor: number;
	angle: number;
	constructedInnerRadius: number;
	bendDieChoices: (BendDieChoice)[];
}
declare interface WidgetConfigAssemblyView {
	assembly: Assembly;
}
declare interface WidgetConfigAttachmentEditor {
	initialValue: WidgetResultAttachmentEditor;
}
declare interface WidgetConfigBendingToolEditor {
	input: (BendingToolEditorInputEntry)[];
	initialValue: WidgetResultBendingToolEditor;
}
declare interface WidgetConfigCalcParamEditor {
	initialValue: WidgetResultCalcParamEditor;
}
declare interface WidgetConfigFileDialog {
	type: FileDialogType;
	title: string;
	defaultPath: string;
	filter: string;
}
declare interface WidgetConfigFormEditor {
	rows: (FormRowConfig)[];
}
declare interface WidgetConfigGeometrySelector {
	flags: GeometrySelectorConfigFlags;
	assembly: Assembly;
	formEditorConfig: WidgetConfigFormEditor;
	initialValue: WidgetResultGeometrySelector;
}
declare interface WidgetConfigGeometryColorSelector {
	flags: GeometrySelectorConfigFlags;
	assembly: Assembly;
	formEditorConfig: WidgetConfigFormEditor;
	colorDataKey: string;
	initialValue: WidgetResultGeometryColorSelector;
}
declare interface AssemblyMapEntry {
	id: string;
	assembly: Assembly;
}
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 WidgetConfig {
	type: WidgetType;
	content: WidgetConfigAssemblyView|WidgetConfigAttachmentEditor|WidgetConfigBendingToolEditor|WidgetConfigCalcParamEditor|WidgetConfigFileDialog|WidgetConfigFormEditor|WidgetConfigGeometrySelector|WidgetConfigGeometryColorSelector|WidgetConfigJoiningSequenceEditor|WidgetConfigLayeredImportDialog|WidgetConfigMessageBox|WidgetConfigProcessSelector|WidgetConfigSheetFilterEditor|WidgetConfigSheetTappingEditor;
}
declare interface WidgetResultAssemblyView {
}
declare interface WidgetResultAttachmentEditor {
	attachments: (Attachment)[];
}
declare interface WidgetResultBendingToolEditor {
	dieChoiceMap: (DieChoiceMapEntry)[];
}
declare interface WidgetResultCalcParamEditor {
	materialCostsPerPiece?: number;
	setupTime?: number;
	unitTimePerPiece?: number;
	userDefinedScalePrices: (UserDefinedScalePrice)[];
}
declare interface WidgetResultFileDialog {
	paths: (string)[];
}
declare interface WidgetResultFormEditor {
	values: StringIndexedInterface;
}
declare interface WidgetResultGeometrySelector {
	selection: (GeometrySelectionEntry)[];
}
declare interface WidgetResultGeometryColorSelector {
	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 WidgetResult {
	type: WidgetType;
	content: WidgetResultAssemblyView|WidgetResultAttachmentEditor|WidgetResultBendingToolEditor|WidgetResultCalcParamEditor|WidgetResultFileDialog|WidgetResultFormEditor|WidgetResultGeometrySelector|WidgetResultGeometryColorSelector|WidgetResultJoiningSequenceEditor|WidgetResultLayeredImportDialog|WidgetResultMessageBox|WidgetResultProcessSelector|WidgetResultSheetFilterEditor|WidgetResultSheetTappingEditor;
}
declare interface TubeProfileGeometryRectangular {
	dimY: number;
	dimZ: number;
	thickness: number;
}
declare interface TubeProfileGeometryCircular {
	outerRadius: number;
	thickness: number;
}
declare interface TubeProfileGeometry {
	type: TubeProfileGeometryType;
	content: TubeProfileGeometryRectangular|TubeProfileGeometryCircular;
}
declare interface Nest2PartInstance {
	descriptor: number;
	transformation: CoordinateSystem2;
}
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 SheetCuttingMaterialMappingUniqueMembers {
	sheetMaterialId: string;
}
declare interface SheetCuttingMaterialMapping extends SheetCuttingMaterialMappingUniqueMembers{
	sheetCuttingMaterialId: string;
}
declare interface SheetBendingMaterialMappingUniqueMembers {
	sheetMaterialId: string;
}
declare interface SheetBendingMaterialMapping extends SheetBendingMaterialMappingUniqueMembers{
	sheetBendingMaterialId: string;
}
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 BendRateParametersUniqueMembers {
	sheetBendingMaterialId: string;
	thickness: number;
	bendLineNetLength: number;
}
declare interface BendRateParameters extends BendRateParametersUniqueMembers{
	hourlyRateFactor: number;
	hourlyRateDelta: number;
}
declare interface BendLineConstraintUniqueMembers {
	sheetBendingMaterialId: string;
	thickness: number;
}
declare interface BendLineConstraint extends BendLineConstraintUniqueMembers{
	maxNetLength: number;
}
declare interface LaserSheetCuttingGasUniqueMembers {
	identifier: string;
}
declare interface LaserSheetCuttingGas extends LaserSheetCuttingGasUniqueMembers{
	name: string;
}
declare interface LaserSheetCuttingSpeedUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
	thickness: number;
}
declare interface LaserSheetCuttingSpeed extends LaserSheetCuttingSpeedUniqueMembers{
	speed: 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 LaserSheetCuttingMinAreaUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
	thickness: number;
}
declare interface LaserSheetCuttingMinArea extends LaserSheetCuttingMinAreaUniqueMembers{
	area: number;
}
declare interface LaserSheetCuttingMaxThicknessUniqueMembers {
	sheetCuttingMaterialId: string;
	laserSheetCuttingGasId: string;
}
declare interface LaserSheetCuttingMaxThickness extends LaserSheetCuttingMaxThicknessUniqueMembers{
	maxThickness: number;
	minThickness: 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 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 SurchargeUniqueMembers {
	name: string;
	type: string;
	value: number;
}
declare interface Surcharge extends SurchargeUniqueMembers{
	description: string;
}
declare interface ProcessUniqueMembers {
	identifier: string;
}
declare interface Process extends ProcessUniqueMembers{
	parentIdentifier: string;
	type: ProcessType;
	name: string;
	costCenter: string;
	active: boolean;
	childrenActive: boolean;
	description: string;
}
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 SheetUniqueMembers {
	identifier: string;
}
declare interface Sheet extends SheetUniqueMembers{
	name: string;
	sheetMaterialId: string;
	dimX: number;
	dimY: number;
	thickness: number;
	description: string;
}
declare interface SheetModulusUniqueMembers {
	sheetId: string;
}
declare interface SheetModulus extends SheetModulusUniqueMembers{
	xModulus: number;
	yModulus: number;
	applyToAll: boolean;
}
declare interface SheetPriceUniqueMembers {
	sheetId: string;
}
declare interface SheetPrice extends SheetPriceUniqueMembers{
	pricePerSheet: number;
}
declare interface UpperDieGroupUniqueMembers {
	identifier: string;
}
declare interface UpperDieGroup extends UpperDieGroupUniqueMembers{
	name: string;
	exportIdentifier: string;
	radius: number;
}
declare interface LowerDieGroupUniqueMembers {
	identifier: string;
}
declare interface LowerDieGroup extends LowerDieGroupUniqueMembers{
	name: string;
	exportIdentifier: string;
	openingWidth: 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 SettingUniqueMembers {
	key: string;
}
declare interface Setting extends SettingUniqueMembers{
	value: 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 DimensionConstraintsUniqueMembers {
	processId: string;
}
declare interface DimensionConstraints extends DimensionConstraintsUniqueMembers{
	minX: number;
	minY: number;
	minZ: number;
	maxX: number;
	maxY: number;
	maxZ: number;
}
declare interface ScrewThreadUniqueMembers {
	identifier: string;
}
declare interface ScrewThread extends ScrewThreadUniqueMembers{
	name: string;
	coreHoleDiameter: number;
	minDepth: number;
	symmetricTolerance: number;
}
declare interface TappingTimeParametersUniqueMembers {
	processId: string;
	screwThreadId: string;
}
declare interface TappingTimeParameters extends TappingTimeParametersUniqueMembers{
	unitTimePerMm: 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 TubeProfileUniqueMembers {
	identifier: string;
}
declare interface TubeProfile extends TubeProfileUniqueMembers{
	name: string;
	description: string;
	geometryJson: string;
}
declare interface TubeSpecificationUniqueMembers {
	identifier: string;
}
declare interface TubeSpecification extends TubeSpecificationUniqueMembers{
	name: string;
	description: string;
}
declare interface TubeUniqueMembers {
	identifier: string;
}
declare interface Tube extends TubeUniqueMembers{
	name: string;
	tubeMaterialId: string;
	tubeProfileId: string;
	tubeSpecificationId: string;
	dimX: number;
}
declare interface UpperDieUniqueMembers {
	identifier: string;
}
declare interface UpperDie extends UpperDieUniqueMembers{
	name: string;
	upperDieGroupId: string;
	description: string;
}
declare interface LowerDieUniqueMembers {
	identifier: string;
}
declare interface LowerDie extends LowerDieUniqueMembers{
	name: string;
	lowerDieGroupId: string;
	description: string;
}
declare interface UpperDieUnitUniqueMembers {
	upperDieId: string;
	dimX: number;
}
declare interface UpperDieUnit extends UpperDieUnitUniqueMembers{
	multiplicity: number;
}
declare interface LowerDieUnitUniqueMembers {
	lowerDieId: string;
	dimX: number;
}
declare interface LowerDieUnit extends LowerDieUnitUniqueMembers{
	multiplicity: number;
}
declare interface ProcessHandlingTimeUniqueMembers {
	processId: string;
	mass: number;
}
declare interface ProcessHandlingTime extends ProcessHandlingTimeUniqueMembers{
	setupTimeDelta: number;
	unitTimeDelta: number;
}
declare interface SheetStockUniqueMembers {
	sheetId: string;
}
declare interface SheetStock extends SheetStockUniqueMembers{
	count: number;
}
declare interface ProcessIdlePeriodUniqueMembers {
	processId: string;
}
declare interface ProcessIdlePeriod extends ProcessIdlePeriodUniqueMembers{
	time: number;
}
declare interface SheetMaterialScrapValueUniqueMembers {
	sheetMaterialId: string;
}
declare interface SheetMaterialScrapValue extends SheetMaterialScrapValueUniqueMembers{
	scrapValue: number;
}
declare interface SheetPriorityUniqueMembers {
	sheetId: string;
}
declare interface SheetPriority extends SheetPriorityUniqueMembers{
	priority: number;
}
declare interface DieGroupPriorityUniqueMembers {
	upperDieGroupId: string;
	lowerDieGroupId: string;
	sheetBendingMaterialId: string;
	sheetThickness: number;
}
declare interface DieGroupPriority extends DieGroupPriorityUniqueMembers{
	priority: number;
}
declare interface SheetCuttingMaterialUniqueMembers {
	identifier: string;
}
declare interface SheetCuttingMaterial extends SheetCuttingMaterialUniqueMembers{
	name: string;
}
declare interface SheetBendingMaterialUniqueMembers {
	identifier: string;
}
declare interface SheetBendingMaterial extends SheetBendingMaterialUniqueMembers{
	name: string;
}
declare interface TubeCuttingProcessUniqueMembers {
	identifier: string;
}
declare interface TubeCuttingProcess extends TubeCuttingProcessUniqueMembers{
	name: string;
}
declare interface TubeCuttingProcessMappingUniqueMembers {
	processId: string;
	tubeMaterialId: string;
}
declare interface TubeCuttingProcessMapping extends TubeCuttingProcessMappingUniqueMembers{
	tubeCuttingProcessId: string;
}
declare interface TubeCuttingSpeedUniqueMembers {
	tubeCuttingProcessId: string;
	thickness: number;
}
declare interface TubeCuttingSpeed extends TubeCuttingSpeedUniqueMembers{
	speed: number;
}
declare interface TubeCuttingPierceTimeUniqueMembers {
	tubeCuttingProcessId: string;
	thickness: number;
}
declare interface TubeCuttingPierceTime extends TubeCuttingPierceTimeUniqueMembers{
	time: number;
}
declare interface TubePriceUniqueMembers {
	tubeId: string;
}
declare interface TubePrice extends TubePriceUniqueMembers{
	pricePerTube: number;
}
declare interface TubeStockUniqueMembers {
	tubeId: string;
}
declare interface TubeStock extends TubeStockUniqueMembers{
	count: number;
}
declare interface TubeMaterialScrapValueUniqueMembers {
	tubeMaterialId: string;
}
declare interface TubeMaterialScrapValue extends TubeMaterialScrapValueUniqueMembers{
	scrapValue: number;
}
declare interface AnyTable {
	type: TableType;
	content: (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)[];
}
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 InvalidValueTableError {
	affectedRowType: TableType;
	affectedRowIndex: number;
	affectedColumnIndex: number;
}
declare interface UniqueMemberCollisionTableError {
	affectedRowType: TableType;
	affectedRowIndex: number;
	affectedColumnIndex: number;
	relatedRowIndex: number;
}
declare interface TableError {
	type: TableErrorType;
	content: ReferringEntryMissingTableError|ReferredEntryMissingTableError|InvalidValueTableError|UniqueMemberCollisionTableError;
}
declare interface HttpReply {
	errorCode: number;
	data: ArrayBuffer;
}
declare interface LineSegment {
	from: Point2;
	to: Point2;
}
declare interface ArcSegment {
	from: Point2;
	to: Point2;
	center: Point2;
	ccw: boolean;
}
declare interface Segment {
	type: SegmentType;
	content: LineSegment|ArcSegment;
}
declare interface SceneStyle {
	strokeWidth?: number;
	strokeColor?: Color;
	fillColor?: Vector4;
	strokeStyle?: StrokeStyle;
	zValue?: number;
}
declare interface ProgramVersion {
	major: number;
	minor: number;
	patch: number;
}
declare interface GeometryEntityDescriptorContentEdge {
	value: number;
}
declare interface GeometryEntityDescriptorContentFace {
	value: number;
}
declare interface GeometryEntityDescriptor {
	type: GeometryEntityType;
	content: GeometryEntityDescriptorContentEdge|GeometryEntityDescriptorContentFace;
}
declare interface GeometryEntity {
	assemblyPath: AssemblyPath;
	descriptor: GeometryEntityDescriptor;
}
declare interface CamCommandSetColor {
	entities: (GeometryEntity)[];
	color: Vector3;
}
declare interface CamCommand {
	type: CamCommandType;
	content: CamCommandSetColor;
}
declare interface CamNestorInputPart {
	iop: InnerOuterPolygon;
	minCount: number;
	maxCount: number;
	fixedRotations: (number)[];
}
declare interface CamNestorInput {
	parts: (CamNestorInputPart)[];
	targetBoundary: Polygon;
	nestingDistance: number;
}
declare interface CamNestorConfig {
	timeout: number;
	numRelevantNestings: number;
}
declare interface CamWorkStepUpdateInputSheet {
	nestorInput: CamNestorInput;
	nestorConfig: CamNestorConfig;
}
declare interface CamWorkStepUpdateInputTube {
	length: number;
	multiplicity: number;
	nestingDistance: number;
}
declare interface AssemblyPath {
	indices: (number)[];
}
declare interface LayeredExtraData {
	thickness: number;
	name: string;
	material: string;
}
declare interface RenderSceneSettings {
	viewPort?: Box2;
}
declare interface TwoDimImportResultPartInvalid {
	problematicPoint?: Point2;
}
declare interface TwoDimImportResultEngravingInvalid {
	problematicPoint: Point2;
}
declare interface TwoDimImportResultSuccess {
	twoDimRep: TwoDimRepresentation;
}
declare interface TwoDimImportResult {
	type: TwoDimImportResultType;
	content: TwoDimImportResultPartInvalid|TwoDimImportResultEngravingInvalid|TwoDimImportResultSuccess;
}
declare interface PrivateManufacturingStateEntry {
	level: string;
	message: string;
}
declare interface PrivateManufacturingStateResourceEntry {
	nodeId: GraphNodeId;
	actualState: (PrivateManufacturingStateEntry)[];
	virtualState: (PrivateManufacturingStateEntry)[];
}
declare interface PrivateNodeRepresentation {
	nodeId: GraphNodeId;
	rootId: GraphNodeRootId;
	sourceNodeIds: (GraphNodeId)[];
	targetNodeIds: (GraphNodeId)[];
	workStepType: WorkStepType;
	processType: ProcessType;
	processId: string;
	processName: string;
}
declare interface PrivateArticleRepresentation {
	name: string;
	externalPartNumber: string;
	externalDrawingNumber: string;
	externalRevisionNumber: string;
	comment: string;
	multiplicity: number;
	nodeId: GraphNodeId;
	rootId: GraphNodeRootId;
	nodeIds: (GraphNodeId)[];
}
declare interface PrivateAssemblyResourceEntry {
	nodeId: GraphNodeId;
	assembly: Assembly;
}
declare interface PrivateBinaryResourceEntry {
	nodeId: GraphNodeId;
	data: ArrayBuffer;
}
declare interface PrivateSceneResourceEntry {
	nodeId: GraphNodeId;
	data: Scene;
}
declare interface PrivateScenesResourceEntry {
	nodeId: GraphNodeId;
	data: (Scene)[];
}
declare interface PrivateNodeTextResourceEntry {
	nodeId: GraphNodeId;
	brief: string;
	details: string;
	toolTip: string;
}
declare interface PrivateArticleTextResourceEntry {
	nodeId: GraphNodeId;
	details: string;
}
declare interface PrivateArticleSignatureNodeResourceEntry {
	nodeId: GraphNodeId;
	material: string;
	mass?: number;
	sheetThickness?: number;
}
declare interface PrivateSourceMultEntry {
	sourceArticleNodeId: GraphNodeId;
	targetArticleNodeId: GraphNodeId;
	multiplicity: number;
}
declare interface PrivateArticleCalcDataResourceEntry {
	nodeId: GraphNodeId;
	approxSemimanufacturedShare?: number;
	manufacturingPriceExclSurcharges?: number;
	manufacturingPriceInclSurcharges?: number;
	recursiveManufacturingPriceExclSurcharges?: number;
	recursiveManufacturingPriceInclSurcharges?: number;
	sellingPrice?: number;
	recursiveSellingPrice?: number;
}
declare interface PrivateNodeCalcDataResourceEntry {
	nodeId: GraphNodeId;
	materialCosts?: number;
	setupTime?: number;
	unitTime?: number;
	manufacturingPriceExclSurcharges?: number;
	manufacturingPriceInclSurcharges?: number;
	sellingPrice?: number;
}
declare interface PrivateProblematicGeometryResourceEntry {
	nodeId: GraphNodeId;
	hasProblematicGeometries: boolean;
}
declare interface PrivateForceSheetMetalPartResourceEntry {
	nodeId: GraphNodeId;
	canForceFuture: BooleanFuture;
}
declare interface PrivateResources {
	pngs: (PrivateBinaryResourceEntry)[];
	inputAssemblies: (PrivateAssemblyResourceEntry)[];
	outputAssemblies: (PrivateAssemblyResourceEntry)[];
	defaultScenes: (PrivateSceneResourceEntry)[];
	bendZoneScenes: (PrivateSceneResourceEntry)[];
	lowerDieAffectZoneScenes: (PrivateSceneResourceEntry)[];
	technicalDrawingScenes: (PrivateScenesResourceEntry)[];
	tubeOutlineScenes: (PrivateSceneResourceEntry)[];
	manufacturingStates: (PrivateManufacturingStateResourceEntry)[];
	nodeTexts: (PrivateNodeTextResourceEntry)[];
	articleTexts: (PrivateArticleTextResourceEntry)[];
	articleCalcData: (PrivateArticleCalcDataResourceEntry)[];
	articleSignatureNodeData: (PrivateArticleSignatureNodeResourceEntry)[];
	nodeCalcData: (PrivateNodeCalcDataResourceEntry)[];
	nodeProblematicGeometryData: (PrivateProblematicGeometryResourceEntry)[];
	nodeForceSheetMetalPartData: (PrivateForceSheetMetalPartResourceEntry)[];
}
declare interface PrivateGraphData {
	projectName: string;
}
declare interface PrivateGuiDataGraphRep {
	nodes: (PrivateNodeRepresentation)[];
	articles: (PrivateArticleRepresentation)[];
	resources: PrivateResources;
	data: PrivateGraphData;
	sourceMults: (PrivateSourceMultEntry)[];
}
declare interface PrivateGuiData {
	type: PrivateGuiDataType;
	content: PrivateGuiDataGraphRep;
}
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 PrivateTubeTablesEditorInitData {
	tubeMaterials: (TubeMaterial)[];
	tubeMaterialDensities: (TubeMaterialDensity)[];
	tubeProfiles: (TubeProfile)[];
	tubeSpecifications: (TubeSpecification)[];
	tubes: (Tube)[];
}
declare interface Nest3Part {
	assembly: Assembly;
	multiplicity: number;
	mass: number;
	prismBodyShadow?: PolygonFuture;
	prismBodyCamera?: Camera3;
}
declare interface Nest3InputBin {
	box: Box3;
	maxWeight: number;
}
declare interface Nest3ResultBox {
	assembly: Assembly;
	weight: number;
}
declare interface BendDieAffectDistanceEntry {
	bendDescriptor: number;
	affectDistance: number;
}
declare interface LstCreationParameters {
	programName: string;
	lttIdentifier: string;
	sheetThickness: number;
	sheetMaterial: string;
	measureSheet: boolean;
	loadingSystem: TrumpfLoadingSystem;
	evaporate: LstEvaporateMode;
	measuringCorner: SheetCorner;
	sheetMetalStop: SheetCorner;
}
declare interface NestingDissection {
	nestingDescriptor: number;
	xDissection?: number;
	yDissection?: number;
}
declare interface DocXText {
	placeholder: string;
	text: string;
}
declare interface DocXImage {
	placeholder: string;
	content: ArrayBuffer;
	type: DocXImageType;
}
declare interface DocXTables {
	tables: (((DocXTableCell)[])[])[];
}
declare interface DocXTableCell {
	type: DocXTableCellType;
	content: DocXText|DocXImage|DocXTables;
}
declare interface GeometrySelectorConfigFlags {
	edge: boolean;
	face: boolean;
}
declare interface DatabasePermissions {
	read: boolean;
	write: boolean;
}
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(feature: CadFeature, part: CadPart): number;
	}
	namespace cam {namespace bend {
		function selectDieGroups(options: readonly Readonly<BendDeduction>[], upperDieGroups: readonly Readonly<UpperDieGroup>[], lowerDieGroups: readonly Readonly<LowerDieGroup>[], dieGroupPriorities: readonly Readonly<DieGroupPriority>[], query: DieSelectorQuery, innerRadius: number): (BendDieChoice)[];
		function extractBendZones(twoDimRep: TwoDimRepresentation): (InnerOuterPolygon)[];
		function computeLowerDieAffectZones(twoDimRep: TwoDimRepresentation, bendDieAffectDistances: readonly Readonly<BendDieAffectDistanceEntry>[]): (Polygon)[];
		function affectedSegments(twoDimRep: TwoDimRepresentation, bendDieAffectDistances: readonly Readonly<BendDieAffectDistanceEntry>[]): (Segment)[];
	}}
	namespace cam {namespace laser {
		function computeContourTime(polygon: Polygon, vMax: number, aMax: number): number;
		function computeSegmentsTime(segments: readonly Readonly<Segment>[], vMax: number, aMax: number): number;
		function computePointsTime(points: readonly Readonly<Point2>[], vMax: number, aMax: number): number;
	}}
	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 addNestingToScene(scene: Scene, twoDimRep: TwoDimRepresentation, nestingDissections: (NestingDissection)[], extraText: string, style: SceneStyle): Scene;
		function twoDimRepFromLayered(layered: Layered, cuttingLayers: readonly Readonly<number>[], engravingLayers: readonly Readonly<number>[], tolerance: number): TwoDimImportResult;
		function twoDimRepVolume(twoDimRep: TwoDimRepresentation): number;
		function boundingBox2(twoDimRep: TwoDimRepresentation): Box2;
		function createLst(twoDimRep: TwoDimRepresentation, parameters: LstCreationParameters): string;
	}}
	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): ArrayBuffer;
		function asyncRenderIntoPng(assembly: Assembly, camera: Camera3): ArrayBufferFuture;
		function gltf(assembly: Assembly): ArrayBuffer;
		function asyncGltf(assembly: Assembly): ArrayBufferFuture;
		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;
	}}
	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 addBendLinesToScene(scene: Scene, labels: boolean, bendLines: readonly Readonly<BendLineData>[], objectDatas: readonly Readonly<SceneObjectData>[]): 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 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 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 asyncShadow(assembly: Assembly, camera: Camera3): PolygonFuture;
		function polygonSegments(polygon: Polygon): (Segment)[];
		function transformIop(iop: InnerOuterPolygon, transformation: CoordinateSystem2): InnerOuterPolygon;
		function pathsIsomorphic(lhs: ((Segment)[])[], rhs: ((Segment)[])[], tol: number): boolean;
	}}
	namespace graph {
		function vertices(): (Vertex)[];
		function userData(): StringIndexedInterface;
		function serialize(): ArrayBuffer;
		function undirectedConnectedComponents(): ((Vertex)[])[];
		function serializeUndirectedConnectedComponent(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 currentUuid(): string;
	}
	namespace graphManipulator {
		function clear(): void;
		function add(input: readonly Readonly<Input>[]): (AddResult)[];
		function addConstAssembly(assembly: Assembly): AddResult;
		function addConstAssemblyWithProcess(assembly: Assembly, processType: ProcessType, processId: string): AddResult;
		function undo(): boolean;
		function redo(): boolean;
		function clearUndoHistory(): boolean;
		function maxHistorySize(): number;
		function setMaxHistorySize(maxSize: number): boolean;
		function changeImportMultiplicity(vertex: Vertex, multiplicity: number): boolean;
		function changeImportMultiplicities(vertexData: readonly Readonly<VertexWithMultiplicity>[]): boolean;
		function changeNodeThickness(vertex: Vertex, thickness: number): boolean;
		function changeFlipSideUsage(vertex: Vertex, flipSide: boolean): boolean;
		function changeBendCorrectionFlag(vertex: Vertex, correctBends: boolean): boolean;
		function changeNodeUserData(vertex: Vertex, userData: StringIndexedInterface): boolean;
		function changeNodesUserData(vertexData: readonly Readonly<VertexWithUserData>[]): boolean;
		function changeArticleUserData(vertexData: readonly Readonly<VertexWithUserData>[]): void;
		function changeJoining(vertex: Vertex, joining: Joining): boolean;
		function changeDieChoiceMap(vertex: Vertex, dieChoiceMap: readonly Readonly<DieChoiceMapEntry>[]): boolean;
		function changeSheetFilter(vertex: Vertex, sheetFilter: SheetFilter): boolean;
		function changeArticleAttributes(vertex: Vertex, attributes: ArticleAttributes): boolean;
		function deleteReducibleComponent(vertex: Vertex): boolean;
		function createNode(processType: ProcessType, processId: string): Vertex;
		function createImportNode(processType: ProcessType, processId: string): Vertex;
		function deleteNode(vertex: Vertex): boolean;
		function deleteNodes(vertices: readonly Readonly<Vertex>[]): boolean;
		function changeProcess(vertex: Vertex, processId: string, forceProcess: boolean): boolean;
		function changeNodesProcess(vertexData: readonly Readonly<VertexWithProcessTypeData>[]): boolean;
		function injectNode(source: Vertex, target: Vertex, vertexToInject: Vertex): boolean;
		function addArc(source: Vertex, target: Vertex): boolean;
		function deleteArc(source: Vertex, target: Vertex): boolean;
		function changeGraphUserData(userData: StringIndexedInterface): boolean;
		function setCommands(vertex: Vertex, commands: readonly Readonly<CamCommand>[]): boolean;
	}
	namespace internal {
		function emitGuiData(guiData: PrivateGuiData): void;
	}
	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;
	}}
	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 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 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 computeBendLineData(vertex: Vertex): (BendLineData)[]|undefined;
		function computeBendLineFlangeLengths(vertex: Vertex): (BendLineFlangeLength)[]|undefined;
		function bendMeasurementScenes(vertex: Vertex, fontSize: number): (MeasurementScene)[];
		function asyncBendMeasurementScenes(vertex: Vertex, fontSize: number): 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 prismBodyCamera(vertex: Vertex): Camera3|undefined;
		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)[];
	}
	namespace sharedData {
		function read(): StringIndexedInterface;
		function positionalArguments(): (string)[];
		function write(data: StringIndexedInterface): void;
		function scriptArgs(): (string)[];
	}
	namespace tables {
		function get(identifier: TableType): AnyTable;
		function getDefault(identifier: TableType): AnyTable;
		function setInternalTable(anyTable: AnyTable): void;
		function setExternalTable(anyTable: AnyTable): void;
		function removeInternalTable(type: TableType): void;
		function removeExternalTable(type: TableType): 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): ArrayBuffer|(MeasurementScene)[]|boolean|Polygon|(Nest3ResultBox)[]|TwoDimRepresentation;
	}}