fcs-core-viewer 0.2.0

package/fcs-core-viewer@types/FrontendEvents/SidebarEvents.d.ts

@@ -0,0 +1,23 @@
+import { SceneWrapper } from "../Model/SceneWrapper";
+export declare class SidebarEvents {
+    sceneWrapper: SceneWrapper;
+    readonly menuSections: any[];
+    readonly topbarSections_L1: any[];
+    readonly a_geom: HTMLElement;
+    readonly section_geom: HTMLElement;
+    readonly a_1D: HTMLElement;
+    readonly section_1D: HTMLElement;
+    readonly a_dev: HTMLElement;
+    readonly section_dev: HTMLElement;
+    readonly a_beam: HTMLElement;
+    readonly section_beam: HTMLElement;
+    readonly a_node: HTMLElement;
+    readonly section_node: HTMLElement;
+    readonly icon_options: HTMLElement;
+    readonly section_options: HTMLElement;
+    constructor(sceneWrapper: SceneWrapper);
+    /**
+     * Registers event listeners.
+     */
+    private _registerListeners;
+}

package/fcs-core-viewer@types/FrontendEvents/TopbarEvents.d.ts

@@ -0,0 +1,124 @@
+import { Views } from "../TaskHandler/Topbar/View/Views";
+import { Rotate } from "../TaskHandler/Topbar/View/Rotate";
+import { Screenshot } from "../TaskHandler/Topbar/View/Screenshot";
+import { GeomVisualisation } from "../TaskHandler/Topbar/View/GeomVisualisation";
+import { TaskHandler } from "../TaskHandler/TaskHandler";
+import { SceneWrapper } from "../Model/SceneWrapper";
+import { UIDefinition } from "../UserInterface/UIDefinition";
+export declare class TopbarEvents {
+    views: Views;
+    rotate: Rotate;
+    screenshot: Screenshot;
+    geomVisualisation: GeomVisualisation;
+    taskHandler: TaskHandler;
+    sceneWrapper: SceneWrapper;
+    taskName: string;
+    uiDef: UIDefinition;
+    readonly topbar: Element;
+    readonly nav_topbar: Element;
+    readonly topbarSections_L1: any[];
+    readonly topbarSections_L2: any[];
+    readonly myCanvas: HTMLElement;
+    readonly a_tree: HTMLElement;
+    readonly a_view: HTMLElement;
+    readonly section_view: HTMLElement;
+    readonly a_disp: HTMLElement;
+    readonly section_disp: HTMLElement;
+    readonly a_repr: HTMLElement;
+    readonly a_vertexRepr_typ0: HTMLElement;
+    readonly a_vertexRepr_typ1: HTMLElement;
+    readonly a_lineRepr: HTMLElement;
+    readonly a_faceRepr: HTMLElement;
+    readonly section_repr: HTMLElement;
+    readonly input_text_disp: HTMLElement;
+    readonly a_disp_entity1: HTMLElement;
+    readonly a_tools: HTMLElement;
+    readonly a_find: HTMLElement;
+    readonly a_info: HTMLElement;
+    readonly a_measure: HTMLElement;
+    readonly a_pos: HTMLElement;
+    readonly a_assy: HTMLElement;
+    readonly section_tools: HTMLElement;
+    readonly a_insp: HTMLElement;
+    readonly section_insp: HTMLElement;
+    readonly a_delete: HTMLElement;
+    readonly a_slctMe: HTMLElement;
+    readonly a_byID: HTMLElement;
+    readonly a_byClick: HTMLElement;
+    readonly a_byAll: HTMLElement;
+    readonly a_byItem: HTMLElement;
+    readonly section_methods: HTMLElement;
+    readonly a_slctMo: HTMLElement;
+    readonly a_visibleOnly: HTMLElement;
+    readonly a_throughAll: HTMLElement;
+    readonly section_modes: HTMLElement;
+    readonly a_slctEn: HTMLElement;
+    readonly a_vertex: HTMLElement;
+    readonly a_edge: HTMLElement;
+    readonly a_face: HTMLElement;
+    readonly section_entities: HTMLElement;
+    readonly a_sktch: HTMLElement;
+    readonly a_views: HTMLElement;
+    readonly a_xy_plus: HTMLElement;
+    readonly a_xy_minus: HTMLElement;
+    readonly a_xz_plus: HTMLElement;
+    readonly a_xz_minus: HTMLElement;
+    readonly a_yz_plus: HTMLElement;
+    readonly a_yz_minus: HTMLElement;
+    readonly section_views: HTMLElement;
+    readonly a_rotPlus: HTMLElement;
+    readonly a_rotMinus: HTMLElement;
+    readonly a_fit: HTMLElement;
+    readonly a_id: HTMLElement;
+    readonly a_att: HTMLElement;
+    readonly input_text_id: HTMLElement;
+    readonly a_id_entity1: HTMLElement;
+    readonly a_dist: HTMLElement;
+    readonly a_translate: HTMLElement;
+    readonly a_rotate: HTMLElement;
+    readonly a_position: HTMLElement;
+    readonly section_measure: HTMLElement;
+    readonly section_transformation: HTMLElement;
+    readonly a_merge: HTMLElement;
+    readonly a_mergeBySelection: HTMLElement;
+    readonly a_mergeByTolerance: HTMLElement;
+    readonly section_merge: HTMLElement;
+    readonly section_tree: HTMLElement;
+    readonly section_find: HTMLElement;
+    readonly a_aux: HTMLElement;
+    readonly section_aux: HTMLElement;
+    readonly a_picture: HTMLElement;
+    readonly fcs_viewer_div: any;
+    constructor(views: Views, rotate: Rotate, screenshot: Screenshot, geomVisualisation: GeomVisualisation, taskHandler: TaskHandler, sceneWrapper: SceneWrapper);
+    /**
+     *
+     */
+    private _registerListeners;
+    /**
+     * Megnyitja az 1. szintu dropdown menut. L1 ... Level 1
+     * @param section
+     * @param a
+     */
+    showDropdown_L1(section: any, a: any): void;
+    /**
+     * Megnyitja az 2. szintu dropdown menut. L2 ... Level 2 --> csak 1 szint maradjon. A tobb level-bol subtask-ot kell csinalni
+     * @param section
+     * @param a
+     */
+    showDropdown_L2(section: any, a: any): void;
+    /**
+     * Bezarja a task GUI-jat a rightPanel-en
+     * @param section
+     */
+    menuHide(section: any): void;
+    /**
+     * Hide-olja a 1. szintu dropdown menu-t
+     * @param section
+     */
+    topbarHide_L1(section: any): void;
+    /**
+     * Hide-olja a 2. szintu dropdown menu-t
+     * @param section
+     */
+    topbarHide_L2(section: any): void;
+}

package/fcs-core-viewer@types/FrontendEvents/TreeEvents.d.ts

@@ -0,0 +1,47 @@
+import { SceneWrapper } from "../Model/SceneWrapper";
+import { TreeOperations } from "../TaskHandler/Tree/Tree";
+/**
+ * To do:
+ * szetvalasztani a listener-eket a operation-tol
+ * Rename eseten a treeJSON-ben update-elni a name-et
+ * Add toggle visibility
+ * Highlight-olja a modellt, ha rakattintunk
+ */
+export declare class TreeEvents {
+    treeOps: TreeOperations;
+    sceneWrapper: SceneWrapper;
+    scene: any;
+    renderer: any;
+    currentCamera: any;
+    readonly div_treeHTML: HTMLElement;
+    readonly myCanvas: HTMLElement;
+    readonly parent: any;
+    readonly id: HTMLElement;
+    readonly mid: HTMLElement;
+    readonly pid: HTMLElement;
+    readonly a_showSelected: HTMLElement;
+    readonly a_hideSelected: HTMLElement;
+    readonly a_showOnlyItem: HTMLElement;
+    readonly a_showAll: HTMLElement;
+    readonly a_hideAll: HTMLElement;
+    readonly a_rename: HTMLElement;
+    readonly a_makeCurrent: HTMLElement;
+    readonly a_copy: HTMLElement;
+    readonly a_move: HTMLElement;
+    readonly a_treeDelete: HTMLElement;
+    readonly a_addComponent: HTMLElement;
+    readonly a_addProperty: HTMLElement;
+    readonly a_addMaterial: HTMLElement;
+    readonly a_addSet: HTMLElement;
+    readonly a_addLoad: HTMLElement;
+    readonly a_addConstraint: HTMLElement;
+    readonly a_addLoadstep: HTMLElement;
+    readonly input_rename: HTMLElement;
+    readonly tol: number;
+    readonly a_add: HTMLElement;
+    constructor(treeOperations: TreeOperations, sceneWrapper: SceneWrapper);
+    /**
+     * Registers listeners
+     */
+    private _registerListeners;
+}

package/fcs-core-viewer@types/Loader/LoadEdge.d.ts

@@ -0,0 +1,47 @@
+import { MeshWrapper } from '../Model/MeshWrapper';
+import { SceneWrapper } from '../Model/SceneWrapper';
+import { LoaderUtils, LoaderTools } from './LoaderUtils';
+import { Appearance } from '../TaskHandler/Context/Context';
+import { TreeView } from '../UserInterface/UIComponents/TreeView';
+/**
+ * Load Edge
+ */
+export declare class LoadEdge {
+    generalLineMaterial: any;
+    generalPointMaterial: any;
+    loaderTools: LoaderTools;
+    loaderUtils: LoaderUtils;
+    appearance: Appearance;
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    treeView: TreeView;
+    mesh: any;
+    line: any;
+    point: any;
+    promise: any;
+    itemUID: any;
+    meshGeometry: any;
+    scene: any;
+    currentCamera: any;
+    renderer: any;
+    uniqueToViewer: {};
+    vertexToUnique: {};
+    components: {};
+    /**
+     *
+     * @param loaderTools
+     * @param loaderUtils
+     * @param sceneWrapper
+     * @param meshWrapper
+     */
+    constructor(loaderTools: LoaderTools, loaderUtils: LoaderUtils, appearance: Appearance, sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, treeView: TreeView);
+    /**
+     * Import edgeBased item
+     * @param name
+     * @param itemUID
+     * @param parentUID
+     * @param objParsed
+     * @returns
+     */
+    importEdge(name: any, itemUID: any, parentUID: any, objParsed: any): Promise<string>;
+}

package/fcs-core-viewer@types/Loader/LoadSTEP.d.ts

@@ -0,0 +1,68 @@
+import * as THREE from '../three/build/three.module';
+import { SceneWrapper } from '../Model/SceneWrapper';
+import { MeshWrapper } from '../Model/MeshWrapper';
+import { LoaderUtils, LoaderTools } from './LoaderUtils';
+import { Appearance } from '../TaskHandler/Context/Context';
+import { TreeView } from '../UserInterface/UIComponents/TreeView';
+/**
+ * Itt tortenik a STEP model importja.
+ * Egyedi ID-t generalunk a beimportalni kivant mdoellnek
+ * Belerakjuk a Register-be (ez a treeJSON, amit a meshWrapper.js-ben keszitunk/modositunk)
+ * Belerakjuk a model tree-be is. (a tree szerkezetenek manipulalasaval kapcsolatos funkciok a tree.js-ben vannak)
+ */
+export declare class STEPLoader {
+    generalMeshMaterial: any;
+    generalLineMaterial: any;
+    generalPointMaterial: any;
+    loaderTools: LoaderTools;
+    appearance: Appearance;
+    loaderUtils: LoaderUtils;
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    treeView: TreeView;
+    mesh: any;
+    line: any;
+    point: any;
+    promise: any;
+    itemUID: any;
+    meshGeometry: any;
+    scene: any;
+    currentCamera: any;
+    renderer: any;
+    uniqueToViewer: {};
+    vertexToUnique: {};
+    components: {};
+    /**
+     *
+     * @param loaderTools
+     * @param loaderUtils
+     * @param sceneWrapper
+     * @param meshWrapper
+     */
+    constructor(loaderTools: LoaderTools, loaderUtils: LoaderUtils, appearance: Appearance, sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, treeView: TreeView);
+    loadSTL(name: string, itemUID: number, parentUID: number, objectURL: string): Promise<string>;
+    loadingFunc_STL(geometry: THREE.Mesh): Promise<string>;
+    /**
+     *
+     * @param name
+     * @param itemUID
+     * @param parentUID
+     * @param objParsed
+     * @param objectURL
+     * @returns
+     */
+    loadSTLwithJson(name: any, itemUID: any, parentUID: any, objParsed: any, objectURL: any): Promise<string>;
+    /**
+     * Import faceBased item
+     * @param meshGeometry
+     * @param name
+     * @param itemUID
+     * @param parentUID
+     * @param objParsed
+     * @returns
+     */
+    loadingFunc_STEP(meshGeometry: any, name: any, itemUID: string, parentUID: string, objParsed: {
+        tFaces: any;
+        tEdges: any;
+    }): Promise<string>;
+}

package/fcs-core-viewer@types/Loader/LoadVertex.d.ts

@@ -0,0 +1,41 @@
+import { MeshWrapper } from '../Model/MeshWrapper';
+import { SceneWrapper } from '../Model/SceneWrapper';
+import { LoaderTools, LoaderUtils } from './LoaderUtils';
+import { TreeView } from '../UserInterface/UIComponents/TreeView';
+/**
+ * Load Vertex
+ */
+export declare class LoadVertex {
+    loaderTools: LoaderTools;
+    loaderUtils: LoaderUtils;
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    treeView: TreeView;
+    scene: any;
+    mesh: any;
+    line: any;
+    point: any;
+    currentCamera: any;
+    renderer: any;
+    uniqueToViewer: {};
+    vertexToUnique: {};
+    generalPointMaterial: any;
+    components: {};
+    /**
+     *
+     * @param loaderTools
+     * @param loaderUtils
+     * @param sceneWrapper
+     * @param meshWrapper
+     */
+    constructor(loaderTools: LoaderTools, loaderUtils: LoaderUtils, sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, treeView: TreeView);
+    /**
+     * Import vertexBased item
+     * @param name
+     * @param itemUID
+     * @param parentUID
+     * @param objParsed
+     * @returns
+     */
+    importVertex(name: any, itemUID: any, parentUID: any, objParsed: any): Promise<string>;
+}

package/fcs-core-viewer@types/Loader/Loader.d.ts

@@ -0,0 +1,67 @@
+import { LoadVertex } from './LoadVertex';
+import { LoadEdge } from './LoadEdge';
+import { STEPLoader } from './LoadSTEP';
+import { BackendManager } from '../Common/CommsChannels/BackendClient';
+import { TaskUtils } from '../TaskHandler/TaskUtils';
+import { Appearance } from '../TaskHandler/Context/Context';
+import { TreeView } from '../UserInterface/UIComponents/TreeView';
+import { MeshWrapper } from '../Model/MeshWrapper';
+/**
+ * Backendbol inditott importalas eseten fogadja az emit-alt data-t es importalja a backend altal elkeszitett STL-t es JSON-t (ha OCC-vel geometriat keszitunk, az is importalas utjan kerul be a viewer-be, hiszen a GEOM_Object-bol elobb STL-t es JSON-t keszitunk, amit be tudunk importalni)
+ * Frontend-bol inditott importalas eseten importalja a modellt
+ *
+ * Mindket esetben az alabbi sorrendben hivjuk meg a fuggvenyeket: loader.js --> loadSTEP.js --> meshWrapper.js
+ *
+ * TODO: az importalashoz lokalis hardcode-olt URL-t hasznalunk. A hardcode-olt URL helyett az alabbi eljarast kellene kiprobalni:
+ * - lokalisan valasszunk ki egy tetszoleges lokalis mappabol egy file-t
+ * - Node js-ben express-szel egy endpoint-ra toltsuk fel a kivalasztott file-t
+ * - Generaljuk ki az STL-t es a JSON-t
+ * - Toltsuk fel az STL-t es JSON-t az endpointra
+ * - Az endpontrol huzzuk be az STL-t es a JSON-t
+ */
+export declare class Loader {
+    loadVertex: LoadVertex;
+    loadEdge: LoadEdge;
+    stepLoader: STEPLoader;
+    taskUtils: TaskUtils;
+    name: any;
+    stlPath: any;
+    stlPathStatic: any;
+    t2gPathStatic: any;
+    meshWrapper: MeshWrapper;
+    appearance: Appearance;
+    treeView: TreeView;
+    components: {};
+    /**
+     * Constructor.
+     * @param loadVertex
+     * @param loadEdge
+     * @param stepLoader
+     */
+    constructor(loadVertex: LoadVertex, loadEdge: LoadEdge, stepLoader: STEPLoader, taskUtils: TaskUtils, meshWrapper: MeshWrapper, appearance: Appearance, treeView: TreeView);
+    importModelFrontend(backendManager: BackendManager): void;
+    /**
+     * This method serves to save the current document locally.
+     */
+    exportSavedModelFrontend(): boolean;
+    /**
+     * Triggers a save request to model frontend!
+     */
+    saveModelFrontend(): boolean;
+    /**
+     * Guesses the file type based on its extension.
+     * @param extension The extension of the uploadable file
+     */
+    private _guessFileType;
+    importSTLBackend(name: string, itemUID: number, parentUID: number, stlPathStatic: string): Promise<void>;
+    /**
+     * Import model from console
+     * @param name
+     * @param itemUID
+     * @param parentUID
+     * @param stlPathStatic
+     * @param t2gPathStatic
+     * @returns
+     */
+    importModelBackend(name: any, itemUID: any, parentUID: any, stlPathStatic: any, t2gPathStatic: any): Promise<any>;
+}

package/fcs-core-viewer@types/Loader/LoaderUtils.d.ts

@@ -0,0 +1,234 @@
+import * as THREE from '../three/build/three.module.js';
+import { MeshWrapper } from '../Model/MeshWrapper';
+import { SceneWrapper } from '../Model/SceneWrapper';
+export declare class LoaderUtils {
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    uniqueToViewer: {};
+    components: {};
+    cntMesh: THREE.Mesh;
+    cntLine: THREE.Line;
+    cntPoint: THREE.Point;
+    generalMeshMaterial: THREE.MeshPhongMaterial;
+    generalLineMaterial: THREE.LineMaterial;
+    generalPointMaterial: THREE.ShaderMaterial;
+    /**
+     *
+     * @param sceneWrapper
+     * @param meshWrapper
+     */
+    constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper);
+    addToScene(mesh?: any, line?: any, point?: any): void;
+    /**
+     * Ide jon minden, ami mesh, de nem modell, pl. szerkeszteshez hasznalt seged geometriak (plane, (bounding) sphere, (bounding) box, cone, cylinder, ...)
+     */
+    addCntAuxMesh(): void;
+    /**
+     * Ide jon minden, ami line, de nem modell, pl. szerkeszteshez hasznalt seged geometriak (szerkesztesi seged vonal, nyil szara, annotato elyet jelolo vonal, ...)
+     */
+    addCntAuxLine(): void;
+    /**
+     * Ide jon minden, ami line, de nem modell, pl. szerkeszteshez hasznalt seged geometriak (szerkesztesi seged vonal, nyil szara, annotato elyet jelolo vonal, ...)
+     */
+    addCntAuxPoint(): void;
+    /**
+     * Kigeneralja a "cntMesh" container-t, ami a component-ek THREE.Mesh objektumait tartalmazza omlesztve
+     */
+    addCntMesh(): any;
+    /**
+     * Importalasnal hozzaadjuk a component THREE.Mesh objektumait a cntMesh container-hez
+     * @param mesh
+     */
+    addToCntMesh(mesh: THREE.Mesh): void;
+    /**
+     * Kitorli a modellt alkoto THREE.Mesh objektumot a container-bol
+     * @param mesh
+     */
+    removeFromCntMesh(mesh: THREE.Mesh): void;
+    /**
+     * Show/Hide mesh
+     * Megkeresi az adott THREE.Mesh objektumot a container-ben es modositja a hozza tartozo vertex-ek visibility attributumait
+     * @param mesh_arr
+     * @param isVisible
+     */
+    setMeshVisibility(mesh_arr: THREE.Mesh[], isVisible: boolean): void;
+    /**
+     * Kigeneralja a "cntMesh" container-t, ami a component-ek THREE.Line2 objektumait tartalmazza omlesztve
+     * @returns
+     */
+    addCntLine(): any;
+    /**
+     * Importalasnal hozzaadjuk a component THREE.Line2 objektumait a cntLine container-hez
+     * @param line
+     */
+    addToCntLine(line: THREE.Line2): void;
+    /**
+     * Kitorli a modellt alkoto THREE.Line2 objektumot a container-bol
+     * @param line
+     */
+    removeFromCntLine(line: THREE.Line2): void;
+    /**
+     * Show/Hide line
+     * Megkeresi az adott THREE.Line2 objektumot a container-ben es modositja a hozza tartozo vertex-ek visibility attributumait
+     * @param line_arr
+     * @param isVisible
+     */
+    setLineVisibility(line_arr: THREE.Line2[], isVisible: boolean): void;
+    /**
+     * Kigeneralja a "cntPoint" container-t, ami a component-ek THREE.Point objektumait tartalmazza omlesztve
+     * @returns
+     */
+    addCntPoint(): any;
+    /**
+     * Importalasnal hozzaadjuk a component THREE.Point objektumait a cntPoint container-hez
+     */
+    addToCntPoint(point: THREE.Point): void;
+    /**
+     * Kitorli a modellt alkoto THREE.Point objektumot a container-bol
+     * @param point
+     */
+    removeFromCntPoint(point: THREE.Point): void;
+    /**
+     * Show/Hide point
+     * Megkeresi az adott THREE.Point objektumot a container-ben es modositja a hozza tartozo vertex-ek visibility attributumait
+     * @param point_arr
+     * @param isVisible
+     */
+    setPointVisibility(point_arr: THREE.Point[], isVisible: boolean): void;
+}
+export declare class LoaderTools {
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    positions: any[];
+    alpha: number;
+    components: {};
+    constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper);
+    /**
+     * Itt definialunk a THREE.Mesh objektumoknak material-t
+     */
+    setMeshMaterial(): void;
+    /**
+     * Itt definialunk a THREE.Line2 objektumoknak material-t
+     */
+    setLineMaterial(): void;
+    /**
+     * Itt definialunk a THREE.Point objektumoknak material-t
+     */
+    setPointMaterial(): void;
+    /**
+     * Kigeneralja a custom shader-t, amit argumentumknet beadunk a THREE.ShaderMaterial-nak
+     * @param currentCamera
+     * @param graySphereTexture
+     * @param yellowSphereTexture
+     * @param violetSphereTexture
+     * @returns
+     */
+    createShader(currentCamera: THREE.OrthographicCamera, graySphereTexture: THREE.Texture, yellowSphereTexture: THREE.Texture, violetSphereTexture: THREE.Texture): {
+        uniforms: {
+            graySphereTexture: {
+                value: THREE.Texture;
+            };
+            yellowSphereTexture: {
+                value: THREE.Texture;
+            };
+            violetSphereTexture: {
+                value: THREE.Texture;
+            };
+            pointSize: {
+                value: number;
+            };
+            alphaTest_gray: {
+                value: number;
+            };
+            alphaTest_yellow: {
+                value: number;
+            };
+            alphaTest_violet: {
+                value: number;
+            };
+            near: {
+                value: any;
+            };
+            far: {
+                value: any;
+            };
+            pixelWidth: {
+                value: number;
+            };
+            pixelHeight: {
+                value: number;
+            };
+        };
+        vertexShader: string;
+        fragmentShader: string;
+        transparent: boolean;
+        depthTest: boolean;
+        visible: boolean;
+        depthWrite: boolean;
+        uniformsNeedUpdate: boolean;
+    };
+    /**
+     * Custom shader-t general THREE.Mesh objektumnak
+     * @returns
+     */
+    meshCustomShader(): {
+        uniforms: {};
+        vertexShader: string;
+        fragmentShader: string;
+        vertexColors: boolean;
+        visible: boolean;
+        depthTest: boolean;
+        depthWrite: boolean;
+        colorWrite: boolean;
+        alphaToCoverage: boolean;
+        transparent: boolean;
+        side: any;
+    };
+}
+export declare class Face {
+    type: string;
+    itemVID: number;
+    itemUID: string;
+    componentVID: number;
+    componentUID: number;
+    faceVID: number;
+    faceUIDs: number[];
+    polygonsXYZ: number[];
+    startIndex: number;
+    count: number;
+    edges: Edge[];
+    isVisible: number;
+    isSelected: boolean;
+    constructor(itemVID: number, itemUID: string, componentVID: number, componentUID: number, faceVID: number, faceUIDs: number[], polygonsXYZ: number[], startIndex: number, count: number);
+}
+export declare class Edge {
+    type: string;
+    itemVID: number;
+    componentVID: number;
+    edgeVID: number;
+    edgeUIDs: number[];
+    segmentsXYZ: number[];
+    startIndex: number;
+    count: number;
+    faces: Face[];
+    vertices: Vertex[];
+    lineWidth: number;
+    isVisible: number;
+    isSelected: boolean;
+    constructor(itemVID: number, componentVID: number, edgeVID: number, edgeUIDs: number[], segmentsXYZ: number[], startIndex: number, count: number, faces?: Face[]);
+}
+export declare class Vertex {
+    type: string;
+    itemVID: number;
+    componentVID: number;
+    vertexVID: number;
+    vertexUIDs: number[];
+    vertexXYZ: number[];
+    startIndex: number;
+    edges: Edge[];
+    faces: Face[];
+    textureID: number;
+    isVisible: number;
+    isSelected: boolean;
+    constructor(itemVID: number, componentVID: number, vertexVID: number, vertexUIDs: number[], vertexXYZ: number[], startIndex: number, edges?: Edge[], faces?: Face[]);
+}