mx3d 2024.6.4 → 2024.6.7

package/index.d.ts

@@ -1,24 +1,1079 @@
-import { App } from "./components/App";
-import { AlarmFlashing } from "./components/AlarmFlashing";
-import { Builder } from "./components/Builder";
-import { EventType } from "./events/EventType";
-import { StatusType } from "./components/StatusType";
-import { UI } from "./components/UI";
-import { Effect, EffectType } from "./effects/Effect";
-import TileLoader from "./earths/TileLoader";
-export default class MX3D {
-    static accessToken: string;
-    static pk: string;
-    static sl: string;
-    static rl: string;
-    static App: typeof App;
-    static Request: import("axios").AxiosInstance;
-    static AlarmFlashing: typeof AlarmFlashing;
-    static UI: typeof UI;
-    static Builder: typeof Builder;
-    static EffectType: typeof EffectType;
-    static EventType: typeof EventType;
-    static StatusType: typeof StatusType;
-    static Effect: typeof Effect;
-    static TileLoader: typeof TileLoader;
+declare namespace MX3D {
+  let accessToken: string;
+  let pk: string;
+  let sl: string;
+  let rl: string;
+
+  class AlarmFlashing {
+    static colors: {
+      1: Runtime.Color3;
+      2: Runtime.Color3;
+      3: Runtime.Color3;
+      4: Runtime.Color3;
+      5: Runtime.Color3;
+      6: Runtime.Color3;
+    };
+    static init(): void;
+  }
+
+  class App {
+    canvas: HTMLCanvasElement;
+    engine: Runtime.Engine;
+    scene: Runtime.Scene;
+    camera: CameraController;
+    iEvent: IEvent;
+    highlightLayer: Runtime.HighlightLayer;
+    container: Runtime.AdvancedDynamicTexture;
+    fps: HTMLDivElement;
+    resources: Resources;
+    environment: Environment;
+    project: Project;
+    toolTips: ToolTips;
+    gl: Runtime.GlowLayer;
+    positionGizmo: Runtime.PositionGizmo;
+    constructor(_config: { container: HTMLElement; sl?: string; rl?: string });
+    load(_config: { pk?: string; isDefaultLevel?: boolean; isDefaultMutual?: boolean; progress?: Function; complete?: Function; onError?: Function }): Promise<void>;
+    isDefaultMutual: boolean;
+    set defaultMutual(value: boolean);
+    dispose(): void;
+  }
+
+  class Builder {
+    static createMatrixCloud(_data: {
+      anchor: IObject;
+      value: {
+        maxX: number;
+        maxY: number;
+        data: Array<{
+          x: number;
+          y: number;
+          value: number;
+        }>;
+      };
+      displayValues: boolean;
+      height: number;
+      isLevelRender: boolean;
+      isAlpha: boolean;
+      isParticle: boolean;
+      radius: number;
+      range: {
+        max: number;
+        min: number;
+      };
+    }): HeatMap;
+    private static _getMatrixParticleTex;
+    static createPunctateCloud(_data: {
+      anchor: IObject;
+      value: number;
+      radius: number;
+      isLevelRender: boolean;
+      displayValues: boolean;
+      isAlpha: boolean;
+      isParticle: boolean;
+      range: {
+        max: number;
+        min: number;
+      };
+    }): HeatMap;
+    static createColumnCloud(_data: {
+      anchor: IObject;
+      data: Array<{
+        index: number;
+        value: number;
+      }>;
+      isLevelRender: boolean;
+      displayValues: boolean;
+      isAlpha: boolean;
+      isParticle: boolean;
+      radius: number;
+      range: {
+        max: number;
+        min: number;
+      };
+    }): HeatMap;
+    private static _getColumnarParticleTex;
+    private static createTempVlaue;
+    static createCapacity(obj: IObject, RATIO: number, _text: string, _fontSize?: string): Capacity;
+    static createTextMesh(obj: IObject, _text: string, RATIO: number, _fontSize?: string, _color?: string): Runtime.Mesh;
+    static create2DLine(
+      _id: string,
+      _objs: Array<IObject>,
+      _options?: {
+        width: number;
+        color: string;
+        isDotted: boolean;
+      },
+    ): Line;
+    static create3DLine(
+      _id: string,
+      _objs: Array<IObject>,
+      _options?: {
+        width: number;
+        color: string;
+      },
+    ): LineFromMesh;
+  }
+
+  class Capacity {
+    anchor: IObject;
+    mesh: Runtime.Mesh;
+    ratio: number;
+    color: string;
+    textMesh: Runtime.Mesh;
+    constructor(_object: IObject, RATIO: number);
+    dispose(): void;
+  }
+
+  class Environment {
+    app: App;
+    lights: Dictionary<LightObject>;
+    _color: Runtime.Color4;
+    background: Runtime.Layer;
+    reflexEnabled: boolean;
+    reflexIntensity: number;
+    constructor(_app: App);
+    setTransparent(_visibility?: number): void;
+    default(): void;
+    set fogDistance(_value: number);
+    set color(_value: Runtime.Color4);
+    reflex(url: string, intensity: number): void;
+    setBackground(url: string): void;
+    setReflexEnabled(_reflexEnabled: boolean): void;
+    setFlexIntensity(_intensity: number): void;
+    defaultLights(): void;
+    offAllLight(): void;
+    openAllLight(): void;
+    loadLight(Lights: Array<any>): void;
+    setLightIntensity(_intensity?: number): void;
+    showTips(): void;
+    closeTips(): void;
+    showFps(cssText?: string): void;
+    hideFps(): void;
+    showDebug(): void;
+  }
+
+  class HeatMap implements BaseNode {
+    id: string;
+    anchor: IObject;
+    mesh: Runtime.Mesh;
+    displayValue: boolean;
+    texts: Array<Runtime.TextBlock>;
+    constructor(_anchor: IObject);
+    isEnabled(_bool: boolean): void;
+    set displayValues(_value: boolean);
+    dispose(): void;
+  }
+
+  class Icon implements BaseNode {
+    id: string;
+    scene: Runtime.Scene;
+    pint: Runtime.Mesh;
+    private textDics;
+    private _line;
+    rect: Runtime.Rectangle;
+    private _background;
+    size: {
+      width: number;
+      height: number;
+    };
+    height: number;
+    container: Runtime.AdvancedDynamicTexture;
+    constructor(_id: string, _scene: Runtime.Scene);
+    set background(_url: string);
+    addEventListener(_action: Function): void;
+    setTexts(
+      _textArr: [
+        {
+          text: string;
+          fontSize: string;
+          color: string;
+          top: number;
+          left: number;
+        },
+      ],
+    ): void;
+    line(_line: { width: number; color: string }): void;
+    dispose(): void;
+    isEnabled(_isEnabled: boolean): void;
+  }
+
+  class IconFromMesh implements BaseNode {
+    id: string;
+    scene: Runtime.Scene;
+    instance: Runtime.Mesh;
+    url: string;
+    scaling: number;
+    textArr: [
+      {
+        text: string;
+        fontSize: string;
+        top: number;
+        left: number;
+        color?: string;
+      },
+    ];
+    constructor(_id: string, _anchor: Runtime.Vector3, _scaling: number, _height: number, _scene: Runtime.Scene);
+    setBackground(_url: string): Promise<unknown>;
+    addEventListener(_action: Function): void;
+    setColor(color: string): void;
+    setContents(
+      _textArr: [
+        {
+          text: string;
+          fontSize: string;
+          top: number;
+          left: number;
+          color?: string;
+        },
+      ],
+    ): Promise<unknown>;
+    dispose(): void;
+    isEnabled(_bool: boolean): void;
+  }
+
+  class Line {
+    id: string;
+    objs: Array<IObject>;
+    instance: Runtime.MultiLine;
+    color: string;
+    width: number;
+    isDotted: boolean;
+    update(): void;
+    addEventListener(_action: Function): void;
+    isEnabled(_isEnabled: boolean): void;
+    dispose(): void;
+  }
+
+  class LineFromMesh {
+    id: string;
+    objs: Array<IObject>;
+    instance: Runtime.Mesh;
+    color: string;
+    width: number;
+    update(): void;
+    addEventListener(_action: Function): void;
+    isEnabled(_isEnabled: boolean): void;
+    dispose(): void;
+  }
+
+  enum StatusType {
+    Opaque = 0,
+    Flash = 1,
+    Transparent = 2,
+  }
+
+  class UI {
+    static createIconFromMesh(_id: string, _anchor: IObject, _scaling: number, _height: number): IconFromMesh;
+    static createIcon(
+      _id: string,
+      _anchor: IObject,
+      _size: {
+        width: number;
+        height: number;
+      },
+      _height: number,
+    ): Icon;
+  }
+
+  class TileLoader {
+    app: App;
+    constructor(_app: App);
+    load(url: string): Promise<void>;
+  }
+
+  class CloudEffect implements IEffect {
+    app: App;
+    cloudNum: number;
+    canvas: HTMLCanvasElement;
+    canvasCloudCtx: CanvasRenderingContext2D;
+    clouds: Array<Cloud>;
+    X: number;
+    Y: number;
+    constructor(_app: App);
+    start(): void;
+    close(): void;
+    render(): void;
+    clearCanvasCloud(): void;
+  }
+  class Cloud {
+    rainSpeed: number;
+    ctx: CanvasRenderingContext2D;
+    c: string;
+    x: number;
+    y: number;
+    r: number;
+    v: {
+      x: number;
+      y: number;
+    };
+    color: {
+      r: number;
+      g: number;
+      b: number;
+      a: number;
+    };
+    X: number;
+    constructor(ctx: any, x: any, y: any, _X: any);
+    init(x: number, y: number): void;
+    draw(): void;
+    gradient(): CanvasGradient;
+    updatePosition(): void;
+    wrapPosition(): void;
+    render(): void;
+  }
+
+  enum EffectType {
+    Thunder = 'Thunder',
+    Rain = 'Rain',
+    Cloud = 'Cloud',
+  }
+  class Effect {
+    static effects: Dictionary<IEffect>;
+    static add(_effectType: EffectType, _app: App): void;
+    static remove(_effectType: EffectType): void;
+  }
+
+  interface IEffect {
+    start: Function;
+    close: Function;
+  }
+
+  class RainEffect implements IEffect {
+    app: App;
+    rainNum: number;
+    canvas: HTMLCanvasElement;
+    canvasRainCtx: CanvasRenderingContext2D;
+    rains: Array<Rain>;
+    X: number;
+    Y: number;
+    constructor(_app: App);
+    start(): void;
+    close(): void;
+    render(): void;
+    clearCanvasRain(): void;
+  }
+  class Rain {
+    rainSpeed: number;
+    ctx: CanvasRenderingContext2D;
+    Y: number;
+    x: number;
+    y: number;
+    r: number;
+    c: string;
+    v: {
+      y: number;
+    };
+    constructor(ctx: any, x: any, y: any, r: any, _Y: any);
+    init(x: number, y: number, r: number): void;
+    draw(): void;
+    updatePosition(): void;
+    wrapPosition(): void;
+    render(): void;
+  }
+
+  class ThunderEffect implements IEffect {
+    app: App;
+    thunderNum: number;
+    canvas: HTMLCanvasElement;
+    canvasThunderCtx: CanvasRenderingContext2D;
+    thunders: Array<Thunder>;
+    X: number;
+    Y: number;
+    constructor(_app: App);
+    start(): void;
+    close(): void;
+    render(): void;
+    clearCanvasThunder(): void;
+  }
+  class Thunder {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    r: number;
+    l: any;
+    c: string;
+    Y: number;
+    X: number;
+    constructor(ctx: any, x: any, y: any, r: any, _X: any, _Y: any);
+    init(x: number, y: number, r: number): void;
+    draw(): void;
+    updateParams(): void;
+    render(): void;
+  }
+
+  class DefaultEvent implements IEvent {
+    app: App;
+    isMove: number;
+    waitingTime: number;
+    touchtime: number;
+    constructor(_app: App);
+    registerAfterRender(): void;
+    runRender(): void;
+    onPointer(pointerInfo: Runtime.PointerInfo): void;
+    onKeyboard(kbInfo: Runtime.KeyboardInfo): void;
+  }
+
+  enum EventType {
+    leftClick = 'leftClick',
+    rightClick = 'rightClick',
+    doubleClick = 'doubleClick',
+    eover = 'eover',
+    longPress = 'longPress',
+    out = 'out',
+    click = 'click',
+  }
+
+  class FPSCameraEvent implements IEvent {
+    app: App;
+    isFPS: boolean;
+    angle: number;
+    direction: Runtime.Vector3;
+    isMoveLeft: boolean;
+    isMoveRight: boolean;
+    isMoveDown: boolean;
+    isMoveUp: boolean;
+    constructor(_app: App);
+    registerAfterRender(): void;
+    runRender(): void;
+    onPointer(pointerInfo: Runtime.PointerInfo): void;
+    onKeyboard(_e: Runtime.KeyboardInfo): void;
+  }
+
+  interface IEvent {
+    runRender(): void;
+    onPointer(e: Runtime.PointerInfo): void;
+    onKeyboard(e: Runtime.KeyboardInfo): void;
+    registerAfterRender(): void;
+  }
+
+  class HubService {
+    static connection: any;
+    static listener(_Url: string): Promise<void>;
+    static start(): Promise<void>;
+  }
+
+  class Directional extends LightObject {
+    direction: Runtime.Vector3;
+    position: Runtime.Vector3;
+    light: Runtime.DirectionalLight;
+    load(): void;
+  }
+
+  class Hemispheric extends LightObject {
+    direction: Runtime.Vector3;
+    light: Runtime.HemisphericLight;
+    load(): void;
+  }
+
+  interface ILightObject {
+    id: string;
+    sceneId: string;
+    name: string;
+    light: Runtime.Light;
+    color: string;
+    lightType: string;
+    intensity: number;
+    load: Function;
+  }
+
+  class LightObject implements ILightObject {
+    id: string;
+    sceneId: string;
+    name: string;
+    light: Runtime.Light;
+    color: string;
+    objectType: string;
+    lightType: string;
+    intensity: number;
+    app: App;
+    constructor(_app: App);
+    load(): void;
+  }
+
+  enum LightType {
+    Point = 'Point',
+    Spot = 'Spot',
+    Directional = 'Directional',
+    Hemispheric = 'Hemispheric',
+  }
+  declare let typeFromat: Function;
+  typeFromat;
+
+  class Point extends LightObject {
+    position: Runtime.Vector3;
+    light: Runtime.PointLight;
+    range: number;
+    load(): void;
+  }
+
+  class Spot extends LightObject {
+    direction: Runtime.Vector3;
+    position: Runtime.Vector3;
+    angle: number;
+    exponent: number;
+    range: number;
+    light: Runtime.SpotLight;
+    load(): void;
+  }
+
+  class MJGLLoader {
+    static load(app: App, _data: any, progress?: Function): Promise<void>;
+  }
+
+  class Mx3dLoader {
+    static load(app: App, _data: any, progress?: Function): Promise<void>;
+  }
+
+  class BaseModel {
+    extension: string;
+    groupId: string;
+    heat: number;
+    height: number;
+    insertTime: string;
+    isTiling: boolean;
+    length: number;
+    modelId: string;
+    modelName: string;
+    modelType: ObjectType;
+    modelTypeName: string;
+    width: number;
+  }
+
+  class BuildingObject extends DefaultObject {
+    completed(): void;
+    computeView(): void;
+    getInto(): void;
+    goBack(): void;
+  }
+
+  class CabinetObject extends DefaultObject {
+    rack: Runtime.Mesh | Runtime.InstancedMesh;
+    computeView(): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+    loadRacks(_data: Array<RackModel>): void;
+    unloadRacks(): void;
+    open(): void;
+    close(): void;
+  }
+
+  class CampusObject extends IRegion {
+    addEventListener(_type: string, _callback: Function): void;
+    removeEventListener(_type: string): void;
+    setEnabled(_isEnabled: boolean): void;
+    loadProperties(_m: any): void;
+    bind(): void;
+  }
+
+  class ConduitObject extends DefaultObject {
+    alpha: number;
+    color: string;
+    pints: Runtime.Vector3[];
+    radius: number;
+    loadProperties(_m: any): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+    setColor(_color?: string): void;
+    reColor(): void;
+    computeView(): void;
+    setFlash(_level?: number): void;
+    setOpaque(): void;
+    setTransparent(alpha?: number): void;
+  }
+
+  class CornerObject implements IObject {
+    app: App;
+    id: string;
+    name: string;
+    parentId: string;
+    objectType: string;
+    height: number;
+    customNumber: string;
+    customType: string;
+    instance: Runtime.Mesh | Runtime.InstancedMesh;
+    Sight: Sight;
+    statusType: StatusType;
+    showBoundingBox: boolean;
+    pints: any;
+    constructor(_app: App);
+    getInto(): void;
+    goBack(): void;
+    baseModel: baseModel;
+    loadProperties(_m: any): void;
+    alwaysActive(): void;
+    optimization(_isOptimization: boolean): void;
+    setFlash(_level: number): void;
+    setEnabled(isEnabled: any): void;
+    addEventListener(_type: string, _callback: Function): void;
+    removeEventListener(_type: string): void;
+    computeView(): void;
+    bind(): boolean;
+    toJson(): {
+      id: string;
+      parentId: string;
+      name: string;
+      customNumber: string;
+      customType: string;
+      objectType: string;
+    };
+    completed(): void;
+    setOpaque(): void;
+    setTransparent(): void;
+  }
+
+  class DefaultObject implements IObject {
+    app: App;
+    id: string;
+    name: string;
+    customNumber: string;
+    customType: string;
+    parentId: string;
+    baseModel: baseModel;
+    instance: Runtime.Mesh | Runtime.InstancedMesh;
+    objectType: string;
+    action: Runtime.ActionManager;
+    executes: Dictionary<Runtime.ExecuteCodeAction>;
+    clickEvents: Dictionary<Function>;
+    touchtime: number;
+    statusType: StatusType;
+    Sight: Sight;
+    animation: boolean;
+    isLoop: boolean;
+    isAutoPlay: boolean;
+    position: Runtime.Vector3;
+    rotation: Runtime.Vector3;
+    scaling: Runtime.Vector3;
+    constructor(_app: App);
+    loadProperties(_m: any): void;
+    setEnabled(_value: boolean): void;
+    set showBoundingBox(_value: boolean);
+    get showBoundingBox(): boolean;
+    set isPickable(_value: boolean);
+    get isPickable(): boolean;
+    bind(): void;
+    completed(): void;
+    computeView(): void;
+    optimization(_isOptimization: boolean): void;
+    alwaysActive(): void;
+    addEventListener(type: EventType, callback: Function): void;
+    removeEventListener(type: string): void;
+    setFlash(_level: number): void;
+    setOpaque(): void;
+    setTransparent(alpha?: number, enableEdges?: boolean): void;
+    setColor(_color?: string): void;
+    play(): void;
+    stop(): void;
+    toJson(): {
+      id: string;
+      parentId: string;
+      name: string;
+      customNumber: string;
+      customType: string;
+      objectType: string;
+    };
+    getInto(): void;
+    goBack(): void;
+  }
+
+  class DoorObject extends DefaultObject {
+    height: number;
+    loadProperties(_m: any): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+  }
+
+  class FloorObject extends DefaultObject {
+    height: number;
+    vectors: Runtime.Vector3[];
+    buckles: Runtime.Vector3[][];
+    loadProperties(_m: any): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+    computeView(): void;
+    setOpaque(): void;
+  }
+
+  interface IBase {
+    app: App;
+    id: string;
+    name: string;
+    parentId: string;
+    objectType: string;
+    customNumber: string;
+    customType: string;
+    baseModel: BaseModel | undefined;
+    instance: Runtime.Mesh | Runtime.InstancedMesh;
+    Sight: Sight;
+    loadProperties(_m: any): void;
+    bind(): any;
+    completed(): any;
+    setEnabled(isEnabled: boolean): any;
+    toJson(): any;
+    getInto(): any;
+    goBack(): any;
+  }
+
+  interface IObject extends IBase {
+    statusType: StatusType;
+    showBoundingBox: boolean;
+    optimization(isOptimization: boolean): any;
+    setFlash(level: number): any;
+    setTransparent(): any;
+    setOpaque(): any;
+    addEventListener(type: EventType, callback: Function): any;
+    removeEventListener(type: EventType): any;
+    computeView(): any;
+    alwaysActive(): any;
+  }
+
+  class IRegion implements IBase {
+    app: App;
+    id: string;
+    name: string;
+    parentId: string;
+    objectType: string;
+    baseModel: baseModel;
+    customNumber: string;
+    customType: string;
+    Sight: Sight;
+    instance: Runtime.Mesh | Runtime.InstancedMesh;
+    position: Runtime.Vector3;
+    rotation: Runtime.Vector3;
+    index: number;
+    layerName: string;
+    layerHeight: number;
+    action: Runtime.ActionManager;
+    executes: Dictionary<Runtime.ExecuteCodeAction>;
+    clickEvents: Dictionary<Function>;
+    touchtime: number;
+    constructor(_app: App);
+    loadProperties(_m: any): void;
+    bind(): void;
+    completed(): void;
+    setEnabled(_isEnabled: boolean): void;
+    addEventListener(type: string, callback: Function): void;
+    removeEventListener(type: string): void;
+    load(isOptimized: boolean, _objs: Array<any>): void;
+    toJson(): {
+      id: string;
+      parentId: string;
+      name: string;
+      customNumber: string;
+      customType: string;
+      objectType: string;
+      index: number;
+      layerHeight: number;
+      layerName: string;
+    };
+    computeView(): void;
+    getInto(): void;
+    goBack(): void;
+  }
+
+  class LeakWaterObject extends DefaultObject {
+    lines: Runtime.Vector3[];
+    loadProperties(_l: any): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+    completed(): void;
+    computeView(): void;
+    addEventListener(type: string, callback: Function): void;
+    removeEventListener(type: string): void;
+  }
+
+  enum ObjectType {
+    Cabinet = 'Cabinet',
+    RackModel = 'RackModel',
+    Corner = 'Corner',
+    Other = 'Other',
+    Door = 'Door',
+    Floor = 'Floor',
+    LeakWater = 'LeakWater',
+    UI3D = 'UI3D',
+    VirtualBox = 'VirtualBox',
+    Wall = 'Wall',
+    Window = 'Window',
+    Conduit = 'Conduit',
+    Building = 'Building',
+    Storey = 'Storey',
+    Campus = 'Campus',
+  }
+
+  class OptimizedWallObject extends DefaultObject {
+    nativeMaterial: Runtime.StandardMaterial;
+    loadProperties(_w: any): void;
+    bind(): void;
+  }
+
+  class Project {
+    private app;
+    id: string;
+    current: IBase;
+    root: IRegion;
+    levelEvent: Function;
+    objectDatas: Dictionary<IBase>;
+    constructor(_app: App);
+    clear(): void;
+    optimization(): void;
+    getChildsById(_id: string, _includeSub?: boolean): IBase[];
+    getSceneTree(_id?: string, _excludeTypes?: Array<string>): any;
+    findObjectById(_id: string): IBase;
+    findObjectByCustomNumber(_customNumber: string): any;
+    findObjectsByCustomType(
+      _customType: string,
+      queryParameters?: {
+        isCurrent: boolean;
+        isEnabled: boolean;
+      },
+    ): any[];
+    findObjectsByType(_type: ObjectType): IBase[];
+    computeSight(_objs: Array<IBase>): any;
+    switchLevel(_id?: string, _isFocus?: boolean): void;
+    goBack(): void;
+    getTypes(_parentId?: string): any[];
+    getCustomTypes(_parentId?: string): any[];
+  }
+
+  class RackModel {
+    id: string;
+    name: string;
+    uHeight: number;
+    uStart: number;
+    color: string;
+    frontImgUrl: string;
+    backImgUrl: string;
+    direction: boolean;
+    width: number;
+    depth: number;
+  }
+
+  class RackObject implements IObject {
+    app: App;
+    id: string;
+    name: string;
+    parentId: string;
+    objectType: ObjectType;
+    customNumber: string;
+    customType: string;
+    baseModel: BaseModel;
+    instance: Mesh | InstancedMesh;
+    Sight: Sight;
+    statusType: StatusType;
+    showBoundingBox: boolean;
+    action: Runtime.ActionManager;
+    executes: Dictionary<Runtime.ExecuteCodeAction>;
+    clickEvents: Dictionary<Function>;
+    touchtime: number;
+    uHeight: number;
+    uStart: number;
+    color: string;
+    frontImgUrl: string;
+    backImgUrl: string;
+    direction: boolean;
+    width: number;
+    depth: number;
+    constructor(_app: App, _parentId: string);
+    setEnabled(isEnabled: boolean): void;
+    loadProperties(_m: RackModel): void;
+    bind(): void;
+    optimization(_isOptimization: boolean): void;
+    alwaysActive(): void;
+    addEventListener(type: EventType, callback: Function): void;
+    removeEventListener(type: string): void;
+    setFlash(_level: number): void;
+    setOpaque(): void;
+    setTransparent(alpha?: number): void;
+    setColor(_color?: string): void;
+    computeView(): void;
+    completed(): void;
+    toJson(): {
+      id: string;
+      parentId: string;
+      name: string;
+      customNumber: string;
+      customType: string;
+      objectType: ObjectType;
+    };
+    getInto(): void;
+    goBack(): void;
+  }
+
+  class StoreyObject extends IRegion {
+    scaling: Runtime.Vector3;
+    loadProperties(_m: any): void;
+    bind(): void;
+    alwaysActive(): void;
+    completed(): void;
+    computeView(): void;
+  }
+
+  class UI3DTextObject extends DefaultObject {
+    tconfig: {
+      color: string;
+      position: any;
+      rotation: any;
+      scaling: any;
+      clearColor: string;
+    };
+    isLookAt: boolean;
+    setEnabled(_value: boolean): void;
+    loadProperties(_u: any): void;
+    bind(): void;
+  }
+
+  class VirtualBoxObject extends DefaultObject {
+    virtualType: string;
+    color: Runtime.Color3;
+    alpha: number;
+    isEdges: boolean;
+    edgesWidth: number;
+    edgesColor: Runtime.Color4;
+    loadProperties(_m: any): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+  }
+
+  class WallObject extends DefaultObject {
+    nativeMaterial: Runtime.StandardMaterial;
+    height: number;
+    walls: Runtime.Mesh[];
+    loadProperties(_m: any): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+    completed(): void;
+    setOpaque(): void;
+  }
+
+  class WindowObject extends DefaultObject {
+    height: number;
+    loadProperties(_m: any): void;
+    setEnabled(_value: boolean): void;
+    bind(): void;
+  }
+
+  class ArrayEx<T> extends Array<T> {
+    remove(val: any): void;
+  }
+
+  interface BaseNode {
+    id: string;
+    dispose(): any;
+    isEnabled(bool: boolean): any;
+  }
+
+  class CameraController {
+    app: App;
+    arcRotateCamera: Runtime.ArcRotateCamera;
+    frustrum: number;
+    freeCamera: Runtime.FreeCamera;
+    _isAutoRotation: boolean;
+    autoRotationSpeed: number;
+    constructor(_app: App);
+    orthographic(_object?: IBase): void;
+    startAutoRotation(_autoRotationSpeed?: number): void;
+    stopAutoRotation(): void;
+    perspective(_object?: IBase): void;
+    flyTo(_Sight?: Sight, _sheep?: number): void;
+    flyToObject(_object: IObject, _sheep?: number): void;
+    lookToTheFront(_object: IObject, _sheep?: number): void;
+    getSightJson(): string;
+    private computeCameraView;
+    _wheel(p: any): void;
+    switchArcRotateCamera(): void;
+    switchFPSCamera(): void;
+  }
+
+  class Dictionary<T> {
+    map: {
+      [key: string]: T;
+    };
+    constructor();
+    add(key: string, value: T): void;
+    find(key: string): T;
+    remove(key: string): void;
+    termRemove(callback: Function): void;
+    showAll(): void;
+    count(): number;
+    clear(): void;
+  }
+
+  class GUID {
+    static getGUID(length: number): string;
+  }
+
+  class RES {
+    static de(str: string): any;
+  }
+
+  class Resources {
+    app: App;
+    walls: Dictionary<Runtime.AbstractMesh>;
+    resources: Dictionary<Runtime.AssetContainer>;
+    ndoeMats: Dictionary<Runtime.NodeMaterial>;
+    transparentBox: Runtime.Mesh;
+    BOX: Runtime.Mesh;
+    FogTex: Runtime.Texture;
+    constructor(_app: App);
+    loadModelMesh(baseModel: any): Promise<Runtime.AssetContainer>;
+    loadModelMeshAsync(baseModel: any, callback: Function): void;
+    Materials: Dictionary<Runtime.StandardMaterial>;
+    Textures: Dictionary<Runtime.Texture>;
+    GetMaterial(textureData: any): Runtime.StandardMaterial;
+    GetTexture(textureData: any): Runtime.Texture;
+    LoadLightMap(id: string, name: string): Runtime.Texture;
+    MergeMaterials: Dictionary<Runtime.CustomMaterial>;
+    GetMergeMaterial(textureData: any): Runtime.CustomMaterial;
+    delete(isAll?: boolean): void;
+    GetWalls(url: string, projectId: string): Promise<void>;
+    setTransparent(_visibility?: number): void;
+    setTransparentById(modelId: string, _visibility?: number): void;
+  }
+
+  class Sight {
+    alpha: number;
+    focus: Runtime.Vector3;
+    radius: number;
+    beta: number;
+    minimumLimit: number;
+    maximumLimit: number;
+    minBeta: number;
+    maxBeta: number;
+    toJosn(_sightJson: any): void;
+    toString(): string;
+    setLimit(_miniLimit: number, _maxiLimit: number): void;
+    setBeta(_minBeta: number, _maxBeta: number): void;
+  }
+
+  class ToolTips {
+    app: App;
+    url: string;
+    ele: HTMLDivElement;
+    private _text;
+    set text(vlaue: string);
+    constructor(_app: App);
+    update(e: Runtime.PointerInfo): void;
+    close(): void;
+    setBackground(_url: string): void;
+    dispose(): void;
+  }
+
+  class Tools {
+    static vector3ToJson(old: Runtime.Vector3): any;
+    static vector3ARRToJson(olds: Runtime.Vector3[]): Runtime.Vector3[];
+    static ToVector3(old: any): Runtime.Vector3;
+    static ToARRVector3(olds: any[]): Runtime.Vector3[];
+    static computeBounds(mscene: Runtime.Mesh): Runtime.BoundingInfo;
+    static computeBoundsToARR(_meshs: Array<Runtime.Mesh>): Runtime.BoundingInfo;
+    static Expand(polygon: Array<Runtime.Vector3>, expand: number): Array<Runtime.Vector3>;
+    static norm(x: number, y: number): number;
+    static MergeMeshes(meshes: Array<Runtime.Mesh>, app: App): Runtime.Mesh;
+    static DeconsTructMesh(mesh: any, height: any, app: App): Array<Runtime.Mesh>;
+    static getVisualAngle(_bound: Runtime.BoundingInfo, app: App): any;
+    static pathTransformation(oldPath: Array<Runtime.Vector3>, radius: number): any[];
+    static createTube(id: string, paths: Array<Runtime.Vector3>, radius: number, app: App): Runtime.Mesh;
+    static getAngleFromVector2(startV: Runtime.Vector2, coreV: Runtime.Vector2, endV: Runtime.Vector2): number;
+    static getAngleFromVector3(startV: Runtime.Vector3, coreV: Runtime.Vector3, endV: Runtime.Vector3): number;
+    static RandomNumBoth(Min: any, Max: any): any;
+    static rand(min: number, max: number): number;
+  }
 }