import { createWebglEngine, createCloudEngine, createNodeServer, createCesiumEngine, webglPlugin, unityPlugin, SceneCacheType } from "./core";
import { defineAnimation, definePlugin } from "./core/extension";
import { createAnimationFromSimilarAnimation, createAnimationFromTween, createAnimationFromTweenGroup } from "./core/animation";
import { DTEvent } from "./common/event-emitter";
import { EngineType } from "./common/constant";
import type { Meta } from "./interface/meta";
import type { Animation, AnimationCreator, AnimationOptions } from "./core/extension";
import type { WebglModel } from "./webgl/model";
import type { PluginCreator, Plugin, PluginOptions } from "./interface/meta";
import type { Component, ComponentGroup, Options as ComponentOptions } from "./interface/component";
import type { WebglCreator } from "./webgl/index";
import type { WebglRenderer } from "./webgl/renderer";
import type { WebglScene } from "./webgl/scene";
import type { WebglCamera } from "./webgl/camera";
import type { UnityCreator } from "./unity/index";
import type { UnityModel } from "./unity/model";
import type { UnityRenderer } from "./unity/renderer";
import type { UnityScene } from "./unity/scene";
import type { UnityCamera } from "./unity/camera";
import TWEEN from "@tweenjs/tween.js";
export type { Meta, ComponentOptions, Component, ComponentGroup, WebglCreator, WebglRenderer, WebglScene, WebglCamera, WebglModel, UnityCreator, UnityModel, UnityRenderer, UnityScene, UnityCamera, PluginCreator, Plugin, PluginOptions, Animation, AnimationCreator, AnimationOptions };
export { SceneCacheType, TWEEN, webglPlugin, unityPlugin, createWebglEngine, createCloudEngine, createNodeServer, createCesiumEngine, defineAnimation, definePlugin, createAnimationFromSimilarAnimation, createAnimationFromTween, createAnimationFromTweenGroup, DTEvent, EngineType };
declare const _default: {
    TWEEN: {
        Easing: {
            Linear: {
                None: (amount: number) => number;
            };
            Quadratic: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Cubic: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Quartic: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Quintic: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Sinusoidal: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Exponential: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Circular: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Elastic: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Back: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
            Bounce: {
                In: (amount: number) => number;
                Out: (amount: number) => number;
                InOut: (amount: number) => number;
            };
        };
        Group: typeof import("@tweenjs/tween.js").Group;
        Interpolation: {
            Linear: (v: number[], k: number) => number;
            Bezier: (v: number[], k: number) => number;
            CatmullRom: (v: number[], k: number) => number;
            Utils: {
                Linear: (p0: number, p1: number, t: number) => number;
                Bernstein: (n: number, i: number) => number;
                Factorial: (n: number) => number;
                CatmullRom: (p0: number, p1: number, p2: number, p3: number, t: number) => number;
            };
        };
        now: () => number;
        Sequence: typeof import("@tweenjs/tween.js").Sequence;
        nextId: typeof import("@tweenjs/tween.js").Sequence.nextId;
        Tween: typeof import("@tweenjs/tween.js").Tween;
        VERSION: string;
        getAll: () => import("@tweenjs/tween.js").Tween<Record<string, any>>[];
        removeAll: () => void;
        add: (tween: import("@tweenjs/tween.js").Tween<Record<string, any>>) => void;
        remove: (tween: import("@tweenjs/tween.js").Tween<Record<string, any>>) => void;
        update: (time?: number, preserve?: boolean) => boolean;
    };
    webglPlugin: {
        orbitControl: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/orbit-control").OrbitControlProps | undefined, {
            control: import("three/examples/jsm/controls/OrbitControls").OrbitControls;
            mode: (type: "2d" | "3d") => void;
            enabled: boolean;
            update(time: number): void;
        }, WebglCreator>;
        renderPass: import("./interface/meta").DefinedPlugin<unknown, {
            renderPass: import("three/examples/jsm/postprocessing/RenderPass").RenderPass;
        }, WebglCreator>;
        fxaaPass: import("./interface/meta").DefinedPlugin<unknown, {
            fxaaPass: import("three/examples/jsm/postprocessing/ShaderPass").ShaderPass;
        }, WebglCreator>;
        light: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/light").DTLight | import("./plugin/webgl/light").DTLight[], {
            lights: Set<import("three").Light<import("three").LightShadow<import("three").Camera> | undefined>>;
            createLight: (lights: import("./plugin/webgl/light").DTLight | import("./plugin/webgl/light").DTLight[]) => void;
            remove: (light: import("three").Light) => void;
            clear: () => void;
        }, WebglCreator>;
        skyBox: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/sky-box").SkyBoxOptions, {
            createSkybox: (p: import("./plugin/webgl/sky-box").SkyBoxOptions) => void;
            clear: () => void;
        }, WebglCreator>;
        hoverColor: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/hover-color").HoverColorOptions, {
            hover: (component: Component<WebglModel>) => void;
            blur: () => void;
            interceptor: (fn: import("./plugin/webgl/hover-color").InterceptorFn) => () => void;
            dispose(): void;
        }, WebglCreator>;
        stats: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/stats").StatsProps, {
            update: () => void;
            remove: () => void;
        }, WebglCreator>;
        color: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/color").ColorOptions | undefined, {
            set(target: string | string[] | Component<WebglModel> | Component<WebglModel>[] | import("three").Object3D | import("three").Object3D[], options?: import("./plugin/webgl/color").ColorOptions): void;
            clear(target?: string | string[] | Component<WebglModel> | Component<WebglModel>[] | import("three").Object3D | import("three").Object3D[]): void;
            dispose(): void;
        }, WebglCreator>;
        poi: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/poi").POIOptions | undefined, {
            keepVisible: boolean;
            createText: (options?: Partial<import("./interface/poi").TextPoiOptions>) => import("./interface/poi").PoiInstance<WebglModel, import("./interface/poi").TextPoiOptions>;
            createImage: (options: Partial<import("./interface/poi").ImagePoiOptions>) => import("./interface/poi").PoiInstance<WebglModel, import("./interface/poi").ImagePoiOptions>;
            createHtml: (options: Partial<import("./interface/poi").HtmlPoiOptions>) => {
                applyToComponent: (component: Component<WebglModel>, interceptor: (component: Component<WebglModel>, options: import("./interface/poi").HtmlPoiOptions) => import("./interface/poi").HtmlPoiOptions) => (import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DSprite | import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DObject)[];
                applyToPosition: (position: import("./interface/model").DTVector3) => (import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DSprite | import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DObject)[];
            };
            clearAll: () => Promise<void>;
            clear: (list: Array<Component<WebglModel> | import("./interface/model").DTVector3> | Component<WebglModel> | import("./interface/model").DTVector3) => Promise<void>;
            dispose: () => void;
            update: () => void;
            css3DRenderer: import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DRenderer;
            addEventListener: (type: string, listener: (data: {
                target: Component<WebglModel> | import("./interface/model").DTVector3;
                poi: import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DObject;
                event: MouseEvent;
            }) => void) => () => void;
        }, WebglCreator>;
        poi2d: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/poi-2d").POIOptions | undefined, {
            keepVisible: boolean;
            createText: (options?: Partial<import("./interface/poi").TextPoiOptions>) => import("./interface/poi").PoiInstance<WebglModel, import("./interface/poi").TextPoiOptions>;
            createImage: (options: Partial<import("./interface/poi").ImagePoiOptions>) => import("./interface/poi").PoiInstance<WebglModel, import("./interface/poi").ImagePoiOptions>;
            createHtml: (options: Partial<import("./interface/poi").HtmlPoiOptions>) => {
                applyToComponent: (component: Component<WebglModel>, interceptor: (component: Component<WebglModel>, options: import("./interface/poi").HtmlPoiOptions) => import("./interface/poi").HtmlPoiOptions) => import("three/examples/jsm/renderers/CSS2DRenderer").CSS2DObject[];
                applyToPosition: (position: import("./interface/model").DTVector3) => import("three/examples/jsm/renderers/CSS2DRenderer").CSS2DObject[];
            };
            clearAll: () => Promise<void>;
            clear: (list: Array<Component<WebglModel> | import("./interface/model").DTVector3> | Component<WebglModel> | import("./interface/model").DTVector3) => Promise<void>;
            dispose: () => void;
            update: () => void;
            css2DRenderer: import("three/examples/jsm/renderers/CSS2DRenderer").CSS2DRenderer;
            addEventListener: (type: string, listener: (data: {
                target: Component<WebglModel> | import("./interface/model").DTVector3;
                poi: import("three/examples/jsm/renderers/CSS2DRenderer").CSS2DObject;
                event: MouseEvent;
            }) => void) => () => void;
        }, WebglCreator>;
        lod: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/lod").LodOptions | undefined, {
            reset: (component?: Component<WebglModel>) => void;
            enable: () => void;
            disable: () => void;
            update: (component?: Component<WebglModel>) => void;
        }, WebglCreator>;
        os: import("./interface/meta").DefinedPlugin<unknown, {
            loadModelUrl: (path: string) => Promise<string>;
            enter: (path: string, hook?: (path: string) => string) => Promise<Component<WebglModel>>;
            compile: (path: string, hook?: (path: string) => string) => Promise<import("three").Object3D<import("three").Object3DEventMap>>;
            event: import("@tslfe/tacos-sdk").EventEmitter;
            connect: (options: import("@tslfe/tacos-sdk").ConnectOptions) => Promise<import("@tslfe/tacos-sdk").Core>;
            dispose: () => void;
        }, WebglCreator>;
        osV1: import("./interface/meta").DefinedPlugin<unknown, {
            loadModelUrl: (path: string) => Promise<string>;
            enter: (path: string, hook?: (path: string) => string) => Promise<Component<WebglModel>>;
            compile: (path: string, hook?: (path: string) => string) => Promise<import("three").Object3D<import("three").Object3DEventMap>>;
            event: import("@tslfe/tacos-sdk").EventEmitter;
            connect: (options: import("@tslfe/tacos-sdk").ConnectOptions) => Promise<import("@tslfe/tacos-sdk").Core>;
            dispose: () => void;
        }, WebglCreator>;
        tool: import("./interface/meta").DefinedPlugin<unknown, {
            containsComponent: (positions: import("./interface/model").DTVector3[], mode?: "all" | "x" | "y" | "z") => Component<WebglModel>[];
            buildCoordinateConvertor: (list: {
                gps: {
                    longitude: number;
                    latitude: number;
                };
                vector3: import("./interface/model").DTVector3;
            }[]) => {
                toVector3: (gpsCoordinate: {
                    longitude: number;
                    latitude: number;
                }) => {
                    x: number;
                    z: number;
                    y: number;
                };
                toGps: (vector3: import("./interface/model").DTVector3) => {
                    longitude: number;
                    latitude: number;
                };
            };
            calculateDistance: (list: import("./interface/model").DTVector3[]) => number;
            createMeasure: (position: import("./interface/model").DTVector3) => (current: import("./interface/model").DTVector3) => number;
            threeCoordinateToScreenPoint: (position: import("./interface/model").DTVector3) => {
                x: number;
                y: number;
            };
            screenPointToThreeCoordinate: (x: number, y: number) => import("three").Vector3 | null;
        }, WebglCreator>;
        path: import("./interface/meta").DefinedPlugin<undefined, {
            readonly list: import("three").Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>[];
            readonly defaultPathData: (import("./plugin/webgl/path").PathOptions & {
                data: import("./interface/model").DTVector3[];
            })[];
            create: (points: import("./interface/model").DTVector3[], options?: Partial<import("./plugin/webgl/path").PathOptions>) => import("three").Mesh<{
                type: string;
                parameters: {
                    path: import("three").Curve<any>;
                    tubularSegments: number;
                    radius: number;
                    radialSegments: number;
                    closed: boolean;
                };
                tangents: import("three").Vector3[];
                normals: import("three").Vector3[];
                binormals: import("three").Vector3[];
            } & import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").MeshBasicMaterial, import("three").Object3DEventMap>;
            transition: (points: import("./interface/model").DTVector3[], defaultOptions?: Partial<import("./plugin/webgl/path").TransitionOptions & import("./plugin/webgl/path").EditOptions>) => {
                readonly points: import("./interface/model").DTVector3[];
                readonly line: import("three").Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | undefined;
                to: (points: import("./interface/model").DTVector3[] | import("./interface/model").DTVector3, options?: Partial<import("./plugin/webgl/path").TransitionOptions>) => Promise<void>;
                back: (step: number, options?: Partial<import("./plugin/webgl/path").TransitionOptions>) => Promise<void>;
            };
            hide: (line: import("three").Mesh | import("./interface/model").DTVector3[]) => void;
            show: (line: import("three").Mesh | import("./interface/model").DTVector3[]) => void;
            remove: (line: import("three").Mesh | import("./interface/model").DTVector3[]) => void;
            edit: (points: import("./interface/model").DTVector3[], options?: Partial<import("./plugin/webgl/path").EditOptions>) => {
                readonly points: import("./interface/model").DTVector3[];
                readonly line: import("three").Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>;
                end: () => void;
                remove: (index: number) => void;
                insert: (index: number, position: import("./interface/model").DTVector3) => void;
                add: (position: import("./interface/model").DTVector3) => void;
            };
            clear: () => void;
        }, WebglCreator>;
        boxSelection: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/box-selection").BoxSelectionOptions | undefined, {
            readonly list: Component<WebglModel>[];
            start: () => void;
            clear: () => void;
            end: () => void;
            undo: (sum?: number) => void;
            dispose: () => void;
            addEventListener: (type: import("./plugin/webgl/box-selection").BoxSelectionEventType, listener: (e: DTEvent) => void) => () => void;
            _update: (force?: boolean) => void;
        }, WebglCreator>;
        picker: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/picker").PickerProps, {
            fromVector2: (position: {
                x: number;
                y: number;
            }) => Component<WebglModel>[];
            fromVector3: (position: import("./interface/model").DTVector3) => Component<WebglModel>[];
            fromMulVector3: (from: import("./interface/model").DTVector3, to: import("./interface/model").DTVector3) => Component<WebglModel>[];
            fromBrowserEvent: (event: MouseEvent) => Component<WebglModel>[];
        }, WebglCreator>;
        space: import("./interface/meta").DefinedPlugin<unknown, {
            render: (target: Component<WebglModel>, options?: {
                url?: string;
                replace?: boolean;
            }) => Promise<Component<WebglModel>>;
        }, WebglCreator>;
        threeLoader3dtiles: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/three-loader-3dtiles").loaderProps, void, WebglCreator>;
        poiv2: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/poi-v2").POIOptions | undefined, {
            keepVisible: boolean;
            createText: (options?: Partial<import("./interface/poi").TextPoiOptions>) => import("./interface/poi").PoiInstance<WebglModel, import("./interface/poi").TextPoiOptions>;
            createImage: (options: Partial<import("./interface/poi").ImagePoiOptions>) => import("./interface/poi").PoiInstance<WebglModel, import("./interface/poi").ImagePoiOptions>;
            createHtml: (options: Partial<import("./interface/poi").HtmlPoiOptions>) => {
                applyToComponent: (component: Component<WebglModel>, interceptor: (component: Component<WebglModel> | import("./interface/model").DTVector3, options: import("./interface/poi").HtmlPoiOptions) => import("./interface/poi").HtmlPoiOptions) => (import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DObject | import("three/examples/jsm/renderers/CSS2DRenderer").CSS2DObject)[];
                applyToPosition: (position: import("./interface/model").DTVector3) => (import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DObject | import("three/examples/jsm/renderers/CSS2DRenderer").CSS2DObject)[];
            };
            clearAll: () => Promise<void>;
            clear: (list: Array<Component<WebglModel> | import("./interface/model").DTVector3> | Component<WebglModel> | import("./interface/model").DTVector3) => Promise<void>;
            dispose: () => void;
            update: () => void;
            renderer: import("three/examples/jsm/renderers/CSS3DRenderer").CSS3DRenderer | import("three/examples/jsm/renderers/CSS2DRenderer").CSS2DRenderer;
            addEventListener: (type: string, listener: (data: {
                target: Component<WebglModel> | import("./interface/model").DTVector3;
                poi: import("three").Object3D;
                event: MouseEvent;
            }) => void) => () => void;
        }, WebglCreator>;
        envRoom: import("./interface/meta").DefinedPlugin<import("./plugin/webgl/env-room").HdrOptions, {
            remove: () => void;
        }, WebglCreator>;
        lightSky: import("./interface/meta").DefinedPlugin<unknown, void, WebglCreator>;
    };
    unityPlugin: {
        tool: import("./interface/meta").DefinedPlugin<unknown, {
            toScreenPoint: (position: import("./interface/model").DTVector3) => Promise<{
                x: any;
                y: any;
            }>;
            dispose: () => void;
        }, UnityCreator>;
        poi: import("./interface/meta").DefinedPlugin<unknown, {
            TemplateType: typeof import("./plugin/unity/poi").TemplateType;
            createText: (options?: Partial<import("./interface/poi").TextPoiOptions>) => import("./interface/poi").UnityPoiInstance<UnityModel, import("./interface/poi").TextPoiOptions>;
            createImage: (options: Partial<import("./interface/poi").ImagePoiOptions>) => import("./interface/poi").UnityPoiInstance<UnityModel, import("./interface/poi").ImagePoiOptions>;
            createHtml: (options: Partial<import("./interface/poi").HtmlPoiOptions>) => {
                applyToComponent: (component: Component<UnityModel>) => Promise<void>;
                applyToPosition: (position: import("./interface/model").DTVector3) => Promise<any>;
            };
            createTemplate: (options: Partial<import("./plugin/unity/poi").TemplateOptions>) => import("./interface/poi").UnityPoiInstance<UnityModel, import("./plugin/unity/poi").TemplateOptions>;
            clearAll: () => Promise<void>;
            clear: (list: Array<Component<UnityModel> | import("./interface/model").DTVector3 | string> | Component<UnityModel> | import("./interface/model").DTVector3 | string) => Promise<void>;
            update: (options: import("./interface/poi").TextPoiOptions | import("./interface/poi").ImagePoiOptions | import("./plugin/unity/poi").TemplateOptions, target: Array<Component<UnityModel> | import("./interface/model").DTVector3 | string> | Component<UnityModel> | import("./interface/model").DTVector3 | string, interceptor?: (target: Component<UnityModel> | import("./interface/model").DTVector3 | string, options: import("./interface/poi").TextPoiOptions | import("./interface/poi").ImagePoiOptions | import("./plugin/unity/poi").TemplateOptions) => import("./plugin/unity/poi").TemplateOptions) => Promise<PromiseSettledResult<string>[]>;
            dispose: () => void;
            addEventListener: (type: string, listener: (data: {
                modelId: string | undefined;
                eventType: string;
                target: Component<UnityModel> | import("./interface/model").DTVector3 | string | undefined;
            }) => void) => () => void;
        }, UnityCreator>;
        effect: import("./interface/meta").DefinedPlugin<unknown, {
            createPointEffect: (options: import("./plugin/unity/effect/point-effect").PointOptions) => Promise<{
                id: any;
                remove: () => void;
            }>;
            createAreaEffect: (options: import("./plugin/unity/effect/area-effect").AreaOptions) => Promise<{
                id: any;
                remove: () => void;
            }>;
            createLineEffect: (options: import("./plugin/unity/effect/line-effect").LineOptions) => Promise<{
                id: any;
                remove: () => void;
            }>;
            createHeatMapEffect: (options: import("./plugin/unity/effect/heatmap-effect").HeatMapOptions) => Promise<{
                id: any;
                remove: () => void;
                update: (posData: {
                    x: number;
                    y: number;
                    z: number;
                    w: number;
                }[]) => void;
                updateSetting: (setting: import("./plugin/unity/effect/heatmap-effect").HeatMapSetting) => void;
                setVisiblity: (visible: boolean) => void;
            }>;
            createTemperatureMapEffect: (options: import("./plugin/unity/effect/temperature-map-effect").TemperatureMapOptions) => Promise<{
                id: any;
                remove: () => void;
                update: (posData: {
                    x: number;
                    y: number;
                    z: number;
                    w: number;
                }[]) => void;
                setVisiblity: (visible: boolean) => void;
            }>;
            createSegmentDefenceWallEffect: (options: import("./plugin/unity/effect/segment-defence-wall-effect").SegmentDefenceWallOptions) => Promise<{
                ids: any;
                remove: () => void;
                updateColor: (walls: {
                    id: string;
                    color: string | import("./unity/model-api").UnityColor;
                }[]) => void;
            }>;
        }, UnityCreator>;
        ai: import("./interface/meta").DefinedPlugin<unknown, {
            invoke: <T>(type: import("./plugin/unity/ai").ActionType, params: T) => void;
            before: (interceptor: import("./plugin/unity/ai").BeforeInterceptor) => void;
            after: (interceptor: import("./plugin/unity/ai").BeforeInterceptor) => void;
            action: (type: import("./plugin/unity/ai").ActionType, fn: (params: any, prevFn: Function) => any) => void;
            dispose: () => void;
            ActionType: typeof import("./plugin/unity/ai").ActionType;
        }, UnityCreator>;
        robot: import("./interface/meta").DefinedPlugin<import("./plugin/unity/robot").RobotProps, {
            update: (component: Component<UnityModel>, params: import("./unity/model").UpdateModelParams & {
                position: Omit<import("./interface/model").DTVector3, "z">;
            }) => void;
        }, UnityCreator>;
    };
    createWebglEngine: typeof createWebglEngine;
    createCloudEngine: typeof createCloudEngine;
    createNodeServer: typeof createNodeServer;
    createCesiumEngine: typeof createCesiumEngine;
    defineAnimation: typeof defineAnimation;
    definePlugin: typeof definePlugin;
    createAnimationFromSimilarAnimation: typeof createAnimationFromSimilarAnimation;
    createAnimationFromTween: typeof createAnimationFromTween;
    createAnimationFromTweenGroup: typeof createAnimationFromTweenGroup;
    DTEvent: typeof DTEvent;
    EngineType: typeof EngineType;
};
export default _default;
