architwin 1.12.5 → 1.13.1

package/lib/loaders/pathLoader.js

@@ -0,0 +1,451 @@
+import { Pane } from 'tweakpane';
+import { dispatchSpaceEvent } from "../architwin";
+import { SPACE_EVENTS } from "../types";
+export class PathLine {
+    constructor(mpSdk) {
+        this.time = 0;
+        this.closed = false;
+        this.billboard = undefined;
+        this.hovered = false;
+        this.length = 0;
+        this.inputs = {
+            name: '',
+            label: 'Path Line',
+            description: '',
+            node: null,
+            tubes: null,
+            path: null,
+            enabled: true,
+            active: false,
+            editMode: false,
+            direction: -1,
+            curveType: 'catmullrom',
+            opacity: 0.3,
+            tubularSegments: 100,
+            radialSegments: 20,
+            fillColor: 'none',
+            textColor: 'rgb(255,255,255)',
+            text: '➡︎',
+            font: '48px sans-serif',
+            radius: 0.05,
+            scrollSpeed: 1.35,
+            collider: true,
+            visible: true,
+            pathOptions: null
+        };
+        //@ts-expect-error
+        this.outputs = {
+            length: 0,
+            gui: {},
+        };
+        this.emits = {
+            active: true,
+            destroyed: true,
+        };
+        this.events = {
+            'INTERACTION.CLICK': true,
+            'INTERACTION.HOVER': false,
+        };
+        this.onInit = () => {
+            const THREE = this.context.three;
+            this.groupedMesh = new THREE.Group();
+            if (this.inputs.active) {
+                //this.renderGUI();
+            }
+            if (this.inputs.path.length > 1) {
+                this.renderPathLine();
+            }
+        };
+        this.onInputsUpdated = (prevInputs) => {
+            if (this.inputs !== prevInputs) {
+                const THREE = this.context.three;
+                this.groupedMesh = new THREE.Group();
+                if (!this.inputs.active && this.panel) {
+                    this.panel.dispose();
+                    //@ts-expect-error
+                    this.panel = false;
+                }
+                else {
+                    if (!this.panel || this.inputs.label !== prevInputs.label) {
+                        //console.log('Rendering GUI...');
+                        // this.renderGUI();
+                    }
+                }
+                if (this.inputs.pathOptions) {
+                    const excludedKeys = ['id', 'pathOptions'];
+                    for (let key in this.inputs) {
+                        if (!excludedKeys.includes(key)) {
+                            if (this.inputs.pathOptions[key]) {
+                                this.inputs[key] = this.inputs.pathOptions[key];
+                            }
+                        }
+                    }
+                }
+                if (this.inputs.path.length > 1) {
+                    this.renderPathLine();
+                    console.log("paths ", this.inputs.path);
+                }
+            }
+        };
+        this.renderPathLine = () => {
+            const THREE = this.context.three;
+            // Find Length
+            let sections = this.inputs.path.length - 1;
+            this.length = 0;
+            for (let i = 0; i < sections; i++) {
+                const start = new THREE.Vector3(this.inputs.path[i].x, this.inputs.path[i].y, this.inputs.path[i].z);
+                const end = new THREE.Vector3(this.inputs.path[i + 1].x, this.inputs.path[i + 1].y, this.inputs.path[i + 1].z);
+                this.length += start.distanceTo(end);
+            }
+            const ctx = document.createElement('canvas').getContext('2d');
+            if (!ctx) {
+                return;
+            }
+            ctx.canvas.width = 64;
+            ctx.canvas.height = 64;
+            if (this.inputs.fillColor == 'none') {
+                ctx.clearRect(0, 0, 64, 64);
+            }
+            else {
+                // background
+                let fillColorRGBA = this.inputs.fillColor.replace(/rgb/i, 'rgba');
+                fillColorRGBA = fillColorRGBA.replace(/\)/i, ',' + (this.hovered ? 0.9 : this.inputs.opacity) + ')');
+                ctx.fillStyle = fillColorRGBA;
+                ctx.fillRect(0, 0, 64, 64);
+            }
+            // render out text measurement in the rendered line
+            ctx.translate(32, 32);
+            ctx.fillStyle = this.inputs.textColor;
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'middle';
+            ctx.font = this.inputs.font;
+            ctx.fillText(this.inputs.text, 0, 0);
+            this.texture = new THREE.CanvasTexture(ctx.canvas);
+            this.texture.wrapS = THREE.RepeatWrapping;
+            this.texture.wrapT = THREE.RepeatWrapping;
+            this.texture.repeat.set(this.length, 3);
+            this.material = new THREE.MeshBasicMaterial({
+                map: this.texture,
+                side: THREE.DoubleSide,
+                depthWrite: false,
+                depthTest: true,
+                transparent: true,
+                //@ts-expect-error
+                flatShading: true,
+                emissive: 0x072534,
+            });
+            if (this.inputs.path !== null) {
+                this.tubeGeometry && this.tubeGeometry.dispose();
+                this.tubeGeometry = new THREE.TubeGeometry(new THREE.CatmullRomCurve3(this.inputs.path, false, 
+                //@ts-expect-error
+                this.inputs.curveType, this.inputs.curveType == 'catmullrom' ? 0.25 : 0), this.inputs.tubularSegments, // tubularSegments
+                this.inputs.radius, this.inputs.radialSegments, // radialSegments
+                this.closed // closed
+                );
+                this.mesh = new THREE.Mesh(this.tubeGeometry, this.material);
+            }
+            this.mesh.name = this.inputs.name;
+            this.outputs.length = this.length;
+            this.groupedMesh.add(this.mesh);
+            this.mesh.visible = this.inputs.visible;
+            if (this.inputs.enabled) {
+                this.outputs.objectRoot = this.mesh;
+                this.outputs.collider = this.inputs.collider ? this.mesh : null;
+            }
+            else {
+                this.outputs.objectRoot = null;
+                this.outputs.collider = null;
+            }
+            if (this.panel) {
+                this.panel.refresh();
+            }
+            dispatchSpaceEvent(SPACE_EVENTS.PATH_UPDATED, {
+                path: this.inputs.path,
+                textColor: this.inputs.textColor
+            });
+        };
+        this.setBillboard = (value) => {
+            this.billboard = value;
+        };
+        //This is just a temp gui I need for debugging and experimentation purposes. Will be commented out once I am done
+        this.renderGUI = () => {
+            if (this.panel) {
+                this.panel.dispose();
+            }
+            this.panel = new Pane({
+                //width: 260,
+                title: 'Scrolling Tube Creator',
+                container: document.getElementById('objgui'),
+            });
+            const tab = this.panel.addTab({
+                pages: [{ title: 'Edit' }, { title: 'All Drawings' }],
+            });
+            const folder1 = tab.pages[0].addFolder({ title: 'Inputs' });
+            folder1.addBinding(this.inputs, 'name');
+            folder1.addBinding(this.inputs, 'label');
+            folder1.addBinding(this.inputs, 'description', {
+                readonly: false,
+                multiline: true,
+                rows: 5,
+            });
+            folder1.addBinding(this.inputs, 'text', {
+                options: { ' ': ' ', '➡︎': '➡︎', '✳': '✳', '☠': '☠' },
+            });
+            folder1.addBinding(this.inputs, 'textColor');
+            folder1.addBinding(this.inputs, 'fillColor');
+            folder1.addBinding(this.inputs, 'direction', {
+                options: { 'Left to Right': -1, 'Right to Left': 1 },
+            });
+            folder1.addBinding(this.outputs, 'length', {
+                readonly: true,
+            });
+            // If the node was passed as an input, we can run node.destroy();
+            if (this.inputs.node) {
+                const remove = folder1.addButton({ title: 'Remove', label: 'Remove' });
+                remove.on('click', () => {
+                    //@ts-expect-error
+                    this.notify('destroyed');
+                    this.panel.dispose();
+                    //@ts-expect-error
+                    this.panel = false;
+                    this.inputs.active = false;
+                    this.inputs.node.stop();
+                });
+            }
+            const folder2 = tab.pages[0].addFolder({
+                title: 'Advanced',
+                expanded: true,
+            });
+            folder2.addBinding(this.inputs, 'enabled');
+            folder2.addBinding(this.inputs, 'opacity', { min: 0, max: 1, step: 0.05 });
+            folder2.addBinding(this.inputs, 'radius', {
+                min: 0.01,
+                max: 1,
+                step: 0.01,
+            });
+            folder2.addBinding(this.inputs, 'scrollSpeed', {
+                min: 0,
+                max: 5,
+                step: 0.05,
+            });
+            folder2.addBinding(this.inputs, 'tubularSegments', {
+                min: 1,
+                max: 100,
+                step: 1,
+            });
+            folder2.addBinding(this.inputs, 'radialSegments', {
+                min: 1,
+                max: 20,
+                step: 1,
+            });
+            folder2.addBinding(this.inputs, 'collider');
+            if (this.inputs.tubes !== null) {
+                const nodeIterator = this.inputs.tubes.nodeIterator();
+                let nodes = nodeIterator.next();
+                while (!nodes.done) {
+                    const componentIterator = nodes.value.componentIterator();
+                    let component = componentIterator.next();
+                    nodes = nodeIterator.next();
+                    const button = tab.pages[1].addButton({
+                        title: component.value.inputs.label,
+                        label: '=',
+                    });
+                    button.on('click', (data) => {
+                        // This needs to be reviewed
+                        if (!component.value.inputs.active) {
+                            //@ts-expect-error
+                            this.notify('active', { component: component.value });
+                        }
+                    });
+                }
+            }
+        };
+        this.mpSdk = mpSdk;
+    }
+    onEvent(eventType, data) {
+        if (eventType === 'INTERACTION.CLICK') {
+            //@ts-expect-error
+            this.notify('active', { component: this });
+            // Show a Tag Billboard with the info of this tube
+            if (!this.billboard) {
+                // Allow access to these variables within then callbacks.
+                var mpSdk = this.mpSdk;
+                mpSdk.Tag.toggleNavControls(false);
+                mpSdk.Tag.add({
+                    label: this.inputs.label,
+                    description: this.inputs.description +
+                        ' - ' +
+                        Math.round(this.length * 1000) / 1000 +
+                        'm',
+                    anchorPosition: {
+                        x: data.point.x,
+                        y: data.point.y,
+                        z: data.point.z,
+                    },
+                    stemVector: {
+                        x: 0,
+                        y: 0,
+                        z: 0,
+                    },
+                }).then((tags) => {
+                    this.setBillboard(tags[0]);
+                    mpSdk.Tag.allowAction(tags[0], {
+                        opening: true,
+                        navigating: true,
+                    });
+                    mpSdk.Tag.editOpacity(tags[0], 0);
+                    mpSdk.Tag.open(tags[0]).then(() => {
+                        let tagDestroyer = mpSdk.Tag.openTags.subscribe((newState) => {
+                            if (newState.selected.size == 0) {
+                                let thisTag = newState.selected;
+                                //@ts-expect-error
+                                if (thisTag != tags[0]) {
+                                    mpSdk.Tag.remove(tags[0]);
+                                    tagDestroyer.cancel();
+                                    this.setBillboard(false);
+                                    mpSdk.Tag.toggleNavControls(true);
+                                }
+                            }
+                        });
+                    });
+                });
+            }
+        }
+    }
+    onTick(tickDelta) {
+        if (this.inputs.scrollSpeed > 0) {
+            this.time += tickDelta;
+            if (this.texture) {
+                this.texture.offset.x =
+                    (this.inputs.direction *
+                        ((this.inputs.scrollSpeed * this.time) / 1000)) %
+                        1;
+            }
+        }
+    }
+    onDestroy() {
+        this.texture.dispose();
+        if (this.panel) {
+            this.panel.dispose();
+            //@ts-expect-error
+            this.panel = false;
+        }
+        if (this.billboard) {
+            this.mpSdk.Tag.remove(this.billboard);
+            console.log('Nav Controls On');
+            this.mpSdk.Tag.toggleNavControls(true);
+        }
+    }
+}
+export const pathLineType = 'pathLine';
+export const pathLineFactory = function (mpSdk) {
+    return function () {
+        return new PathLine(mpSdk);
+    };
+};
+export class PathPoint {
+    constructor(mpSdk) {
+        this.inputs = {
+            index: null,
+            radius: 0.05,
+            position: null,
+            fillColor: 'rgb(11,57,72)',
+            hoverColor: 'rgb(255,0,0)',
+            ringVisibility: false
+        };
+        this.emits = {
+            active: true,
+            changed: true,
+        };
+        this.events = {
+            'INTERACTION.DRAG': true,
+            'INTERACTION.DRAG_BEGIN': true,
+            'INTERACTION.DRAG_END': true,
+            'INTERACTION.HOVER': true,
+        };
+        this.onInputsUpdated = (prevInputs) => {
+            this.renderVertice(false);
+        };
+        this.onInit = () => {
+            this.renderVertice();
+        };
+        this.renderVertice = (hovered = false) => {
+            const THREE = this.context.three;
+            const group = new THREE.Group();
+            //This is just a visual marker so that the user can see the points they have already marked
+            this.geometry = new THREE.SphereGeometry(this.inputs.radius, 16, 16);
+            this.material = new THREE.MeshBasicMaterial({
+                color: (hovered ? this.inputs.hoverColor : this.inputs.fillColor),
+                transparent: true,
+                opacity: 0.6,
+            });
+            this.mesh = new THREE.Mesh(this.geometry, this.material);
+            this.mesh.position.set(this.inputs.position.x, this.inputs.position.y, this.inputs.position.z);
+            this.outputs.objectRoot = this.mesh;
+            this.outputs.collider = this.mesh;
+        };
+        this.mpSdk = mpSdk;
+    }
+    onEvent(eventType, data) {
+        var _a;
+        if (eventType === 'INTERACTION.DRAG') {
+            //this.pointerIntersection.object  === 'intersectedobject.model'
+            //this.pointerIntersection.object
+            console.log("group this.pointerIntersection ", this.pointerIntersection);
+            if (this.pointerIntersection.object === 'intersectedobject.model') {
+                let e = Object.assign({}, this.pointerIntersection.position);
+                this.mesh.position.set(e.x, e.y, e.z);
+                //this.mesh.children[0].position.set(e.x, e.y, e.z)
+                //@ts-expect-error
+                this.notify('changed', {
+                    index: this.inputs.index,
+                    position: this.mesh.position,
+                    collider: null,
+                });
+            }
+        }
+        if (eventType === 'INTERACTION.DRAG_BEGIN') {
+            this.mpSdk.Pointer.setVisible(false);
+            //@ts-expect-error
+            this.mesh.material.opacity = 0.5;
+            //this.mesh.children[0].material.opacity = 0.5
+            // will make it smaller later. Setting this to 0.5 to make it easier to see in the space
+            this.mesh.scale.set(0.5, 0.5, 0.5);
+            if (this.pointerSub == null) {
+                this.pointerSub = this.mpSdk.Pointer.intersection.subscribe((data) => {
+                    this.pointerIntersection = data;
+                });
+            }
+            //@ts-expect-error
+            this.notify('changed', {
+                index: this.inputs.index,
+                position: this.mesh.position,
+                collider: false,
+            });
+        }
+        if (eventType === 'INTERACTION.DRAG_END') {
+            //@ts-expect-error
+            this.mesh.material.opacity = 1;
+            this.mesh.scale.set(1, 1, 1);
+            this.mpSdk.Pointer.setVisible(true);
+            (_a = this.pointerSub) === null || _a === void 0 ? void 0 : _a.cancel();
+            //renderPolygonFromPath()
+            //@ts-expect-error
+            this.notify('changed', {
+                index: this.inputs.index,
+                position: this.mesh.position,
+                collider: false,
+            });
+            dispatchSpaceEvent(SPACE_EVENTS.VERTEX_DRAG_END, {
+                index: this.inputs.index,
+                position: this.mesh.position
+            });
+        }
+    }
+}
+export const pathPointType = 'pathPoint';
+export const pathPointFactory = function (mpSdk) {
+    return function () {
+        return new PathPoint(mpSdk);
+    };
+};

package/lib/minimap.d.ts

@@ -1,5 +1,5 @@
 import { MpSdk } from "../bundle/sdk";
-import { ISweep, SweepColor, DEGREE, CustomMapFloorData } from "./types";
+import { ISweep, SweepColor, DEGREE, CustomMapFloorData, CUSTOM_MAP_MODE } from "./types";
 import 'notyf/notyf.min.css';
 declare let isMinimapNavigation: boolean;
 interface FloorData {
@@ -120,4 +120,6 @@ declare function getCustomMapFloorData(index?: number): CustomMapFloorData[] | C
 declare function resetCustomMapSettingValues(): void;
 declare function setMpSDK(mpSdk: MpSdk): void;
 declare function getMpSdk(): MpSdk;
-export { isMinimapNavigation, mapPositions, setMap, showMinimap, hideMinimap, locateAvatar, resetSweepMarkerColors, renderOverlaySweep, showDirection, toggleMinimapVisibility, setSweepMarkerColor, setStandaloneMap, toggleMinimapFloor, getFloorsInSpace, createDropdown, setMinimapPosition, setCurrentMinimapPosition, setCustomMap, setupCustomMinimapPane, setCustomMinimapRotation, getCustomMinimapRotation, generateCustomMinimap, setCustomMapScale, setCustomMapTranslate, setCustomMapXOffset, setCustomMapYOffset, getCustomMapScale, getCustomMapTranslate, getCustomMapXOffset, getCustomMapYOffset, setMinAndMax, setCustomMapFloorData, getCustomMapFloorData, resetCustomMapSettingValues, getMinimapPosition, subscribeToFloorChanges, setMpSDK, getMpSdk };
+declare function setCustomMapMode(mode: CUSTOM_MAP_MODE): void;
+declare function getCustomMapMode(): CUSTOM_MAP_MODE;
+export { isMinimapNavigation, mapPositions, setMap, showMinimap, hideMinimap, locateAvatar, resetSweepMarkerColors, renderOverlaySweep, showDirection, toggleMinimapVisibility, setSweepMarkerColor, setStandaloneMap, toggleMinimapFloor, getFloorsInSpace, createDropdown, setMinimapPosition, setCurrentMinimapPosition, setCustomMap, setupCustomMinimapPane, setCustomMinimapRotation, getCustomMinimapRotation, generateCustomMinimap, setCustomMapScale, setCustomMapTranslate, setCustomMapXOffset, setCustomMapYOffset, getCustomMapScale, getCustomMapTranslate, getCustomMapXOffset, getCustomMapYOffset, setMinAndMax, setCustomMapFloorData, getCustomMapFloorData, resetCustomMapSettingValues, getMinimapPosition, subscribeToFloorChanges, setMpSDK, getMpSdk, setCustomMapMode, getCustomMapMode };

package/lib/minimap.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import * as superviz from './superviz';
 import { _mpConfig, getCurrentCameraPose, getCurrentSweep, getMapConfig, dispatchSpaceEvent, isCdnMapDataAvailable, getCurrentFloor, minimap } from "./architwin";
-import { SPACE_EVENTS, DEGREE, MAP_OPTIONS } from "./types";
+import { SPACE_EVENTS, DEGREE, MAP_OPTIONS, CUSTOM_MAP_MODE } from "./types";
 import { isValidCSSColor } from "./color";
 import { _participants } from "./participant";
 import { getAtwinSdk } from "./architwin";
@@ -46,6 +46,7 @@ let _customMapContainer;
 let _customMapFloorData = [];
 let _minimapPosition = "bottomRight";
 let _mpSdk;
+let _customMapMode = CUSTOM_MAP_MODE.DEFAULT;
 let notyf = new Notyf({ position: { x: 'left', y: 'bottom' }, duration: 4500, types: [
         {
             type: 'info',
@@ -1343,7 +1344,12 @@ function displaySweepToCustomMap(sweepItem, mpSdk) {
     const posY = sweepItem.y;
     let thisSweep = document.createElement('button');
     log.info("getCurrentSweep().id ==> ", getCurrentSweep().id);
-    const cList = getCurrentSweep().id === sweepItem.id ? 'at_custom_sweep active' : 'at_custom_sweep';
+    const isActive = getCurrentSweep().id === sweepItem.id;
+    const isDefaultMode = _customMapMode === CUSTOM_MAP_MODE.DEFAULT;
+    const cList = isActive
+        ? 'at_custom_sweep active'
+        : `at_custom_sweep ${isDefaultMode ? 'at_sweep_color_default' : 'at_sweep_color_edit'}`;
+    // const cList = getCurrentSweep().id === sweepItem.id ? 'at_custom_sweep active' : 'at_custom_sweep'
     const scaleX = _customMapScale;
     const scaleY = (_customMapScale * 21 / 9) / _customMapTranslate;
     const scaledX = scaleToContainer(posX, minX, maxX, scaleX, 0);
@@ -1618,8 +1624,15 @@ function setMpSDK(mpSdk) {
 function getMpSdk() {
     return _mpSdk;
 }
+function setCustomMapMode(mode) {
+    log.info("__@ setCustomMapMode: ", mode);
+    _customMapMode = mode;
+}
+function getCustomMapMode() {
+    return _customMapMode;
+}
 export { 
 // _miniMapData as minimapData,
 isMinimapNavigation, mapPositions, setMap, showMinimap, hideMinimap, locateAvatar, resetSweepMarkerColors, renderOverlaySweep, showDirection, toggleMinimapVisibility, setSweepMarkerColor, setStandaloneMap, toggleMinimapFloor, getFloorsInSpace, createDropdown, setMinimapPosition, setCurrentMinimapPosition, 
 // custom minimap
-setCustomMap, setupCustomMinimapPane, setCustomMinimapRotation, getCustomMinimapRotation, generateCustomMinimap, setCustomMapScale, setCustomMapTranslate, setCustomMapXOffset, setCustomMapYOffset, getCustomMapScale, getCustomMapTranslate, getCustomMapXOffset, getCustomMapYOffset, setMinAndMax, setCustomMapFloorData, getCustomMapFloorData, resetCustomMapSettingValues, getMinimapPosition, subscribeToFloorChanges, setMpSDK, getMpSdk };
+setCustomMap, setupCustomMinimapPane, setCustomMinimapRotation, getCustomMinimapRotation, generateCustomMinimap, setCustomMapScale, setCustomMapTranslate, setCustomMapXOffset, setCustomMapYOffset, getCustomMapScale, getCustomMapTranslate, getCustomMapXOffset, getCustomMapYOffset, setMinAndMax, setCustomMapFloorData, getCustomMapFloorData, resetCustomMapSettingValues, getMinimapPosition, subscribeToFloorChanges, setMpSDK, getMpSdk, setCustomMapMode, getCustomMapMode };

package/lib/types.d.ts

@@ -446,6 +446,8 @@ export interface ComponentOptions {
     polygonData?: PolygonData | undefined;
     wallHeight?: number | undefined;
     floorLevel?: number | undefined;
+    lineComponentType?: string | undefined;
+    id?: number | undefined;
 }
 export interface VectorCoords {
     object_position: Vector3;
@@ -731,7 +733,23 @@ export declare enum SPACE_EVENTS {
     CUSTOM_SWEEP_OFFSETY_UPDATED = "CUSTOM_SWEEP_OFFSETY_UPDATED",
     CUSTOM_MAP_SETTINGS_UPDATED = "CUSTOM_MAP_SETTINGS_UPDATED",
     SPACE_METADATA_RETRIEVED = "SPACE_METADATA_RETRIEVED",
-    TAG_MESSAGE_UNSEND = "TAG_MESSAGE_UNSEND"
+    RENDER_PIPE_CATEGORY = "RENDER_PIPE_CATEGORY",
+    PIPE_CATEGORY_REMOVED = "PIPE_CATEGORY_REMOVED",
+    PIPE_CATEGORY_SAVED = "PIPE_CATEGORY_SAVED",
+    PIPE_CATEGORY_SELECTED = "PIPE_CATEGORY_SELECTED",
+    PIPE_CATEGORY_ON_CHANGE = "PIPE_CATEGORY_ON_CHANGE",
+    PIPE_SAVED = "PIPE_SAVED",
+    PIPE_REMOVED = "PIPE_REMOVED",
+    PIPE_ON_CHANGE = "PIPE_ON_CHANGE",
+    PIPE_CLICKED = "PIPE_CLICKED",
+    PIPE_ADD = "PIPE_ADD",
+    PIPE_SELECTED = "PIPE_SELECTED",
+    DRAW_PIPE = "DRAW_PIPE",
+    DRAW_PIPE_UNDO = "DRAW_PIPE_UNDO",
+    DRAW_PIPE_REDO = "DRAW_PIPE_REDO",
+    PIPE_VERTEX_REMOVED = "PIPE_VERTEX_REMOVED",
+    TAG_MESSAGE_UNSEND = "TAG_MESSAGE_UNSEND",
+    PATH_UPDATED = "PATH_UPDATED"
 }
 export declare const enum TAG_COLOR {
     MAROON = "MAROON",
@@ -885,6 +903,7 @@ export interface IToolbarConfig {
             includeMeasurements?: boolean;
             includeViews?: boolean;
         };
+        pipe?: boolean;
         models?: boolean;
         minimap?: boolean;
         theme?: boolean;
@@ -988,6 +1007,7 @@ export interface TagMessage {
     binaryFile?: File;
     created_on?: any;
     modified_on?: any;
+    is_sender?: boolean;
 }
 export interface EmbedlyData {
     author_name: string;
@@ -1097,7 +1117,8 @@ export declare const enum SCREEN_POSITIONS {
 }
 export declare const enum FORM_MODE {
     ADD = "ADD",
-    EDIT = "EDIT"
+    EDIT = "EDIT",
+    NONE = "NONE"
 }
 export declare enum ZOOM_COMMAND {
     TOGGLE_VIDEO_ON = "TOGGLE VIDEO ON",
@@ -1280,6 +1301,18 @@ export interface SpaceMetadata {
         };
     };
 }
+export interface PathConfig {
+    lineType: string;
+    verticeType: string;
+    lineTypeComponentConfig?: ComponentOptions;
+    verticeTypeComponentConfig?: ComponentOptions;
+}
+export interface ModelPayload {
+    mediaUrl: string;
+    objectType: string;
+    config?: ObjectConfig;
+    object_data?: I3DObject;
+}
 export declare enum COORDINATE_SYSTEM {
     MATTERPORT = "YUP",
     BIM = "ZUP"
@@ -1304,3 +1337,54 @@ export declare enum MAP_OPTIONS {
     DEFAULT_MAP = "Default Minimap",
     CUSTOM_MAP = "Custom Minimap"
 }
+export declare enum CUSTOM_MAP_MODE {
+    DEFAULT = "DEFAULT",
+    EDIT = "EDIT"
+}
+export interface VetexData {
+    uuid: string;
+    name: string;
+    path: Array<Vector3>;
+}
+export interface IPipeCategory {
+    uuid: string;
+    space_uuid: string;
+    name: string;
+    parent_uuid: string;
+    json_data: string;
+    color?: string;
+    pipes: Array<IPipe>;
+    owner_uuid?: string;
+    created_on: Date;
+}
+export interface IPipe {
+    uuid: string;
+    space_uuid: string;
+    name: string;
+    category_uuid: string;
+    json_data: string;
+    created_on: Date;
+}
+export declare enum COLLAPSE {
+    TOGGLE_ID = "at-collapse-toggle-btn",
+    CONTENT_ID = "at-collapse-content",
+    ACTIVE = "active",
+    EXPAND = "expand",
+    TOGGLE = "toggle",
+    INACTIVE = "inactive",
+    LIST = "at-collapse-list",
+    HEADER = "at-collapse-header",
+    FORM = "at-collapse-form",
+    ITEM = "item"
+}
+export declare enum DRAWING_MODE {
+    ACTIVE = "active",
+    INACTIVE = "inactive"
+}
+export interface PipePayload {
+    uuid?: string | undefined;
+    space_uuid?: string | undefined;
+    name?: string | undefined;
+    parent_uuid?: string | undefined;
+    json_data: PolygonData;
+}