fcs-core-viewer 0.49.0 → 0.52.1

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/CreationToolsParentResolver.d.ts

@@ -0,0 +1 @@
+export declare function resolveCreationToolsParentItemUID(itemName: string, isPreview: boolean, createCopy?: boolean): Promise<number>;

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/Index.d.ts

@@ -1,16 +1,55 @@
 import * as PointByXYZ from "./OpPointByXYZ";
 import * as PointOnVertex from "./OpPointOnVertex";
 import * as PointByInterpolation from "./OpPointByInterpolation";
-import * as LineByXYZ from './OpLineByXYZ';
-import * as LineByPoints from './OpLineByPoints';
+import * as PointByParameters from "./OpPointByParameters";
+import * as PointAtCOG from "./OpPointAtCOG";
+import * as PointAtCenter from "./OpPointAtCenter";
+import * as PointAtIntersection from "./OpPointAtIntersection";
+import * as CurveByXYZ from './OpCurveByXYZ';
+import * as CurveByPoints from './OpCurveByPoints';
+import * as CurveArcThreeVertices from './OpCurveArcThreeVertices';
+import * as CurveArcRadiusTwoVertices from './OpCurveArcRadiusTwoVertices';
+import * as CurveCircleThreeVertices from './OpCurveCircleThreeVertices';
+import * as CurveCircleCenterVector from './OpCurveCircleCenterVector';
+import * as CurveAtIntersection from './OpCurveAtIntersection';
 import * as FaceByEdges from './OpFaceByEdges';
+import * as FaceByRevolute from './OpFaceByRevolute';
+import * as SolidByExtrusion from './OpSolidByExtrusion';
+import * as SolidByRevolute from './OpSolidByRevolute';
+import * as SolidBySweep from './OpSolidBySweep';
+import * as SolidByLoft from './OpSolidByLoft';
+import * as SolidByBoundary from './OpSolidByBoundary';
 import * as FaceByExtension from './OpFaceByExtension';
 import * as FaceByExtrusion from "./OpFaceByExtrusion";
 import * as FaceByFilling from "./OpFaceByFilling";
 import * as FaceByOffset from "./OpFaceByOffset";
 import * as ExtractAndBuild from './OpExtractAndBuild';
+import * as PrimitivesBox from './OpPrimitivesBox';
+import * as PrimitivesRectangle from './OpPrimitivesRectangle';
+import * as PrimitivesCylinder from './OpPrimitivesCylinder';
+import * as PrimitivesCone from './OpPrimitivesCone';
+import * as PrimitivesSphere from './OpPrimitivesSphere';
+import * as PrimitivesTorus from './OpPrimitivesTorus';
+import * as PrimitivesDisc from './OpPrimitivesDisc';
 declare const CADCreationToolsOperations: {
+    PrimitivesDisc: typeof PrimitivesDisc.PrimitivesDisc;
+    TemporaryPrimitivesDisc: typeof PrimitivesDisc.TemporaryPrimitivesDisc;
+    PrimitivesTorus: typeof PrimitivesTorus.PrimitivesTorus;
+    TemporaryPrimitivesTorus: typeof PrimitivesTorus.TemporaryPrimitivesTorus;
+    PrimitivesSphere: typeof PrimitivesSphere.PrimitivesSphere;
+    TemporaryPrimitivesSphere: typeof PrimitivesSphere.TemporaryPrimitivesSphere;
+    PrimitivesCone: typeof PrimitivesCone.PrimitivesCone;
+    TemporaryPrimitivesCone: typeof PrimitivesCone.TemporaryPrimitivesCone;
+    PrimitivesCylinder: typeof PrimitivesCylinder.PrimitivesCylinder;
+    TemporaryPrimitivesCylinder: typeof PrimitivesCylinder.TemporaryPrimitivesCylinder;
+    PrimitivesRectangle: typeof PrimitivesRectangle.PrimitivesRectangle;
+    TemporaryPrimitivesRectangle: typeof PrimitivesRectangle.TemporaryPrimitivesRectangle;
+    PrimitivesBox: typeof PrimitivesBox.PrimitivesBox;
+    TemporaryPrimitivesBox: typeof PrimitivesBox.TemporaryPrimitivesBox;
     ExtractShapes: typeof ExtractAndBuild.ExtractShapes;
+    BuildWire: typeof ExtractAndBuild.BuildWire;
+    BuildShell: typeof ExtractAndBuild.BuildShell;
+    BuildSolid: typeof ExtractAndBuild.BuildSolid;
     FaceByOffset: typeof FaceByOffset.FaceByOffset;
     TemporaryFaceByOffset: typeof FaceByOffset.TemporaryFaceByOffset;
     FaceByFilling: typeof FaceByFilling.FaceByFilling;
@@ -19,12 +58,42 @@ declare const CADCreationToolsOperations: {
     TemporaryFaceByExtrusion: typeof FaceByExtrusion.TemporaryFaceByExtrusion;
     FaceByExtension: typeof FaceByExtension.FaceByExtension;
     TemporaryFaceByExtension: typeof FaceByExtension.TemporaryFaceByExtension;
+    SolidByBoundary: typeof SolidByBoundary.SolidByBoundary;
+    TemporarySolidByBoundary: typeof SolidByBoundary.TemporarySolidByBoundary;
+    SolidByLoft: typeof SolidByLoft.SolidByLoft;
+    TemporarySolidByLoft: typeof SolidByLoft.TemporarySolidByLoft;
+    SolidBySweep: typeof SolidBySweep.SolidBySweep;
+    TemporarySolidBySweep: typeof SolidBySweep.TemporarySolidBySweep;
+    SolidByRevolute: typeof SolidByRevolute.SolidByRevolute;
+    TemporarySolidByRevolute: typeof SolidByRevolute.TemporarySolidByRevolute;
+    SolidByExtrusion: typeof SolidByExtrusion.SolidByExtrusion;
+    TemporarySolidByExtrusion: typeof SolidByExtrusion.TemporarySolidByExtrusion;
+    FaceByRevolute: typeof FaceByRevolute.FaceByRevolute;
+    TemporaryFaceByRevolute: typeof FaceByRevolute.TemporaryFaceByRevolute;
     FaceByEdges: typeof FaceByEdges.FaceByEdges;
     TemporaryFaceByEdges: typeof FaceByEdges.TemporaryFaceByEdges;
-    LineByPoints: typeof LineByPoints.LineByPoints;
-    TemporaryLineByPoints: typeof LineByPoints.TemporaryLineByPoints;
-    LineByXYZ: typeof LineByXYZ.LineByXYZ;
-    TemporaryLineByXYZ: typeof LineByXYZ.TemporaryLineByXYZ;
+    CurveAtIntersection: typeof CurveAtIntersection.CurveAtIntersection;
+    TemporaryCurveAtIntersection: typeof CurveAtIntersection.TemporaryCurveAtIntersection;
+    CurveCircleCenterVector: typeof CurveCircleCenterVector.CurveCircleCenterVector;
+    TemporaryCurveCircleCenterVector: typeof CurveCircleCenterVector.TemporaryCurveCircleCenterVector;
+    CurveCircleThreeVertices: typeof CurveCircleThreeVertices.CurveCircleThreeVertices;
+    TemporaryCurveCircleThreeVertices: typeof CurveCircleThreeVertices.TemporaryCurveCircleThreeVertices;
+    CurveArcRadiusTwoVertices: typeof CurveArcRadiusTwoVertices.CurveArcRadiusTwoVertices;
+    TemporaryCurveArcRadiusTwoVertices: typeof CurveArcRadiusTwoVertices.TemporaryCurveArcRadiusTwoVertices;
+    CurveArcThreeVertices: typeof CurveArcThreeVertices.CurveArcThreeVertices;
+    TemporaryCurveArcThreeVertices: typeof CurveArcThreeVertices.TemporaryCurveArcThreeVertices;
+    CurveByPoints: typeof CurveByPoints.CurveByPoints;
+    TemporaryCurveByPoints: typeof CurveByPoints.TemporaryCurveByPoints;
+    CurveByXYZ: typeof CurveByXYZ.CurveByXYZ;
+    TemporaryCurveByXYZ: typeof CurveByXYZ.TemporaryCurveByXYZ;
+    PointAtIntersection: typeof PointAtIntersection.PointAtIntersection;
+    TemporaryPointAtIntersection: typeof PointAtIntersection.TemporaryPointAtIntersection;
+    PointAtCenter: typeof PointAtCenter.PointAtCenter;
+    TemporaryPointAtCenter: typeof PointAtCenter.TemporaryPointAtCenter;
+    PointAtCOG: typeof PointAtCOG.PointAtCOG;
+    TemporaryPointAtCOG: typeof PointAtCOG.TemporaryPointAtCOG;
+    PointByParameters: typeof PointByParameters.PointByParameters;
+    TemporaryPointByParameters: typeof PointByParameters.TemporaryPointByParameters;
     PointByInterpolation: typeof PointByInterpolation.PointByInterpolation;
     TemporaryPointByInterpolation: typeof PointByInterpolation.TemporaryPointByInterpolation;
     PointOnVertex: typeof PointOnVertex.PointOnVertex;

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpCurveArcRadiusTwoVertices.d.ts

@@ -0,0 +1,18 @@
+export declare class CurveArcRadiusTwoVertices {
+    itemName: string;
+    entityUID1: number;
+    entityUID2: number;
+    vectorUID: number;
+    radius: number;
+    flip: boolean;
+    pickShorterArc: boolean;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryCurveArcRadiusTwoVertices {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpCurveArcThreeVertices.d.ts

@@ -0,0 +1,13 @@
+export declare class CurveArcThreeVertices {
+    itemName: string;
+    shapeUIDs: number[];
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryCurveArcThreeVertices {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpCurveAtIntersection.d.ts

@@ -0,0 +1,15 @@
+export declare class CurveAtIntersection {
+    itemName: string;
+    entityUIDs1: number[];
+    entityUIDs2: number[];
+    isPreview: boolean;
+    createCopy: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryCurveAtIntersection {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/{OpLineByPoints.d.ts → OpCurveByPoints.d.ts}

@@ -1,4 +1,4 @@
-export declare class LineByPoints {
+export declare class CurveByPoints {
     iEntities: any[];
     /**
      * Get checkbox value -> create closed wire if checkbox is checked
@@ -9,7 +9,7 @@ export declare class LineByPoints {
     constructor(input: {});
     perform(): Promise<boolean>;
 }
-export declare class TemporaryLineByPoints {
+export declare class TemporaryCurveByPoints {
     private input;
     constructor(input?: {});
     preview(): Promise<void>;

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/{OpLineByXYZ.d.ts → OpCurveByXYZ.d.ts}

@@ -1,4 +1,4 @@
-export declare class LineByXYZ {
+export declare class CurveByXYZ {
     itemName: string;
     x1: number;
     y1: number;
@@ -10,7 +10,7 @@ export declare class LineByXYZ {
     constructor(input: {});
     perform(): Promise<boolean>;
 }
-export declare class TemporaryLineByXYZ {
+export declare class TemporaryCurveByXYZ {
     private input;
     constructor(input?: {});
     preview(): Promise<void>;

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpCurveCircleCenterVector.d.ts

@@ -0,0 +1,15 @@
+export declare class CurveCircleCenterVector {
+    itemName: string;
+    centerUID: number;
+    vectorUID: number;
+    radius: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryCurveCircleCenterVector {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpCurveCircleThreeVertices.d.ts

@@ -0,0 +1,13 @@
+export declare class CurveCircleThreeVertices {
+    itemName: string;
+    shapeUIDs: number[];
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryCurveCircleThreeVertices {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpExtractAndBuild.d.ts

@@ -5,5 +5,21 @@ import { ModelData } from "../../../../Viewer3D/DataStorage/ModelData/Index";
 export declare class ExtractShapes {
     _extractableShapeType: ModelData.dataTypes;
     constructor(extractableShapeType: ModelData.dataTypes);
+    perform(inputSelectionData?: {}): Promise<void>;
+}
+export declare class BuildWire {
+    private readonly edgeShapeIDs;
+    constructor(input: {});
+    perform(): Promise<void>;
+}
+export declare class BuildShell {
+    private readonly faceShapeIDs;
+    constructor(input: {});
+    perform(): Promise<void>;
+}
+export declare class BuildSolid {
+    private readonly shellShapeIDs;
+    private readonly faceShapeIDs;
+    constructor(input: {});
     perform(): Promise<void>;
 }

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpFaceByRevolute.d.ts

@@ -0,0 +1,15 @@
+export declare class FaceByRevolute {
+    itemName: string;
+    profileUID: number;
+    axisUID: number;
+    angle: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryFaceByRevolute {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPointAtCOG.d.ts

@@ -0,0 +1,14 @@
+export declare class PointAtCOG {
+    itemName: string;
+    entityUID: number;
+    isPreview: boolean;
+    createCopy: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPointAtCOG {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPointAtCenter.d.ts

@@ -0,0 +1,14 @@
+export declare class PointAtCenter {
+    itemName: string;
+    entityUID: number;
+    isPreview: boolean;
+    createCopy: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPointAtCenter {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPointAtIntersection.d.ts

@@ -0,0 +1,15 @@
+export declare class PointAtIntersection {
+    itemName: string;
+    entityUIDs1: number[];
+    entityUIDs2: number[];
+    isPreview: boolean;
+    createCopy: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPointAtIntersection {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPointByInterpolation.d.ts

@@ -8,6 +8,7 @@ export declare class PointByInterpolation {
     toolShapeUIDs: number[];
     numberOfPoints: number;
     isPreview: boolean;
+    createCopy: boolean;
     constructor(input: {});
     perform(): Promise<boolean>;
 }

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPointByParameters.d.ts

@@ -0,0 +1,18 @@
+import { ModelData } from "../../../../Viewer3D/DataStorage/ModelData/Index";
+export declare class PointByParameters {
+    itemName: string;
+    entityUID: number;
+    entityType: ModelData.dataTypes;
+    u: number;
+    v: number;
+    isPreview: boolean;
+    createCopy: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPointByParameters {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPointByXYZ.d.ts

@@ -4,6 +4,7 @@ export declare class PointByXYZ {
     y: number;
     z: number;
     isPreview: boolean;
+    createCopy: boolean;
     constructor(input: {});
     perform(): Promise<boolean>;
 }

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPointOnVertex.d.ts

@@ -6,6 +6,7 @@ export declare class PointOnVertex {
     itemName: string;
     toolShapeUIDs: number[];
     isPreview: boolean;
+    createCopy: boolean;
     constructor(input: {});
     perform(): Promise<boolean>;
 }

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPrimitivesBox.d.ts

@@ -0,0 +1,15 @@
+export declare class PrimitivesBox {
+    itemName: string;
+    dx: number;
+    dy: number;
+    dz: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPrimitivesBox {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPrimitivesCone.d.ts

@@ -0,0 +1,15 @@
+export declare class PrimitivesCone {
+    itemName: string;
+    r1: number;
+    r2: number;
+    h: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPrimitivesCone {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPrimitivesCylinder.d.ts

@@ -0,0 +1,14 @@
+export declare class PrimitivesCylinder {
+    itemName: string;
+    r: number;
+    h: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPrimitivesCylinder {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPrimitivesDisc.d.ts

@@ -0,0 +1,14 @@
+export declare class PrimitivesDisc {
+    itemName: string;
+    r: number;
+    orientation: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPrimitivesDisc {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPrimitivesRectangle.d.ts

@@ -0,0 +1,15 @@
+export declare class PrimitivesRectangle {
+    itemName: string;
+    h: number;
+    w: number;
+    orientation: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPrimitivesRectangle {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPrimitivesSphere.d.ts

@@ -0,0 +1,13 @@
+export declare class PrimitivesSphere {
+    itemName: string;
+    r: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPrimitivesSphere {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpPrimitivesTorus.d.ts

@@ -0,0 +1,14 @@
+export declare class PrimitivesTorus {
+    itemName: string;
+    rMajor: number;
+    rMinor: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryPrimitivesTorus {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpSolidByBoundary.d.ts

@@ -0,0 +1,13 @@
+export declare class SolidByBoundary {
+    itemName: string;
+    faceUIDs: number[];
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporarySolidByBoundary {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpSolidByExtrusion.d.ts

@@ -0,0 +1,16 @@
+export declare class SolidByExtrusion {
+    itemName: string;
+    profileUID: number;
+    dx: number;
+    dy: number;
+    dz: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporarySolidByExtrusion {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpSolidByLoft.d.ts

@@ -0,0 +1,13 @@
+export declare class SolidByLoft {
+    itemName: string;
+    sectionUIDs: number[];
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporarySolidByLoft {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpSolidByRevolute.d.ts

@@ -0,0 +1,15 @@
+export declare class SolidByRevolute {
+    itemName: string;
+    profileUID: number;
+    axisUID: number;
+    angle: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporarySolidByRevolute {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/CreationTools/OpSolidBySweep.d.ts

@@ -0,0 +1,14 @@
+export declare class SolidBySweep {
+    itemName: string;
+    profileUID: number;
+    pathUID: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporarySolidBySweep {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAD/Index.d.ts

@@ -12,7 +12,24 @@ declare const CAD: {
         TemporarySplitFace: typeof import("./EditingTools/OpSplitFace").TemporarySplitFace;
     };
     CADCreationToolsOperations: {
+        PrimitivesDisc: typeof import("./CreationTools/OpPrimitivesDisc").PrimitivesDisc;
+        TemporaryPrimitivesDisc: typeof import("./CreationTools/OpPrimitivesDisc").TemporaryPrimitivesDisc;
+        PrimitivesTorus: typeof import("./CreationTools/OpPrimitivesTorus").PrimitivesTorus;
+        TemporaryPrimitivesTorus: typeof import("./CreationTools/OpPrimitivesTorus").TemporaryPrimitivesTorus;
+        PrimitivesSphere: typeof import("./CreationTools/OpPrimitivesSphere").PrimitivesSphere;
+        TemporaryPrimitivesSphere: typeof import("./CreationTools/OpPrimitivesSphere").TemporaryPrimitivesSphere;
+        PrimitivesCone: typeof import("./CreationTools/OpPrimitivesCone").PrimitivesCone;
+        TemporaryPrimitivesCone: typeof import("./CreationTools/OpPrimitivesCone").TemporaryPrimitivesCone;
+        PrimitivesCylinder: typeof import("./CreationTools/OpPrimitivesCylinder").PrimitivesCylinder;
+        TemporaryPrimitivesCylinder: typeof import("./CreationTools/OpPrimitivesCylinder").TemporaryPrimitivesCylinder;
+        PrimitivesRectangle: typeof import("./CreationTools/OpPrimitivesRectangle").PrimitivesRectangle;
+        TemporaryPrimitivesRectangle: typeof import("./CreationTools/OpPrimitivesRectangle").TemporaryPrimitivesRectangle;
+        PrimitivesBox: typeof import("./CreationTools/OpPrimitivesBox").PrimitivesBox;
+        TemporaryPrimitivesBox: typeof import("./CreationTools/OpPrimitivesBox").TemporaryPrimitivesBox;
         ExtractShapes: typeof import("./CreationTools/OpExtractAndBuild").ExtractShapes;
+        BuildWire: typeof import("./CreationTools/OpExtractAndBuild").BuildWire;
+        BuildShell: typeof import("./CreationTools/OpExtractAndBuild").BuildShell;
+        BuildSolid: typeof import("./CreationTools/OpExtractAndBuild").BuildSolid;
         FaceByOffset: typeof import("./CreationTools/OpFaceByOffset").FaceByOffset;
         TemporaryFaceByOffset: typeof import("./CreationTools/OpFaceByOffset").TemporaryFaceByOffset;
         FaceByFilling: typeof import("./CreationTools/OpFaceByFilling").FaceByFilling;
@@ -21,12 +38,42 @@ declare const CAD: {
         TemporaryFaceByExtrusion: typeof import("./CreationTools/OpFaceByExtrusion").TemporaryFaceByExtrusion;
         FaceByExtension: typeof import("./CreationTools/OpFaceByExtension").FaceByExtension;
         TemporaryFaceByExtension: typeof import("./CreationTools/OpFaceByExtension").TemporaryFaceByExtension;
+        SolidByBoundary: typeof import("./CreationTools/OpSolidByBoundary").SolidByBoundary;
+        TemporarySolidByBoundary: typeof import("./CreationTools/OpSolidByBoundary").TemporarySolidByBoundary;
+        SolidByLoft: typeof import("./CreationTools/OpSolidByLoft").SolidByLoft;
+        TemporarySolidByLoft: typeof import("./CreationTools/OpSolidByLoft").TemporarySolidByLoft;
+        SolidBySweep: typeof import("./CreationTools/OpSolidBySweep").SolidBySweep;
+        TemporarySolidBySweep: typeof import("./CreationTools/OpSolidBySweep").TemporarySolidBySweep;
+        SolidByRevolute: typeof import("./CreationTools/OpSolidByRevolute").SolidByRevolute;
+        TemporarySolidByRevolute: typeof import("./CreationTools/OpSolidByRevolute").TemporarySolidByRevolute;
+        SolidByExtrusion: typeof import("./CreationTools/OpSolidByExtrusion").SolidByExtrusion;
+        TemporarySolidByExtrusion: typeof import("./CreationTools/OpSolidByExtrusion").TemporarySolidByExtrusion;
+        FaceByRevolute: typeof import("./CreationTools/OpFaceByRevolute").FaceByRevolute;
+        TemporaryFaceByRevolute: typeof import("./CreationTools/OpFaceByRevolute").TemporaryFaceByRevolute;
         FaceByEdges: typeof import("./CreationTools/OpFaceByEdges").FaceByEdges;
         TemporaryFaceByEdges: typeof import("./CreationTools/OpFaceByEdges").TemporaryFaceByEdges;
-        LineByPoints: typeof import("./CreationTools/OpLineByPoints").LineByPoints;
-        TemporaryLineByPoints: typeof import("./CreationTools/OpLineByPoints").TemporaryLineByPoints;
-        LineByXYZ: typeof import("./CreationTools/OpLineByXYZ").LineByXYZ;
-        TemporaryLineByXYZ: typeof import("./CreationTools/OpLineByXYZ").TemporaryLineByXYZ;
+        CurveAtIntersection: typeof import("./CreationTools/OpCurveAtIntersection").CurveAtIntersection;
+        TemporaryCurveAtIntersection: typeof import("./CreationTools/OpCurveAtIntersection").TemporaryCurveAtIntersection;
+        CurveCircleCenterVector: typeof import("./CreationTools/OpCurveCircleCenterVector").CurveCircleCenterVector;
+        TemporaryCurveCircleCenterVector: typeof import("./CreationTools/OpCurveCircleCenterVector").TemporaryCurveCircleCenterVector;
+        CurveCircleThreeVertices: typeof import("./CreationTools/OpCurveCircleThreeVertices").CurveCircleThreeVertices;
+        TemporaryCurveCircleThreeVertices: typeof import("./CreationTools/OpCurveCircleThreeVertices").TemporaryCurveCircleThreeVertices;
+        CurveArcRadiusTwoVertices: typeof import("./CreationTools/OpCurveArcRadiusTwoVertices").CurveArcRadiusTwoVertices;
+        TemporaryCurveArcRadiusTwoVertices: typeof import("./CreationTools/OpCurveArcRadiusTwoVertices").TemporaryCurveArcRadiusTwoVertices;
+        CurveArcThreeVertices: typeof import("./CreationTools/OpCurveArcThreeVertices").CurveArcThreeVertices;
+        TemporaryCurveArcThreeVertices: typeof import("./CreationTools/OpCurveArcThreeVertices").TemporaryCurveArcThreeVertices;
+        CurveByPoints: typeof import("./CreationTools/OpCurveByPoints").CurveByPoints;
+        TemporaryCurveByPoints: typeof import("./CreationTools/OpCurveByPoints").TemporaryCurveByPoints;
+        CurveByXYZ: typeof import("./CreationTools/OpCurveByXYZ").CurveByXYZ;
+        TemporaryCurveByXYZ: typeof import("./CreationTools/OpCurveByXYZ").TemporaryCurveByXYZ;
+        PointAtIntersection: typeof import("./CreationTools/OpPointAtIntersection").PointAtIntersection;
+        TemporaryPointAtIntersection: typeof import("./CreationTools/OpPointAtIntersection").TemporaryPointAtIntersection;
+        PointAtCenter: typeof import("./CreationTools/OpPointAtCenter").PointAtCenter;
+        TemporaryPointAtCenter: typeof import("./CreationTools/OpPointAtCenter").TemporaryPointAtCenter;
+        PointAtCOG: typeof import("./CreationTools/OpPointAtCOG").PointAtCOG;
+        TemporaryPointAtCOG: typeof import("./CreationTools/OpPointAtCOG").TemporaryPointAtCOG;
+        PointByParameters: typeof import("./CreationTools/OpPointByParameters").PointByParameters;
+        TemporaryPointByParameters: typeof import("./CreationTools/OpPointByParameters").TemporaryPointByParameters;
         PointByInterpolation: typeof import("./CreationTools/OpPointByInterpolation").PointByInterpolation;
         TemporaryPointByInterpolation: typeof import("./CreationTools/OpPointByInterpolation").TemporaryPointByInterpolation;
         PointOnVertex: typeof import("./CreationTools/OpPointOnVertex").PointOnVertex;

package/fcs-core-editor@types/Editor3D/Operations/CAD/InspectionTools/OpMeasureDistance.d.ts

@@ -4,6 +4,7 @@ export declare class MeasureDistance {
     entity2Type: ModelData.dataTypes;
     entity1ID: number;
     entity2ID: number;
-    constructor(data: {});
+    constructDistanceLine: boolean;
+    constructor(input: {});
     perform(): Promise<boolean>;
 }