fcs-core-viewer 0.33.0 → 0.35.0

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

@@ -1,5 +1,5 @@
-import * as MeasureDistance from "./MeasureDistance";
-import * as PointCoordinates from "./PointCoordinates";
+import * as MeasureDistance from "./OpMeasureDistance";
+import * as PointCoordinates from "./OpPointCoordinates";
 declare const CADAnalysisToolsOperations: {
     PointCoordinates: typeof PointCoordinates.PointCoordinates;
     MeasureDistance: typeof MeasureDistance.MeasureDistance;

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

@@ -1,5 +1,6 @@
-import * as CreateVectorByPoints from "./CreateVectorByPoints";
+import * as VectorByPoints from "./OpVectorByPoints";
 declare const CADAuxiliaryToolsOperations: {
-    CreateVectorByPoints: typeof CreateVectorByPoints.CreateVectorByPoints;
+    VectorByPoints: typeof VectorByPoints.VectorByPoints;
+    TemporaryVectorByPoints: typeof VectorByPoints.TemporaryVectorByPoints;
 };
 export { CADAuxiliaryToolsOperations };

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

@@ -0,0 +1,15 @@
+export declare class VectorByPoints {
+    itemName: string;
+    private entityUID1;
+    private entityUID2;
+    isPreview: boolean;
+    private iEntities;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryVectorByPoints {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -1,21 +1,29 @@
-import * as CreateVertexByXYZ from "./CreateVertexByXYZ";
-import * as CreateEdgeByXYZ from './CreateEdgeByXYZ';
-import * as CreateEdgeByPoints from './CreateEdgeByPoints';
-import * as CreateFaceByEdges from './CreateFaceByEdges';
-import * as CreateFaceByExtension from './CreateFaceByExtension';
-import * as CreateFaceByExtrusion from "./CreateFaceByExtrusion";
-import * as CreateFaceByFilling from "./CreateFaceByFilling";
-import * as CreateFaceByOffset from "./CreateFaceByOffset";
-import * as ExtractAndBuild from './ExtractAndBuild';
+import * as VertexByXYZ from "./OpVertexByXYZ";
+import * as EdgeByXYZ from './OpEdgeByXYZ';
+import * as EdgeByPoints from './OpEdgeByPoints';
+import * as FaceByEdges from './OpFaceByEdges';
+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';
 declare const CADCreationToolsOperations: {
     ExtractShapes: typeof ExtractAndBuild.ExtractShapes;
-    CreateFaceByOffset: typeof CreateFaceByOffset.CreateFaceByOffset;
-    CreateFaceByFilling: typeof CreateFaceByFilling.CreateFaceByFilling;
-    CreateFaceByExtrusion: typeof CreateFaceByExtrusion.CreateFaceByExtrusion;
-    CreateFaceByExtension: typeof CreateFaceByExtension.CreateFaceByExtension;
-    CreateFaceByEdges: typeof CreateFaceByEdges.CreateFaceByEdges;
-    CreateEdgeBypoints: typeof CreateEdgeByPoints.CreateEdgeBypoints;
-    CreateEdgeByXYZ: typeof CreateEdgeByXYZ.CreateEdgeByXYZ;
-    CreateVertexByXYZ: typeof CreateVertexByXYZ.CreateVertexByXYZ;
+    FaceByOffset: typeof FaceByOffset.FaceByOffset;
+    TemporaryFaceByOffset: typeof FaceByOffset.TemporaryFaceByOffset;
+    FaceByFilling: typeof FaceByFilling.FaceByFilling;
+    TemporaryFaceByFilling: typeof FaceByFilling.TemporaryFaceByFilling;
+    FaceByExtrusion: typeof FaceByExtrusion.FaceByExtrusion;
+    TemporaryFaceByExtrusion: typeof FaceByExtrusion.TemporaryFaceByExtrusion;
+    FaceByExtension: typeof FaceByExtension.FaceByExtension;
+    TemporaryFaceByExtension: typeof FaceByExtension.TemporaryFaceByExtension;
+    FaceByEdges: typeof FaceByEdges.FaceByEdges;
+    TemporaryFaceByEdges: typeof FaceByEdges.TemporaryFaceByEdges;
+    EdgeByPoints: typeof EdgeByPoints.EdgeByPoints;
+    TemporaryEdgeByPoints: typeof EdgeByPoints.TemporaryEdgeByPoints;
+    EdgeByXYZ: typeof EdgeByXYZ.EdgeByXYZ;
+    TemporaryEdgeByXYZ: typeof EdgeByXYZ.TemporaryEdgeByXYZ;
+    VertexByXYZ: typeof VertexByXYZ.VertexByXYZ;
+    TemporaryVertexByXYZ: typeof VertexByXYZ.TemporaryVertexByXYZ;
 };
 export { CADCreationToolsOperations };

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

@@ -0,0 +1,17 @@
+export declare class EdgeByPoints {
+    iEntities: any[];
+    /**
+     * Get checkbox value -> create closed wire if checkbox is checked
+     */
+    itemName: string;
+    isClosed: boolean;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryEdgeByPoints {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+export declare class EdgeByXYZ {
+    itemName: string;
+    x1: number;
+    y1: number;
+    z1: number;
+    x2: number;
+    y2: number;
+    z2: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryEdgeByXYZ {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

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

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

@@ -0,0 +1,19 @@
+export declare class FaceByExtension {
+    itemName: string;
+    iEntities: any[];
+    uLength: number;
+    vLength: number;
+    isPreview: boolean;
+    /**
+     * Get checkbox value -> create closed wire if checkbox is checked
+     */
+    length: number;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryFaceByExtension {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -1,5 +1,5 @@
 import { ModelData } from "../../../../Viewer3D/DataStorage/ModelData/Index";
-export declare class CreateFaceByExtrusion {
+export declare class FaceByExtrusion {
     id: number;
     Modes: {
         VectorAndLength: number;
@@ -7,6 +7,7 @@ export declare class CreateFaceByExtrusion {
         DxDyDz: number;
         UpToSurface: number;
     };
+    itemName: string;
     shapeUIDs: number[];
     dx: number;
     dy: number;
@@ -14,6 +15,13 @@ export declare class CreateFaceByExtrusion {
     faceUIDs: number[];
     iVector: InstanceType<typeof ModelData.Shapes.Vector>;
     length: number;
-    constructor(data: {});
+    isPreview: boolean;
+    constructor(input: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryFaceByExtrusion {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+export declare class FaceByFilling {
+    itemName: string;
+    shapeUIDs: number[];
+    method: number;
+    minDegree: number;
+    maxDegree: number;
+    numOfIterations: number;
+    tolerance2D: number;
+    tolerance3D: number;
+    isApprox: boolean;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryFaceByFilling {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -0,0 +1,19 @@
+export declare class FaceByOffset {
+    iEntities: any[];
+    /**
+     * Get checkbox value -> create closed wire if checkbox is checked
+     */
+    itemName: string;
+    offsetValue: number;
+    smoothTransition: boolean;
+    copy: boolean;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryFaceByOffset {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+export declare class VertexByXYZ {
+    itemName: string;
+    x: number;
+    y: number;
+    z: number;
+    isPreview: boolean;
+    constructor(input: {});
+    perform(): Promise<boolean>;
+}
+export declare class TemporaryVertexByXYZ {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -1,5 +1,6 @@
-import * as SplitFace from './SplitFace';
+import * as SplitFace from './OpSplitFace';
 declare const Request_CAD_EditingTools: {
     SplitFace: typeof SplitFace.SplitFace;
+    TemporarySplitFace: typeof SplitFace.TemporarySplitFace;
 };
 export { Request_CAD_EditingTools };

package/fcs-core-editor@types/Editor3D/Operations/CAD/EditingTools/{SplitFace.d.ts → OpSplitFace.d.ts}

@@ -1,6 +1,7 @@
 import { ModelData } from '../../../../Viewer3D/DataStorage/ModelData/Index';
 export declare class SplitFace {
     id: number;
+    itemName: string;
     Modes: {
         Face: number;
         LineAndVector: number;
@@ -16,7 +17,14 @@ export declare class SplitFace {
     dx: number;
     dy: number;
     dz: number;
+    isPreview: boolean;
     iVector: InstanceType<typeof ModelData.Shapes.Vector>;
-    constructor(data: {});
+    constructor(input: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporarySplitFace {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -1,29 +1,41 @@
 declare const CAD: {
     CADTransformationTools: {
-        ProjectOnFace: typeof import("./TransformationTools/ProjectOnFace").ProjectOnFace;
-        ProjectOnLine: typeof import("./TransformationTools/ProjectOnLine").ProjectOnLine;
-        TranslateByDXDYDZ: typeof import("./TransformationTools/Translate").TranslateByDXDYDZ;
+        ProjectOnFace: typeof import("./TransformationTools/OpProjectOnFace").ProjectOnFace;
+        TemporaryProjectOnFace: typeof import("./TransformationTools/OpProjectOnFace").TemporaryProjectOnFace;
+        ProjectOnLine: typeof import("./TransformationTools/OpProjectOnLine").ProjectOnLine;
+        TemporaryProjectOnLine: typeof import("./TransformationTools/OpProjectOnLine").TemporaryProjectOnLine;
+        TranslateByDXDYDZ: typeof import("./TransformationTools/OpTranslate").TranslateByDXDYDZ;
     };
     Request_CAD_EditingTools: {
-        SplitFace: typeof import("./EditingTools/SplitFace").SplitFace;
+        SplitFace: typeof import("./EditingTools/OpSplitFace").SplitFace;
+        TemporarySplitFace: typeof import("./EditingTools/OpSplitFace").TemporarySplitFace;
     };
     CADCreationToolsOperations: {
-        ExtractShapes: typeof import("./CreationTools/ExtractAndBuild").ExtractShapes;
-        CreateFaceByOffset: typeof import("./CreationTools/CreateFaceByOffset").CreateFaceByOffset;
-        CreateFaceByFilling: typeof import("./CreationTools/CreateFaceByFilling").CreateFaceByFilling;
-        CreateFaceByExtrusion: typeof import("./CreationTools/CreateFaceByExtrusion").CreateFaceByExtrusion;
-        CreateFaceByExtension: typeof import("./CreationTools/CreateFaceByExtension").CreateFaceByExtension;
-        CreateFaceByEdges: typeof import("./CreationTools/CreateFaceByEdges").CreateFaceByEdges;
-        CreateEdgeBypoints: typeof import("./CreationTools/CreateEdgeByPoints").CreateEdgeBypoints;
-        CreateEdgeByXYZ: typeof import("./CreationTools/CreateEdgeByXYZ").CreateEdgeByXYZ;
-        CreateVertexByXYZ: typeof import("./CreationTools/CreateVertexByXYZ").CreateVertexByXYZ;
+        ExtractShapes: typeof import("./CreationTools/OpExtractAndBuild").ExtractShapes;
+        FaceByOffset: typeof import("./CreationTools/OpFaceByOffset").FaceByOffset;
+        TemporaryFaceByOffset: typeof import("./CreationTools/OpFaceByOffset").TemporaryFaceByOffset;
+        FaceByFilling: typeof import("./CreationTools/OpFaceByFilling").FaceByFilling;
+        TemporaryFaceByFilling: typeof import("./CreationTools/OpFaceByFilling").TemporaryFaceByFilling;
+        FaceByExtrusion: typeof import("./CreationTools/OpFaceByExtrusion").FaceByExtrusion;
+        TemporaryFaceByExtrusion: typeof import("./CreationTools/OpFaceByExtrusion").TemporaryFaceByExtrusion;
+        FaceByExtension: typeof import("./CreationTools/OpFaceByExtension").FaceByExtension;
+        TemporaryFaceByExtension: typeof import("./CreationTools/OpFaceByExtension").TemporaryFaceByExtension;
+        FaceByEdges: typeof import("./CreationTools/OpFaceByEdges").FaceByEdges;
+        TemporaryFaceByEdges: typeof import("./CreationTools/OpFaceByEdges").TemporaryFaceByEdges;
+        EdgeByPoints: typeof import("./CreationTools/OpEdgeByPoints").EdgeByPoints;
+        TemporaryEdgeByPoints: typeof import("./CreationTools/OpEdgeByPoints").TemporaryEdgeByPoints;
+        EdgeByXYZ: typeof import("./CreationTools/OpEdgeByXYZ").EdgeByXYZ;
+        TemporaryEdgeByXYZ: typeof import("./CreationTools/OpEdgeByXYZ").TemporaryEdgeByXYZ;
+        VertexByXYZ: typeof import("./CreationTools/OpVertexByXYZ").VertexByXYZ;
+        TemporaryVertexByXYZ: typeof import("./CreationTools/OpVertexByXYZ").TemporaryVertexByXYZ;
     };
     CADAuxiliaryToolsOperations: {
-        CreateVectorByPoints: typeof import("./AuxiliaryTools/CreateVectorByPoints").CreateVectorByPoints;
+        VectorByPoints: typeof import("./AuxiliaryTools/OpVectorByPoints").VectorByPoints;
+        TemporaryVectorByPoints: typeof import("./AuxiliaryTools/OpVectorByPoints").TemporaryVectorByPoints;
     };
     CADAnalysisToolsOperations: {
-        PointCoordinates: typeof import("./AnalysisTools/PointCoordinates").PointCoordinates;
-        MeasureDistance: typeof import("./AnalysisTools/MeasureDistance").MeasureDistance;
+        PointCoordinates: typeof import("./AnalysisTools/OpPointCoordinates").PointCoordinates;
+        MeasureDistance: typeof import("./AnalysisTools/OpMeasureDistance").MeasureDistance;
     };
 };
 export { CAD };

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

@@ -1,9 +1,11 @@
-import * as Translate from "./Translate";
-import * as ProjectOnLine from "./ProjectOnLine";
-import * as ProjectOnFace from "./ProjectOnFace";
+import * as Translate from "./OpTranslate";
+import * as ProjectOnLine from "./OpProjectOnLine";
+import * as ProjectOnFace from "./OpProjectOnFace";
 declare const CADTransformationTools: {
     ProjectOnFace: typeof ProjectOnFace.ProjectOnFace;
+    TemporaryProjectOnFace: typeof ProjectOnFace.TemporaryProjectOnFace;
     ProjectOnLine: typeof ProjectOnLine.ProjectOnLine;
+    TemporaryProjectOnLine: typeof ProjectOnLine.TemporaryProjectOnLine;
     TranslateByDXDYDZ: typeof Translate.TranslateByDXDYDZ;
 };
 export { CADTransformationTools };

package/fcs-core-editor@types/Editor3D/Operations/CAD/TransformationTools/{ProjectOnFace.d.ts → OpProjectOnFace.d.ts}

@@ -1,6 +1,7 @@
 import { ModelData } from '../../../../Viewer3D/DataStorage/ModelData/Index';
 export declare class ProjectOnFace {
     id: number;
+    itemName: string;
     Modes: {
         FaceAndVector: number;
         FaceAndDxDyDz: number;
@@ -12,7 +13,14 @@ export declare class ProjectOnFace {
     dx: number;
     dy: number;
     dz: number;
+    isPreview: boolean;
     iVector: InstanceType<typeof ModelData.Shapes.Vector>;
-    constructor(data: {});
+    constructor(input: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryProjectOnFace {
+    private input;
+    constructor(input?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

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

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_0D_1D/{CreateDistributingCoupling.d.ts → DistributingCoupling.d.ts}

@@ -1,5 +1,5 @@
 import { ElementData } from "../../../../Viewer3D/DataStorage/ModelData/Elements/ElementTypes/ElementTypes";
-export declare class CreateDistributingCoupling {
+export declare class DistributingCoupling {
     id: number;
     Modes: {
         CalcMasterNode: number;
@@ -10,6 +10,13 @@ export declare class CreateDistributingCoupling {
     weight: number;
     solverProfile: ElementData.Solvers;
     elementType: ElementData.ElementTypes;
+    isPreview: boolean;
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryDistributingCoupling {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -1,9 +1,12 @@
-import * as CreateNode from "./CreateNode";
-import * as CreateKinematicCoupling from "./CreateKinematicCoupling";
-import * as CreateDistributingCoupling from "./CreateDistributingCoupling";
+import * as Node from "./Node";
+import * as KinematicCoupling from "./KinematicCoupling";
+import * as DistributingCoupling from "./DistributingCoupling";
 declare const CAECreationTools_0D_1D_Operations: {
-    CreateDistributingCoupling: typeof CreateDistributingCoupling.CreateDistributingCoupling;
-    CreateKinematicCoupling: typeof CreateKinematicCoupling.CreateKinematicCoupling;
-    CreateNode: typeof CreateNode.CreateNode;
+    DistributingCoupling: typeof DistributingCoupling.DistributingCoupling;
+    TemporaryDistributingCoupling: typeof DistributingCoupling.TemporaryDistributingCoupling;
+    KinematicCoupling: typeof KinematicCoupling.KinematicCoupling;
+    TemporaryKinematicCoupling: typeof KinematicCoupling.TemporaryKinematicCoupling;
+    Node: typeof Node.Node;
+    TemporaryNode: typeof Node.TemporaryNode;
 };
 export { CAECreationTools_0D_1D_Operations };

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_0D_1D/{CreateKinematicCoupling.d.ts → KinematicCoupling.d.ts}

@@ -1,5 +1,5 @@
 import { ElementData } from "../../../../Viewer3D/DataStorage/ModelData/Elements/ElementTypes/ElementTypes";
-export declare class CreateKinematicCoupling {
+export declare class KinematicCoupling {
     id: number;
     Modes: {
         CalcMasterNode: number;
@@ -15,6 +15,13 @@ export declare class CreateKinematicCoupling {
     dof6: boolean;
     solverProfile: ElementData.Solvers;
     elementType: ElementData.ElementTypes;
+    isPreview: boolean;
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryKinematicCoupling {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_0D_1D/{CreateNode.d.ts → Node.d.ts}

@@ -1,4 +1,4 @@
-export declare class CreateNode {
+export declare class Node {
     id: number;
     Modes: {
         XYZ: number;
@@ -15,6 +15,13 @@ export declare class CreateNode {
     shape2UIDs: number[];
     shape3UIDs: number[];
     elementType: any;
+    isPreview: boolean;
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryNode {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_2D/CreateElement.d.ts

@@ -1,10 +1,11 @@
 import { ModelData } from "../../../../Viewer3D/DataStorage/ModelData/Index";
 import { ElementData } from "../../../../Viewer3D/DataStorage/ModelData/Elements/ElementTypes/ElementTypes";
-export declare class CreateElementByNodes {
+export declare class Element2DByNodes {
     iShapes: any[];
     elementShape: ModelData.elementTopologies;
     elementType: ElementData.ElementTypes;
     elementOrder: typeof ModelData.gmshData.settings.elementOrder;
+    isPreview: boolean;
     checkQuality2D: boolean;
     qualityMeasure: number;
     comparisonCondition: number;
@@ -12,3 +13,9 @@ export declare class CreateElementByNodes {
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryElement2DByNodes {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_2D/Extrude2D.d.ts

@@ -2,6 +2,7 @@ export declare class Extrude2DByNodes {
     elementUIDs: number[];
     nodeUIDs: number[];
     elementCount: number;
+    isPreview: boolean;
     checkQuality2D: boolean;
     qualityMeasure: number;
     comparisonCondition: number;
@@ -9,3 +10,9 @@ export declare class Extrude2DByNodes {
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryExtrude2DByNodes {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -1,14 +1,18 @@
 import * as ManualElementCreation from "./CreateElement";
 import * as Extrude2D from "./Extrude2D";
 import * as MeshFace from "./MeshFace";
-import * as Remesh2D from "./Remesh2D";
-import * as CreatePatch from "./CreatePatch";
+import * as Remesh from "./Remesh";
+import * as MeshPatch from "./MeshPatch";
 declare const CAECreationTools2DOperations: {
-    CreatePatch: typeof CreatePatch.CreatePatch;
-    Remesh2D: typeof Remesh2D.Remesh2D;
+    MeshPatch: typeof MeshPatch.MeshPatch;
+    TemporaryMeshPatch: typeof MeshPatch.TemporaryMeshPatch;
+    Remesh: typeof Remesh.Remesh;
+    TemporaryRemesh: typeof Remesh.TemporaryRemesh;
     MeshFace: typeof MeshFace.MeshFace;
     TemporaryMeshFace: typeof MeshFace.TemporaryMeshFace;
     Extrude2DByNodes: typeof Extrude2D.Extrude2DByNodes;
-    CreateElementByNodes: typeof ManualElementCreation.CreateElementByNodes;
+    TemporaryExtrude2DByNodes: typeof Extrude2D.TemporaryExtrude2DByNodes;
+    Element2DByNodes: typeof ManualElementCreation.Element2DByNodes;
+    TemporaryElement2DByNodes: typeof ManualElementCreation.TemporaryElement2DByNodes;
 };
 export { CAECreationTools2DOperations };

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_2D/MeshFace.d.ts

@@ -22,12 +22,11 @@ export declare class MeshFace {
     recombineNodePositioning: number;
     recombineOptimizeTopology: number;
     element2DMaterial: THREE.ShaderMaterial;
-    private response;
     constructor(data?: {});
     perform(): Promise<void>;
 }
 export declare class TemporaryMeshFace {
-    data: {};
+    private data;
     constructor(data?: {});
     preview(): Promise<void>;
     reject(): Promise<void>;

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_2D/{CreatePatch.d.ts → MeshPatch.d.ts}

@@ -1,9 +1,10 @@
-export declare class CreatePatch {
+export declare class MeshPatch {
     data: {};
     faceUIDs: number[];
     elementSize: number;
     elementOrder: number;
     meshType: {};
+    isPreview: boolean;
     checkQuality2D: boolean;
     qualityMeasure: number;
     comparisonCondition: number;
@@ -14,8 +15,13 @@ export declare class CreatePatch {
     recombineMinimumQuality: number;
     recombineNodePositioning: number;
     recombineOptimizeTopology: number;
-    private static _placedMeshOrder;
     iEntities: any[];
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryMeshPatch {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_2D/{Remesh2D.d.ts → Remesh.d.ts}

@@ -1,9 +1,10 @@
-export declare class Remesh2D {
+export declare class Remesh {
     data: {};
     faceUIDs: number[];
     elementSize: number;
     elementOrder: number;
     meshType: {};
+    isPreview: boolean;
     checkQuality2D: boolean;
     qualityMeasure: number;
     comparisonCondition: number;
@@ -17,3 +18,9 @@ export declare class Remesh2D {
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryRemesh {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -1,5 +1,6 @@
-import * as Generate3DMesh from "./VolumeMesh";
+import * as MeshVolumeFromElements from "./VolumeMesh";
 declare const CAECreationTools3DOperations: {
-    Generate3DMeshFromBoundary: typeof Generate3DMesh.Generate3DMeshFromBoundary;
+    MeshVolumeFromElements: typeof MeshVolumeFromElements.MeshVolumeFromElements;
+    TemporaryMeshVolumeFromElements: typeof MeshVolumeFromElements.TemporaryMeshVolumeFromElements;
 };
 export { CAECreationTools3DOperations };

package/fcs-core-editor@types/Editor3D/Operations/CAE/CreationTools_3D/VolumeMesh.d.ts

@@ -1,8 +1,15 @@
-export declare class Generate3DMeshFromBoundary {
+export declare class MeshVolumeFromElements {
     meshName: string;
     elementUIDs: number[];
     elementSize: number;
     elementOrder: number;
+    isPreview: boolean;
     constructor(data: {});
     perform(): Promise<boolean>;
 }
+export declare class TemporaryMeshVolumeFromElements {
+    private data;
+    constructor(data?: {});
+    preview(): Promise<void>;
+    reject(): Promise<void>;
+}

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

@@ -2,5 +2,7 @@ import * as Merge from "./Merge";
 declare const CAEEditingToolsOperations: {
     MergeByNodes: typeof Merge.MergeByNodes;
     MergeByElements: typeof Merge.MergeByElements;
+    TemporaryMergeByNodes: typeof Merge.TemporaryMergeByNodes;
+    TemporaryMergeByElements: typeof Merge.TemporaryMergeByElements;
 };
 export { CAEEditingToolsOperations };