vis-core 0.30.0-beta.63 → 0.30.0-beta.70

package/dist/index.d.ts

@@ -1,12 +1,1776 @@
-import '@/styles/vis.css';
-import './fix';
-export * as TWEEN from '@tweenjs/tween.js';
-export * from "./vis/index";
-export * from "./vis/map/MapManager";
-export * as THREE from 'three';
-export * from './getVisConfig';
-export * as animationUtils from './utils/animation';
-export declare const access: {
-    token: string;
-};
-export declare const VERSION = "0.30.0-beta.63";
+import { BaseObject } from 'gl-draw';
+import { ConicPolygon } from 'gl-draw';
+import { default as default_2 } from 'gl-draw';
+import { EventEmitter } from 'events';
+import { ExtrudePolygon } from 'gl-draw';
+import { FeatureCollection } from 'geojson';
+import { GeoJsonProperties } from 'geojson';
+import { GeoProjection } from 'd3-geo';
+import { Group } from 'gl-draw';
+import { Lead } from 'gl-draw';
+import { Light as Light_2 } from 'gl-draw';
+import { Line } from 'gl-draw';
+import { Line2 } from 'gl-draw';
+import { Listener } from 'events';
+import { MeshLineMaterial } from 'gl-draw';
+import { MultiPolygon } from 'geojson';
+import { Node as Node_2 } from 'gl-draw';
+import { PickFunctionsItem } from 'gl-draw';
+import { Polygon } from 'geojson';
+import { Position } from 'geojson';
+import { RoomEnvironment } from 'three/examples/jsm/environments/RoomEnvironment.js';
+import * as THREE from 'three';
+import * as TWEEN from '@tweenjs/tween.js';
+import { Water } from './Water2';
+
+export declare const access: {
+    token: string;
+};
+
+export declare namespace animationUtils {
+    export {
+        timeOut,
+        sinusoidalInOut,
+        baseObjectFadeIn,
+        baseObjectFadeOut,
+        baseObjectBounceIn,
+        baseObjectBounce
+    }
+}
+
+declare class Arc extends BaseObject {
+    options: Options_4;
+    line: Line;
+    helperMeshPosition?: THREE.Vector3[];
+    constructor(options: Options_4);
+    static getInitOptions(pencil: default_2, options: Options_4): {
+        from: THREE.Vector3Tuple;
+        to: THREE.Vector3Tuple;
+    };
+    create(): Promise<void>;
+    instantiate(ops?: any): Promise<this>;
+    setPath(from: THREE.Vector3 | number[], to: THREE.Vector3 | number[], radius: number, setPointWidth?: (p: number) => number): void;
+    pickTube: Tube | null;
+    addPickTarget(radius?: number, show?: boolean): Promise<Tube>;
+    onPointerEvent(...args: Parameters<BaseObject['onPointerEvent']>): void;
+    setColor(color: string): void;
+    animateIn({ duration, delay, repeat, onComplete, onRepeat, }?: {
+        duration?: number;
+        delay?: number;
+        repeat?: number;
+        onComplete?: (...args: any[]) => void;
+        onRepeat?: (count: number) => void;
+    }): void;
+    update(): void;
+    render(): void;
+    dispose(): void;
+}
+
+declare class Area extends BaseObject {
+    options: Options_10;
+    area: ExtrudePolygon[];
+    constructor(options: Options_10);
+    create(): Promise<void>;
+}
+
+export declare class Base extends Camera {
+    static VisName: string;
+    playing: boolean;
+    leftTruck: boolean;
+    options: BaseOptions;
+    showState: boolean;
+    settings: Record<string, any>;
+    delLoadArr?: string[];
+    extendsOptions: Record<string, any>;
+    leadObjs: {
+        Plane: Plane;
+        CrossPlane: CrossPlane;
+        PlaneShadow: PlaneShadow;
+        Ring: Ring;
+        Sphere: Sphere;
+        Sprite: Sprite;
+        Tetrahedron: Tetrahedron;
+        Torus: Torus;
+        TorusKnot: TorusKnot;
+        Tube: Tube;
+        Box: Box;
+        Capsule: Capsule;
+        Circle: Circle;
+        Cylinder: Cylinder;
+        Dodecahedron: Dodecahedron;
+        Icosahedron: Icosahedron;
+        Lathe: Lathe;
+        Octahedron: Octahedron;
+        Node: typeof Node_2;
+        Line: typeof Line;
+        Line2: Line2;
+        ExtrudePolygon: ExtrudePolygon;
+        ConicPolygon: ConicPolygon;
+        Group: Group;
+        Light: Light;
+        Point: Point;
+        Arc: typeof Arc;
+        Model: Model;
+    };
+    lead: Lead<typeof objs>;
+    mList: default_2['mList'];
+    tier0: boolean;
+    pmremGenerator: THREE.PMREMGenerator | null;
+    re: RoomEnvironment | null;
+    roomEnvMap?: THREE.Texture;
+    visName: string;
+    editor?: Editor;
+    publicDir: Record<string, string>;
+    constructor(options: BaseOptions);
+    private showDetectRes;
+    setOptions(options: Record<string, any>): void;
+    _baseObjectByUuid: Editor['baseObjectByUuid'];
+    _objectByUuid: Editor['objectByUuid'];
+    get fromJSON(): (jsonOrUrl: Record<string, any> | string, hooks?: Record<string, any>) => Promise<Record<string, any>>;
+    get baseObjectByUuid(): {
+        (key: `arc${string}`): Arc;
+        (key: `sprite${string}`): Sprite;
+        (key: string): BaseObject;
+    };
+    get objectByUuid(): (key: string) => THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
+    get getDataURL(): () => string;
+    loaderAdd(...args: any): void;
+    initMaterial(...args: any): Promise<void>;
+    initVis(...args: any): Promise<void>;
+    init(...args: any[]): Promise<void>;
+    private observeScale;
+    initPencil(): Promise<void>;
+    private sceneActive;
+    setSceneActive(): void;
+    initCameraUserData(): void;
+    initSceneUserData(): void;
+    initBaseObjectUserData(baseObject: BaseObject): void;
+    addCSS3DRenderer(container?: HTMLElement): void;
+    initSettingsObj?: Record<string, any>;
+    mouseButtonsActiveStore: Record<string, any> | null;
+    initSettings(): void;
+    handleSetting(key: string, value: any): Promise<any>;
+    show(): void;
+    showAction(): void;
+    hide(): void;
+    addGroup(): Promise<Group>;
+    addCSS2D(dom: HTMLElement, options?: {
+        display?: string;
+        onTop?: number;
+        target?: BaseObject;
+    }): Promise<Node_2>;
+    addCSS3D(dom: HTMLElement, options?: {
+        display?: string;
+        onTop?: number;
+        type?: '3d' | '3dSprite';
+        target?: BaseObject;
+    }): Promise<Node_2>;
+    getRoomEnvMap(): THREE.Texture<unknown>;
+    handlePick(objArr: PickFunctionsItem['objArr'], type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): void;
+    getScreenPosition(x: number, y: number, z: number): {
+        x: number;
+        y: number;
+    };
+    dispose(): void;
+}
+
+declare const baseObjectBounce: (obj: BaseObject, up: string | undefined, to: number) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<any>;
+    stop: () => void;
+};
+
+declare const baseObjectBounceIn: (obj: BaseObject, up?: string) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<any>;
+    stop: () => void;
+};
+
+declare const baseObjectFadeIn: (obj: BaseObject) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<any>;
+    stop: () => void;
+};
+
+declare const baseObjectFadeOut: (obj: BaseObject) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<any>;
+    stop: () => void;
+};
+
+declare interface BaseOptions {
+    container: HTMLElement;
+    assetsPrefix?: string;
+    css2DContainer?: HTMLElement;
+    controlsContainer?: HTMLElement;
+    pencil?: any;
+    pencil2?: any;
+    pencilConfig?: Record<string, any>;
+    disableInitShow?: boolean;
+    editor?: boolean;
+    logarithmicDepthBuffer?: boolean;
+    tier?: number;
+    observeParentScale?: boolean;
+    [key: string]: any;
+}
+
+declare class Box extends BaseObject {
+    create(): void;
+}
+
+declare class Building extends BaseObject {
+    options: Options_8;
+    constructor(options: Options_8);
+    create(): Promise<void>;
+    worldPositionZ: {
+        value: number;
+    };
+    sideGradient(color?: string, maxGradientHeight?: number): void;
+    update(): void;
+}
+
+declare class Camera extends Event_2 {
+    container: HTMLElement;
+    pencil: default_2;
+    cameraState: Record<string, number[]>;
+    setSaveCamera(type: string): void;
+    useSaveCamera(type: string, enableTransition?: boolean): Promise<boolean>;
+    lookAt(positionX: number, positionY: number, positionZ: number, targetX: number, targetY: number, targetZ: number, enableTransition?: boolean, smoothTime?: number): Promise<void>;
+    truck(x: number, y: number, enableTransition?: boolean, smoothTime?: number): Promise<void>;
+    dollyTo(distance: number | `+=${number}` | `-=${number}` | `*=${number}` | `/=${number}`, enableTransition?: boolean, smoothTime?: number): Promise<void>;
+    absoluteAngle(targetAngle: number, sourceAngle: number): number;
+    lookAtTarget(ops: {
+        target?: THREE.Vector3;
+        distance?: number;
+        polarAngle?: number;
+        azimuthAngle?: number;
+    }, enableTransition?: boolean, smoothTime?: number): Promise<void>;
+    paddingInCssPixel(obj: BaseObject, top: number, right: number, bottom: number, left: number, enableTransition: boolean): Promise<void[]>;
+    resetCamera(enableTransition?: boolean, smoothTime?: number): Promise<void>;
+    unproject(e: MouseEvent, targetZ?: number): THREE.Vector3;
+    dispose(): void;
+}
+
+declare class Capsule extends BaseObject {
+    create(): void;
+}
+
+declare class Circle extends BaseObject {
+    create(): void;
+}
+
+export declare class City extends Base {
+    static VisName: string;
+    leadObjs: {
+        Building: typeof Building;
+        Road: typeof Road;
+        Area: Area;
+        CityPlane: CityPlane;
+        Target: Target;
+        Plane: Plane;
+        CrossPlane: CrossPlane;
+        PlaneShadow: PlaneShadow;
+        Ring: Ring;
+        Sphere: Sphere;
+        Sprite: Sprite;
+        Tetrahedron: Tetrahedron;
+        Torus: Torus;
+        TorusKnot: TorusKnot;
+        Tube: Tube;
+        Box: Box;
+        Capsule: Capsule;
+        Circle: Circle;
+        Cylinder: Cylinder;
+        Dodecahedron: Dodecahedron;
+        Icosahedron: Icosahedron;
+        Lathe: Lathe;
+        Octahedron: Octahedron;
+        Node: Node_2;
+        Line: Line;
+        Line2: Line2;
+        ExtrudePolygon: ExtrudePolygon;
+        ConicPolygon: ConicPolygon;
+        Group: typeof Group;
+        Light: Light;
+        Point: Point;
+        Arc: Arc;
+        Model: Model;
+    };
+    lead: Lead<typeof objs_2>;
+    adcode: number;
+    pcenter: [number, number];
+    pscale: number;
+    projection: ReturnType<typeof getProjection>;
+    options: CityOptions;
+    group: Group;
+    building: Building;
+    road: Road;
+    setOptions(options: CityOptions): void;
+    multiplyScalar: number;
+    loaderAdd(): void;
+    initMaterial(): Promise<void>;
+    disableSSAO(): void;
+    enabledSSAO(): void;
+    init(): Promise<void>;
+    getInvert(vector3: THREE.Vector3): [number, number] | null | undefined;
+    fitTo(obj: BaseObject, enableTransition?: boolean): Promise<void>;
+    initVis(): Promise<void>;
+    drawCityPlane(adcode: number, target?: BaseObject): Promise<void>;
+    drawBuilding(options?: {
+        jsonUrl?: string;
+        meters?: number;
+        grey?: boolean;
+        sideGradient?: boolean;
+        hasSide?: boolean;
+    }): Promise<Building | undefined>;
+    drawArea(options?: {
+        jsonUrl?: string;
+        type?: 'river' | 'grassland';
+        oArr?: number[];
+        grey?: boolean;
+    }): Promise<Area | undefined>;
+    drawRoad(options?: {
+        jsonUrl?: string;
+        meters?: number;
+        z?: number;
+        grey?: boolean;
+    }): Promise<Road | undefined>;
+    getWorldPosition(longitude: number, latitude: number): {
+        x: number;
+        y: number;
+    };
+}
+
+declare class city extends City {
+    multiplyScalar: number;
+    fixNearFar(n?: number, f?: number): void;
+}
+
+declare interface CityOptions extends BaseOptions {
+    adcode: number;
+    jsonName: string;
+    cacheKey?: string;
+    center?: [number, number];
+    fitTo?: boolean;
+    coordtransformFunc?: (lng: number, lat: number) => {
+        longitude: number;
+        latitude: number;
+    };
+    plane?: boolean;
+    grey?: boolean;
+    showBuilding?: boolean;
+    buildingSideGradient?: boolean;
+    buildingHasSide?: boolean;
+    showRoad?: boolean;
+    showGrassland?: boolean;
+    showRiver?: boolean;
+    setWaterMaterial?: boolean;
+    ssao?: boolean;
+}
+
+declare class CityPlane extends BaseObject {
+    options: Options_11;
+    constructor(options: Options_11);
+    plane: THREE.PlaneGeometry;
+    water?: Water;
+    create(): Promise<void>;
+    addWater(): void;
+}
+
+declare class Config {
+    editor: Editor;
+    meta: {
+        name: string;
+        key: string;
+        open: boolean;
+        jsonVersion: string;
+        sdkVersion: string;
+        __template: string;
+    };
+    constructor(editor: Editor);
+    setConfig<K extends keyof Config['meta']>(key: K, value: Config['meta'][K]): void;
+    fromJSON(json: any): void;
+    compareVersion(): void;
+    toJSON(): {
+        version: string;
+    };
+}
+
+declare class ContinentsBg extends BaseObject {
+    options: Options_15;
+    mapArr: PlaneMap[];
+    constructor(options: Options_15);
+    create(): Promise<void>;
+    private getPointInContinentInfo;
+    getPointInContinent(location: [number, number]): boolean;
+    getLocationPosition(location: [number, number], tName?: string): [number, number, number] | undefined;
+    render(): void;
+    dispose(): void;
+}
+
+declare class CrossPlane extends BaseObject {
+    options: Options;
+    constructor(options: Options);
+    create(): Promise<void>;
+}
+
+declare class Cylinder extends BaseObject {
+    create(): void;
+}
+
+declare class Dodecahedron extends BaseObject {
+    create(): void;
+}
+
+export declare class Earth extends Base {
+    static VisName: string;
+    leadObjs: {
+        Earth: Earth_2;
+        SphereShadow: SphereShadow;
+        Countries: typeof PlaneMap;
+        Plane: Plane;
+        CrossPlane: CrossPlane;
+        PlaneShadow: PlaneShadow;
+        Ring: Ring;
+        Sphere: Sphere;
+        Sprite: Sprite;
+        Tetrahedron: Tetrahedron;
+        Torus: Torus;
+        TorusKnot: TorusKnot;
+        Tube: Tube;
+        Box: Box;
+        Capsule: Capsule;
+        Circle: Circle;
+        Cylinder: Cylinder;
+        Dodecahedron: Dodecahedron;
+        Icosahedron: Icosahedron;
+        Lathe: Lathe;
+        Octahedron: Octahedron;
+        Node: Node_2;
+        Line: Line;
+        Line2: Line2;
+        ExtrudePolygon: ExtrudePolygon;
+        ConicPolygon: ConicPolygon;
+        Group: Group;
+        Light: Light;
+        Point: Point;
+        Arc: Arc;
+        Model: Model;
+    };
+    leftTruck: boolean;
+    lead: Lead<typeof objs_3>;
+    options: Required<EarthOptions>;
+    extendsOptions: Record<string, any>;
+    map: PlaneMap;
+    get mapArea(): ExtrudePolygon[];
+    setOptions(options: EarthOptions): void;
+    handleSetting(key: string, value: any): Promise<any>;
+    show(): void;
+    animationIn(): void;
+    initLight(): Promise<void>;
+    getLocationPosition(location: [number, number], dr?: number): [number, number, number];
+    setAreaMaterialByProperty(key: string, value: any, ops: {
+        color?: string;
+        emissive?: string;
+        emissiveIntensity?: number;
+    } | 'origin'): void;
+    setLineMaterialByProperty(key: string, value: any, ops: {
+        color?: string;
+        width?: number;
+    } | 'origin'): void;
+    addAreaPlaneByProperty(key: string, value: any, options: {
+        area: ConstructorParameters<typeof THREE.MeshBasicMaterial>[0];
+        line: ConstructorParameters<typeof MeshLineMaterial>[0];
+    }): Promise<PlaneMap | undefined>;
+    getRadius(): number;
+    checkBehindEarth(objArr: () => BaseObject[], cb: (obj: BaseObject[], res: boolean[]) => any): void;
+    /**
+     * 设置物体在球面上的位置和旋转，使其垂直于球面
+     * @param object - 要设置的物体
+     * @param location - 经纬度 [经度, 纬度]
+     * @param height - 距离球面的高度，默认为0
+     * @param upAxis - 物体的up轴方向，默认为Y轴 [0, 1, 0]
+     */
+    setObjectOnSphere(baseObject: BaseObject, location: [number, number], height?: number, upAxis?: [number, number, number]): void;
+}
+
+declare class Earth_2 extends Sphere {
+    options: Required<Options_12>;
+    constructor(options: Options_12);
+    create(): void;
+}
+
+declare interface EarthOptions extends BaseOptions {
+    mapDepth?: number;
+    otherMapDepth?: number;
+    radius?: number;
+    copyChinaPlane?: boolean;
+    mergeSide?: boolean;
+    style?: 'chinaPlate' | 'countryPlate' | 'base';
+}
+
+declare class Editor {
+    selected: BaseObject | null;
+    playing: boolean;
+    currentMaterialSlot: number;
+    events: EventEmitter;
+    history: History_2;
+    viewport: Viewport;
+    hooks: Hooks;
+    config: Config;
+    pencil: default_2;
+    on: (type: string | number, listener: Listener) => EventEmitter;
+    emit: (type: string | number, ...args: any[]) => boolean;
+    options: Options_7;
+    constructor(options: Options_7);
+    getObjectMaterial(object?: THREE.Mesh | null, slot?: number): THREE.Material | THREE.Material[] | undefined;
+    getMListFixBaseObjectByObject(object: THREE.Mesh, slot: number): any;
+    materialObjectByUuid(uuid: string): any;
+    uuidByMaterialObject(object: THREE.Object3D): any;
+    setObjectMaterial(object: THREE.Mesh, slot: number, newMaterial: THREE.Material): void;
+    uuidByObject(object: THREE.Object3D): string | undefined;
+    objectByUuid(key: string): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
+    uuidByBaseObject(object: BaseObject): string | undefined;
+    baseObjectByUuid(key: `arc${string}`): Arc;
+    baseObjectByUuid(key: `sprite${string}`): Sprite;
+    baseObjectByUuid(key: string): BaseObject;
+    private _selectOptionMaps;
+    findSelectItem(key: any, val: any): SelectedMeta | undefined;
+    selectOption: SelectedMeta[];
+    changeSelectOption(): void;
+    private _buildCacheMapsRecursively;
+    private _mListOptionsMaps;
+    findMListSelectItem(key: any, val: any): any;
+    mListOptions: {
+        key: string;
+        name: string;
+        type: string;
+        use: number;
+        object: THREE.Mesh;
+        material: THREE.Material;
+        baseObject: BaseObject;
+    }[];
+    changeMListOptions(): never[] | undefined;
+    execute(cmd: any, optionalName?: string): Promise<void>;
+    private static urlCache;
+    private static _loadingCount;
+    /**
+     * 清除特定 URL 的缓存
+     * @param url 要清除的 URL，如果不提供则清除所有缓存
+     */
+    static clearUrlCache(url?: string): void;
+    fromJSON(jsonOrUrl: Record<string, any> | string, hooks?: Record<string, any>): Promise<Record<string, any>>;
+    appendJSON(jsonOrUrl: Record<string, any> | string): Promise<void>;
+    toJSON(): {};
+    select(...args: any[]): void;
+    setViewportVis(...args: any[]): void;
+    getDataURL(): string;
+    _dispose: boolean;
+    dispose(): void;
+}
+
+declare class Event_2 {
+    event: EventEmitter;
+    private eventHandlers;
+    on: (type: string | number, listener: Listener) => EventEmitter;
+    emit: (type: string | number, ...args: any[]) => boolean;
+    addListener(node: HTMLElement, event: string, handler: (e: MouseEvent) => void, capture?: boolean): void;
+    removeListener(targetNode: HTMLElement | '', event: string): void;
+    removeAllListeners(): void;
+    dispose(): void;
+}
+
+declare const findAdcodeInfo: (adcode: number) => {
+    adcode: number;
+    lng: number;
+    lat: number;
+    name: string;
+    level: string;
+    parent: number;
+    c: number[];
+    b: number[];
+} | undefined;
+
+export declare interface FixConfig {
+    [key: `${string}`]: {
+        s: string[];
+        z: string[];
+    };
+}
+
+declare type GeoJSON_2 = FeatureCollection<Polygon | MultiPolygon>;
+
+declare type GeoJSON_3 = FeatureCollection<Polygon | MultiPolygon>;
+
+declare type GeoJSON_4 = FeatureCollection<Polygon | MultiPolygon>;
+
+/**
+ * 获取城市配置
+ * @param adcode 区域代码
+ */
+export declare const getCityConfig: (adcode: number) => {
+    center: number[];
+    adcode: number;
+    jsonName: string;
+};
+
+/**
+ * 获取地图配置
+ * @param adcode 区域代码
+ * @param base 基础URL
+ * @param prevConfig 之前的配置
+ * @param imgArr 图像数组
+ */
+export declare const getMapConfig: (adcode: number, base?: string, prevConfig?: any, imgArr?: string[] | Record<string, string>) => Promise<any>;
+
+declare const getProjection: (options: {
+    center: [number, number];
+    scale: number;
+    projectionType?: "equirectangular" | "mercator" | "winkel3";
+    translate?: [number, number];
+    precision?: number;
+    rotate?: [number, number];
+}) => GeoProjection;
+
+declare const getProjection_2: (options: {
+    center: [number, number];
+    scale: number;
+    projectionType?: "equirectangular" | "mercator" | "winkel3";
+    translate?: [number, number];
+    precision?: number;
+    rotate?: [number, number];
+}) => GeoProjection;
+
+declare class History_2 {
+    editor: Editor;
+    undos: any[];
+    redos: any[];
+    lastCmdTime: number;
+    idCounter: number;
+    historyDisabled: boolean;
+    constructor(editor: Editor);
+    /**
+     * 检查两个命令是否可以合并
+     */
+    private canMergeCommands;
+    execute(cmd: any, optionalName?: string): Promise<void>;
+    undo(): any;
+    redo(): any;
+    /**
+     * 处理图片数据，将ArrayBuffer转换为Base64字符串并建立引用映射
+     */
+    private processImageData;
+    /**
+     * 处理包含图片的命令
+     */
+    private processCommandWithImages;
+    toJSON(): {
+        u: any[];
+        i: Record<string, string>;
+    };
+    /**
+     * 处理图片引用，将引用字符串还原为实际URL或数据
+     */
+    private processImageReference;
+    /**
+     * 还原包含图片的命令数据
+     */
+    private restoreCommandImages;
+    /**
+     * 验证和规范化命令类型
+     */
+    private normalizeCommandType;
+    /**
+     * 创建命令实例
+     */
+    private createCommand;
+    fromJSON(json: any): void;
+    /**
+     * 批量处理撤销操作，支持分帧执行以避免阻塞UI
+     */
+    processUndos(maxFrameTime?: number): Promise<string>;
+    /**
+     * 执行单个撤销命令
+     */
+    private executeUndo;
+    /**
+     * 清空所有历史记录
+     */
+    clear(): void;
+    /**
+     * 获取历史记录状态信息
+     */
+    getState(): {
+        undoCount: number;
+        redoCount: number;
+        canUndo: boolean;
+        canRedo: boolean;
+        isDisabled: boolean;
+    };
+    /**
+     * 启用/禁用历史记录功能
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * 获取最后执行的命令
+     */
+    getLastCommand(): any;
+}
+
+declare class Hooks {
+    editor: Editor;
+    events: {
+        beforeSetVisOptions: Function[];
+        afterSetVisOptions: Function[];
+        beforeExecuteUndo: Function[];
+        afterExecuteUndo: Function[];
+        beforeShow: Function[];
+        afterShow: Function[];
+        beforeFromJSON: Function[];
+        afterFromJSON: Function[];
+        errorFromJSON: Function[];
+    };
+    source: string;
+    constructor(editor: Editor);
+    addEvents(event: Record<string, Function>): void;
+    addStaticEvents(func: Function): void;
+    fromJSON(source: string): void;
+    toJSON(): string;
+    clear(): void;
+    dispatch(type: keyof Hooks['events'], ...args: any[]): any;
+}
+
+declare class Icosahedron extends BaseObject {
+    create(): void;
+}
+
+declare class Lathe extends BaseObject {
+    create(): void;
+}
+
+declare class Light extends Light_2 {
+    constructor(options: any);
+    update(delta: number, elapsed: number): void;
+    render(): void;
+}
+
+declare class Map_2 extends Base {
+    static VisName: string;
+    leadObjs: {
+        PlaneMap: typeof PlaneMap;
+        CityPlane: CityPlane;
+        ContinentsBg: typeof ContinentsBg;
+        Mountain: PlaneMap_2;
+        Plane: Plane;
+        CrossPlane: CrossPlane;
+        PlaneShadow: PlaneShadow;
+        Ring: Ring;
+        Sphere: Sphere;
+        Sprite: Sprite;
+        Tetrahedron: Tetrahedron;
+        Torus: Torus;
+        TorusKnot: TorusKnot;
+        Tube: Tube;
+        Box: Box;
+        Capsule: Capsule;
+        Circle: Circle;
+        Cylinder: Cylinder;
+        Dodecahedron: Dodecahedron;
+        Icosahedron: Icosahedron;
+        Lathe: Lathe;
+        Octahedron: Octahedron;
+        Node: Node_2;
+        Line: Line;
+        Line2: Line2;
+        ExtrudePolygon: typeof ExtrudePolygon;
+        ConicPolygon: ConicPolygon;
+        Group: typeof Group;
+        Light: Light;
+        Point: Point;
+        Arc: Arc;
+        Model: Model;
+    };
+    lead: Lead<typeof objs_4>;
+    options: Required<MapCityOptions>;
+    mapHistory: {
+        map: PlaneMap;
+        mapInfo: NonNullable<ReturnType<typeof findAdcodeInfo>>;
+        z: number;
+        cX: number;
+        cY: number;
+        depth: number;
+        controls?: {
+            lookAt: [number, number, number, number, number, number];
+            polarAngle: number;
+            azimuthAngle: number;
+        };
+        userControls?: {
+            lookAt: [number, number, number, number, number, number];
+            polarAngle: number;
+            azimuthAngle: number;
+        };
+    }[];
+    get mapObj(): {
+        map: PlaneMap;
+        mapInfo: NonNullable<ReturnType<typeof findAdcodeInfo>>;
+        z: number;
+        cX: number;
+        cY: number;
+        depth: number;
+        controls?: {
+            lookAt: [number, number, number, number, number, number];
+            polarAngle: number;
+            azimuthAngle: number;
+        };
+        userControls?: {
+            lookAt: [number, number, number, number, number, number];
+            polarAngle: number;
+            azimuthAngle: number;
+        };
+    };
+    get map(): PlaneMap;
+    get mapInfo(): {
+        adcode: number;
+        lng: number;
+        lat: number;
+        name: string;
+        level: string;
+        parent: number;
+        c: number[];
+        b: number[];
+    };
+    get mapArea(): ExtrudePolygon[];
+    get mapLine(): Line[];
+    get adcodes(): number[];
+    activePlaneMap: PlaneMap | null;
+    isAnimating: boolean;
+    parentBg: PlaneMap[];
+    continentsBg?: ContinentsBg;
+    group: Group;
+    projection: ReturnType<typeof getProjection_2>;
+    pcenter: [number, number];
+    pscale: number;
+    meters: number;
+    cityVis: city[];
+    extendsOptions: Record<string, any>;
+    setOptions(options: MapOptions): void;
+    initSettingsObj: Record<string, any>;
+    handleSetting(key: string, value: any): Promise<any>;
+    init(): Promise<void>;
+    initCityVis(adcode: number, grey?: boolean): Promise<city>;
+    initCityOnMap(adcode: number): Promise<void>;
+    initVisBg(): Promise<void>;
+    initVis(adcode: number): Promise<void>;
+    loaderAddBg(): void;
+    initMaterialBg(): Promise<void>;
+    consoleMousePostion(): void;
+    setAreaMaterialByProperty(key: string, value: any, ops: {
+        color?: string;
+        emissive?: string;
+        emissiveIntensity?: number;
+    } | 'origin'): void;
+    setLineMaterialByProperty(key: string, value: any, ops: {
+        color?: string;
+        width?: number;
+    } | 'origin'): void;
+    addAreaPlaneByProperty(key: string, value: any, options: {
+        material?: ConstructorParameters<typeof THREE.MeshBasicMaterial>[0];
+        lineMaterial?: ConstructorParameters<typeof MeshLineMaterial>[0];
+        sideMaterial?: ConstructorParameters<typeof THREE.MeshBasicMaterial>[0];
+        depth?: number;
+        lineBloom?: boolean;
+        topSegments?: number;
+        area?: string;
+        line?: string;
+    }): Promise<PlaneMap | undefined>;
+    caId: string | number | undefined;
+    showAction(): Promise<void>;
+    hide(): Promise<void>;
+    shadowMapLight?: BaseObject;
+    planeShadow?: BaseObject;
+    shadowMapEnabled(): Promise<void>;
+    shadowMapDisabled(): void;
+    getOptionsDepth(adcode: number): number;
+    getDepth(adcode: number, futureBox: number[]): number;
+    getReferenceScale(bboxa: number[], bboxb: number[]): number;
+    getAdcodeShowLevel(adcode: number, fix?: boolean): string | undefined;
+    handleClick(area?: ExtrudePolygon): void;
+    beforeShowMap(adcodes: number[]): boolean;
+    getAdcodes(adcode: number): number[];
+    showMap({ adcode, adcodes: prevAdcodes, duration, }: {
+        adcode?: number;
+        adcodes?: number[];
+        duration?: number;
+    }): Promise<void>;
+    drawLabels(): Promise<void>;
+    eraseLabels(): void;
+    geAdcodePosition(adcode: number): [number, number, number] | undefined;
+    getLocationPosition(location: [number, number]): [number, number, number];
+    /**
+     * 设置物体在平面地图上的位置
+     * @param object - 要设置的物体
+     * @param location - 经纬度 [经度, 纬度]
+     * @param height - 距离地图平面的高度，默认为0
+     */
+    setObjectOnMap(object: BaseObject, location: [number, number], height?: number): void;
+    setObjectOnMapAreaByProperty(object: BaseObject, key: string, value: any, height?: number): void;
+    getAdcodeScreenPosition(adcode: number): {
+        x: number;
+        y: number;
+    } | undefined;
+    booleanPointInCn(location: [number, number]): boolean;
+    /**
+     * 判断经纬度是否在当前地图板块内
+     * @param location - 经纬度坐标 [经度, 纬度]
+     * @param adcode - 可选，指定板块的行政区划代码，不传则使用当前地图的adcode
+     * @returns 是否在板块内
+     */
+    booleanPointInMap(location: [number, number], adcode?: number): boolean;
+    private getGeojson;
+    handleDrillDown({ adcode, duration, handleLook, saveBackCamvasState, extrudelineBloom, }: {
+        adcode: number;
+        duration?: number;
+        handleLook?: boolean;
+        saveBackCamvasState?: boolean;
+        extrudelineBloom?: boolean;
+    }): Promise<void>;
+    saveCamvasState(type: 'userControls' | 'controls', index: number): void;
+    fixNear(adcode: number): void;
+    fitTo(obj?: BaseObject, { polarAngle, azimuthAngle, z, handleStart, adcode, enableTransition, }?: {
+        adcode?: number;
+        polarAngle?: number;
+        azimuthAngle?: number;
+        enableTransition?: boolean;
+        z?: number;
+        handleStart?: () => void;
+    }): Promise<void>;
+    drawPlaneMap({ geojson, extrudeLineGeojson, bbox, depth, extrudelineBloom, adcode, }: {
+        geojson: GeoJSON_4;
+        extrudeLineGeojson?: GeoJSON_4;
+        bbox?: number[];
+        depth: number;
+        adcode: number;
+        extrudelineBloom?: boolean;
+    }): Promise<PlaneMap>;
+    handleBack({ duration, handleLookBack, keepOne, }?: {
+        duration?: number | undefined;
+        handleLookBack?: boolean | undefined;
+        keepOne?: boolean | undefined;
+    }): Promise<void>;
+    handleLookBack(duration?: number): Promise<void>;
+    compareLocations(currentO: any[], destinationO: any[]): number[];
+    setAdcode({ adcodes, duration, }: {
+        adcodes: number[];
+        duration?: number;
+    }): Promise<void>;
+    setPadding(padding: number[], fitTo?: boolean, enableTransition?: boolean): void;
+    findAdcodeInfo(adcode: number): {
+        adcode: number;
+        lng: number;
+        lat: number;
+        name: string;
+        level: string;
+        parent: number;
+        c: number[];
+        b: number[];
+    } | undefined;
+    dispose(): void;
+}
+export { Map_2 as Map }
+
+declare interface MapCityOptions extends MapOptions {
+    cacheCity?: boolean;
+    nearbyCities?: boolean | 'full';
+    showBuilding?: boolean;
+    buildingSideGradient?: boolean;
+    showRoad?: boolean;
+    showGrassland?: boolean;
+    showRiver?: boolean;
+    setWaterMaterial?: boolean;
+    showCityOnMapInnerLine?: boolean;
+    bloom?: boolean;
+    citySSAO?: boolean;
+}
+
+export declare interface MapEventHandlers {
+    [key: string]: (...args: any[]) => void;
+}
+
+/**
+ * MapManager - 地图管理类
+ */
+export declare class MapManager {
+    private container;
+    private controlsContainer?;
+    private assetsPrefix?;
+    private fixConfig?;
+    private raycasterPointsThreshold;
+    private readonly MAX_ZOOM_FACTOR;
+    private readonly MIN_ZOOM_FACTOR;
+    private mapInstances;
+    private mapDistances;
+    private mapConfigs;
+    private currentMap;
+    private currentZoom;
+    private mapPadding;
+    private isInitializing;
+    private rmTemplateIdentifier;
+    private geojsonExtensions;
+    private groups;
+    private eventHandlers;
+    private areaCloseTimer;
+    static findAdcodeInfoByName: (name: string) => {
+        adcode: number;
+        lng: number;
+        lat: number;
+        name: string;
+        level: string;
+        parent: number;
+        c: number[];
+        b: number[];
+    } | undefined;
+    static getAdcodeShowLevel: (adcode: number, fix?: boolean) => string | undefined;
+    static findAdcodeInfo: (adcode: number) => {
+        adcode: number;
+        lng: number;
+        lat: number;
+        name: string;
+        level: string;
+        parent: number;
+        c: number[];
+        b: number[];
+    } | undefined;
+    static extendsAdcodeAll: (cb: any) => void;
+    constructor(config: MapManagerConfig);
+    /**
+     * 设置事件处理器
+     */
+    setEventHandlers(handlers: MapEventHandlers): void;
+    /**
+     * 触发事件
+     */
+    emit<K extends keyof MapEventHandlers>(eventName: K, ...args: Parameters<MapEventHandlers[K]>): void;
+    /**
+     * 获取当前地图实例
+     */
+    getCurrentMap(): Map_2 | null;
+    /**
+     * 获取当前缩放级别
+     */
+    getCurrentZoom(): number;
+    /**
+     * 初始化地图
+     */
+    initMap(adcodeArr: number[], fixedAdcode?: boolean): Promise<Map_2 | null | undefined>;
+    /**
+     * 创建地图实例
+     */
+    private createMapInstance;
+    /**
+     * 应用地图修复配置
+     */
+    private applyFixConfig;
+    /**
+     * 绑定区域交互事件
+     */
+    private bindAreaEvents;
+    /**
+     * 设置缩放级别
+     */
+    setZoom(zoom: number): void;
+    /**
+     * 创建分组
+     * @param groupId 分组ID，用于后续管理
+     * @returns 分组实例
+     */
+    createGroup(groupId: string): Promise<Awaited<ReturnType<Map_2['addGroup']>> | null>;
+    /**
+     * 获取分组
+     */
+    getGroup(groupId: string): Awaited<ReturnType<Map_2['addGroup']>> | undefined;
+    /**
+     * 清除指定分组
+     */
+    clearGroup(groupId: string): void;
+    /**
+     * 清除所有分组
+     */
+    clearAllGroups(): void;
+    /**
+     * 清除区域关闭定时器（供 PortalModal 调用）
+     */
+    clearAreaCloseTimer(): void;
+    triggerAreaLeave({ areaName }?: {
+        areaName: string;
+    }): void;
+    /**
+     * 销毁所有地图实例
+     */
+    dispose(): void;
+}
+
+export declare interface MapManagerConfig {
+    container: HTMLDivElement;
+    controlsContainer?: HTMLDivElement;
+    assetsPrefix?: string;
+    fixConfig?: FixConfig;
+    raycasterPointsThreshold?: number;
+    mapPadding?: [number, number, number, number];
+    rmTemplateIdentifier?: boolean;
+    geojsonExtensions?: Record<string, any[]>;
+}
+
+declare interface MapOptions extends BaseOptions {
+    adcode: number;
+    center?: [number, number];
+    parentBg?: boolean | number;
+    parentBgDepth?: number;
+    topSegments?: number;
+    continentsBg?: boolean;
+    continentsBgDepth?: number;
+    clickOusideBack?: boolean;
+    mapDepth?: number[];
+    depthReference?: number[];
+    mapPadding?: number[];
+    geojsonMap?: Record<string, GeoJSON_4>;
+    extrudeLineGeojsonMap?: Record<string, GeoJSON_4>;
+    fixGeojson?: Record<string, string>;
+    plateInCenter?: boolean;
+    clickHandleDrillDown?: boolean;
+    drillDownPlateInCenter?: boolean;
+    drillDownHideParent?: boolean;
+    drillDownRestrictions?: 'city' | 'district';
+    drillDownSecondLevelMats?: boolean;
+    drillDownThirdLevelMats?: boolean;
+    showDistrict?: boolean;
+    showLabel?: boolean | 'lite';
+    lineWidth?: number;
+    lineOffset?: number;
+    extrudeLineWidth?: number;
+    extrudeLine?: boolean;
+    equirectangular?: boolean;
+    winkel3?: boolean;
+    projectionType?: 'mercator' | 'equirectangular' | 'winkel3';
+    polarAngle?: number;
+    azimuthAngle?: number;
+    showOneLevel?: boolean;
+    handleBackKeepCamvasState?: boolean;
+    worldPacificCentre?: boolean;
+    mapBoundary?: boolean;
+    mergeSide?: boolean;
+    style?: 'map2Base' | 'map2CityOnMap';
+    bottomPlane?: boolean;
+    bottomPlaneWater?: boolean;
+    geojsonExtensions?: Record<string, GeoJSON_4 | string | number | (GeoJSON_4 | string | number)[]>;
+}
+
+declare class Model extends BaseObject {
+    options: Options_5;
+    mixer: THREE.AnimationMixer | null;
+    clips: THREE.AnimationClip[];
+    actions: THREE.AnimationAction[];
+    actionStates: Record<string, boolean>;
+    constructor(options: Options_5);
+    create(): Promise<void>;
+    render(): void;
+    /**
+     * Set animation clips for the model
+     * @param clips Array of animation clips from GLTF
+     */
+    setClips(clips: THREE.AnimationClip[]): void;
+    /**
+     * Play all animation clips
+     */
+    playAllClips(): void;
+    /**
+     * Play a specific animation clip by name
+     * @param clipName Name of the animation clip to play
+     */
+    playClip(clipName: string): void;
+    /**
+     * Stop a specific animation clip by name
+     * @param clipName Name of the animation clip to stop
+     */
+    stopClip(clipName: string): void;
+    /**
+     * Stop all animation clips
+     */
+    stopAllClips(): void;
+    /**
+     * Set the playback speed for all animations
+     * @param speed Playback speed (1.0 = normal speed)
+     */
+    setPlaybackSpeed(speed: number): void;
+    /**
+     * Get the current playback speed
+     */
+    getPlaybackSpeed(): number;
+    /**
+     * Check if a specific animation is playing
+     * @param clipName Name of the animation clip
+     */
+    isPlaying(clipName: string): boolean;
+    /**
+     * Get all available animation clip names
+     */
+    getClipNames(): string[];
+    /**
+     * Update animations - should be called in render loop
+     * @param deltaTime Time elapsed since last frame
+     */
+    update(deltaTime: number): void;
+    /**
+     * Dispose of resources including animation mixer
+     */
+    dispose(): void;
+}
+
+declare const objs: {
+    Plane: typeof Plane;
+    CrossPlane: typeof CrossPlane;
+    PlaneShadow: typeof PlaneShadow;
+    Ring: typeof Ring;
+    Sphere: typeof Sphere;
+    Sprite: typeof Sprite;
+    Tetrahedron: typeof Tetrahedron;
+    Torus: typeof Torus;
+    TorusKnot: typeof TorusKnot;
+    Tube: typeof Tube;
+    Box: typeof Box;
+    Capsule: typeof Capsule;
+    Circle: typeof Circle;
+    Cylinder: typeof Cylinder;
+    Dodecahedron: typeof Dodecahedron;
+    Icosahedron: typeof Icosahedron;
+    Lathe: typeof Lathe;
+    Octahedron: typeof Octahedron;
+    Node: typeof Node_2;
+    Line: typeof Line;
+    Line2: typeof Line2;
+    ExtrudePolygon: typeof ExtrudePolygon;
+    ConicPolygon: typeof ConicPolygon;
+    Group: typeof Group;
+    Light: typeof Light;
+    Point: typeof Point;
+    Arc: typeof Arc;
+    Model: typeof Model;
+};
+
+declare const objs_2: {
+    Building: typeof Building;
+    Road: typeof Road;
+    Area: typeof Area;
+    CityPlane: typeof CityPlane;
+    Target: typeof Target;
+    Plane: Plane;
+    CrossPlane: CrossPlane;
+    PlaneShadow: PlaneShadow;
+    Ring: Ring;
+    Sphere: Sphere;
+    Sprite: Sprite;
+    Tetrahedron: Tetrahedron;
+    Torus: Torus;
+    TorusKnot: TorusKnot;
+    Tube: Tube;
+    Box: Box;
+    Capsule: Capsule;
+    Circle: Circle;
+    Cylinder: Cylinder;
+    Dodecahedron: Dodecahedron;
+    Icosahedron: Icosahedron;
+    Lathe: Lathe;
+    Octahedron: Octahedron;
+    Node: Node_2;
+    Line: Line;
+    Line2: Line2;
+    ExtrudePolygon: ExtrudePolygon;
+    ConicPolygon: ConicPolygon;
+    Group: Group;
+    Light: Light;
+    Point: Point;
+    Arc: Arc;
+    Model: Model;
+};
+
+declare const objs_3: {
+    Earth: typeof Earth_2;
+    SphereShadow: typeof SphereShadow;
+    Countries: typeof PlaneMap;
+    Plane: Plane;
+    CrossPlane: CrossPlane;
+    PlaneShadow: PlaneShadow;
+    Ring: Ring;
+    Sphere: Sphere;
+    Sprite: Sprite;
+    Tetrahedron: Tetrahedron;
+    Torus: Torus;
+    TorusKnot: TorusKnot;
+    Tube: Tube;
+    Box: Box;
+    Capsule: Capsule;
+    Circle: Circle;
+    Cylinder: Cylinder;
+    Dodecahedron: Dodecahedron;
+    Icosahedron: Icosahedron;
+    Lathe: Lathe;
+    Octahedron: Octahedron;
+    Node: Node_2;
+    Line: Line;
+    Line2: Line2;
+    ExtrudePolygon: ExtrudePolygon;
+    ConicPolygon: ConicPolygon;
+    Group: Group;
+    Light: Light;
+    Point: Point;
+    Arc: Arc;
+    Model: Model;
+};
+
+declare const objs_4: {
+    PlaneMap: typeof PlaneMap;
+    CityPlane: typeof CityPlane;
+    ContinentsBg: typeof ContinentsBg;
+    Mountain: typeof PlaneMap_2;
+    Plane: Plane;
+    CrossPlane: CrossPlane;
+    PlaneShadow: PlaneShadow;
+    Ring: Ring;
+    Sphere: Sphere;
+    Sprite: Sprite;
+    Tetrahedron: Tetrahedron;
+    Torus: Torus;
+    TorusKnot: TorusKnot;
+    Tube: Tube;
+    Box: Box;
+    Capsule: Capsule;
+    Circle: Circle;
+    Cylinder: Cylinder;
+    Dodecahedron: Dodecahedron;
+    Icosahedron: Icosahedron;
+    Lathe: Lathe;
+    Octahedron: Octahedron;
+    Node: Node_2;
+    Line: Line;
+    Line2: Line2;
+    ExtrudePolygon: ExtrudePolygon;
+    ConicPolygon: ConicPolygon;
+    Group: Group;
+    Light: Light;
+    Point: Point;
+    Arc: Arc;
+    Model: Model;
+};
+
+declare class Octahedron extends BaseObject {
+    create(): void;
+}
+
+declare interface Opt {
+    scale?: number;
+}
+
+declare interface Options {
+    material?: THREE.Material;
+    key?: string;
+}
+
+declare interface Options_10 {
+    jsonUrl: string;
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    material: THREE.Material;
+    type: string;
+    cacheKey?: string;
+    oArr?: number[];
+}
+
+declare interface Options_11 {
+    width: number;
+    height: number;
+    material?: THREE.Material;
+    color?: string;
+    map?: THREE.Texture | null;
+}
+
+declare interface Options_12 {
+    radius?: number;
+    rotationY?: number;
+}
+
+declare interface Options_13 {
+    radius?: number;
+}
+
+declare interface Options_14 {
+    areaGroup?: boolean;
+    geojson: GeoJSON_2;
+    projection?: {
+        center: [number, number];
+        scale: number;
+        rotate?: [number, number];
+        projectionType?: 'mercator' | 'equirectangular' | 'winkel3';
+    };
+    extrudeLineGeojson?: GeoJSON_2;
+    hasSide?: boolean;
+    hasTop?: boolean;
+    mergeSide?: boolean;
+    hasLine?: boolean;
+    start?: number;
+    depth?: number;
+    lineOffset?: number;
+    bbox?: number[];
+    topSegments?: number;
+    conic?: boolean;
+    materialOptions: {
+        topMat: THREE.Material;
+        sideMat?: THREE.Material;
+        lineMat?: MeshLineMaterial;
+        extrudeLineMat?: MeshLineMaterial;
+        bgTopMat?: THREE.Material;
+        bgSideMat?: THREE.Material;
+        bgLineMat?: MeshLineMaterial;
+        bgExtrudeLineMat?: MeshLineMaterial;
+    };
+    onTop?: number;
+    bloom?: boolean;
+}
+
+declare interface Options_15 {
+    scale: number;
+    depth: number;
+}
+
+declare interface Options_16 {
+    geojson: GeoJSON_3;
+    projection: {
+        center: [number, number];
+        scale: number;
+        rotate?: [number, number];
+        projectionType?: 'mercator' | 'equirectangular' | 'winkel3';
+    };
+    depth?: number;
+    bbox?: number[];
+}
+
+declare interface Options_2 {
+    path?: THREE.Curve<THREE.Vector3>;
+    radius?: number;
+    multiplyScalar?: number;
+}
+
+declare interface Options_3 {
+    sprite?: boolean;
+}
+
+declare interface Options_4 {
+    from: number[];
+    to: number[];
+    radius?: number;
+    globe?: boolean;
+    color?: string;
+    lineWidth?: number;
+    offsetLoop?: boolean;
+    key?: string;
+}
+
+declare interface Options_5 {
+    src?: string;
+    autoPlay?: boolean;
+    playbackSpeed?: number;
+}
+
+declare interface Options_6 {
+    visFactories?: Base;
+}
+
+declare interface Options_7 {
+    visFactories?: Base;
+    assetsPrefix?: string;
+    processUndosMaxFrameTime?: number;
+}
+
+declare interface Options_8 {
+    jsonUrl: string;
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    cacheKey?: string;
+    material?: THREE.Material | THREE.Material[];
+    meters?: number;
+    hasSide?: boolean;
+    sideGradient?: boolean;
+    grey?: boolean;
+}
+
+declare interface Options_9 {
+    jsonUrl: string;
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    cacheKey?: string;
+    meters?: number;
+    grey?: boolean;
+}
+
+declare class Plane extends BaseObject {
+    create(): void;
+}
+
+declare class PlaneMap extends BaseObject {
+    options: Required<Omit<Options_14, 'bbox' | 'extrudeLineGeojson'>> & Pick<Options_14, 'bbox' | 'extrudeLineGeojson'>;
+    isActive: boolean;
+    groupArr: Group[];
+    areaArr: ExtrudePolygon[];
+    lineArr: Line[];
+    mergeSideArea: ExtrudePolygon | null;
+    extrudelineArr?: Line[];
+    splitPolygons: number;
+    constructor(options: Options_14);
+    create(): Promise<void>;
+    addArea(geojson: GeoJSON_2, options: {
+        material: THREE.Material | THREE.Material[];
+        bbox?: number[];
+        areaGroup?: boolean;
+        hasSide?: boolean;
+        hasTop?: boolean;
+        onTop?: number;
+        castShadow?: boolean;
+    }): Promise<ExtrudePolygon[]>;
+    addLine(geojson: GeoJSON_2, options: {
+        material?: MeshLineMaterial;
+        onTop?: number;
+        areaGroup?: boolean;
+    }): Promise<Line[]>;
+    getPropertiesKey(properties: Record<string, any>): string;
+    geojson2Meta(geojson: GeoJSON_2): {
+        coords: Position[][];
+        properties: GeoJsonProperties;
+    }[];
+    update(delta: number, elapsed: number): void;
+    findGroup(adcode: string | number, fix?: boolean): Group | undefined;
+    setAreaMaterial(key: string, material: THREE.Material[] | THREE.Material): void;
+    useAreaMaterial(key: string): void;
+    setLineMaterial(key: string, material: THREE.Material): void;
+    useLineMaterial(key: string): void;
+    setExtrudeLineMaterial(key: string, material: THREE.Material): void;
+    useExtrudeLineMaterial(key: string): void;
+    changeLineAnimateParams({ speed, extrude, }: {
+        speed?: number;
+        extrude?: boolean;
+    }): void;
+    deactive(): void;
+    render(): void;
+    toggleExtrudelineBloom(s: boolean): void;
+    active(): void;
+    dispose(): void;
+}
+
+declare class PlaneMap_2 extends BaseObject {
+    options: Required<Omit<Options_16, 'bbox'>> & Pick<Options_16, 'bbox'>;
+    extrudePolygon: ExtrudePolygon;
+    constructor(options: Options_16);
+    geojson2Meta(geojson: GeoJSON_3): {
+        coords: Position[][];
+        properties: GeoJsonProperties;
+    }[];
+    create(): Promise<void>;
+    setNoise(geometry: THREE.BufferGeometry, image: HTMLImageElement, maxHeight?: number): void;
+    render(): void;
+    dispose(): void;
+}
+
+declare class PlaneShadow extends BaseObject {
+    create(): Promise<void>;
+}
+
+declare class Point extends BaseObject {
+    options: Options_3;
+    constructor(options: Options_3);
+    get material(): THREE.SpriteMaterial | THREE.MeshBasicMaterial;
+    getMaterial(): THREE.SpriteMaterial | THREE.MeshBasicMaterial;
+    create(): Promise<void>;
+    scaleValue: number;
+    setScale(n: number): void;
+}
+
+/**
+ * 移除摄像机历史记录
+ * @param u 历史记录数组
+ */
+export declare const removeCameraHistory: (u: any) => any;
+
+declare class Ring extends BaseObject {
+    create(): void;
+}
+
+declare class Road extends BaseObject {
+    options: Options_9;
+    constructor(options: Options_9);
+    linePrimary: Line[];
+    lineSecondary: Line[];
+    create(): Promise<void>;
+    dispose(): void;
+}
+
+declare interface SelectedMeta {
+    name: string;
+    key: string;
+    object: THREE.Mesh;
+    baseObject: BaseObject;
+    useMaterialType: string;
+    visible: boolean;
+    disabledC: boolean;
+    disabledR: boolean;
+    disabledTC: boolean;
+    disabledVisible: boolean;
+    children: SelectedMeta[];
+}
+
+declare const sinusoidalInOut: ({ onUpdate, onComplete, backwards, }?: {
+    onUpdate?: ((v: number) => void) | undefined;
+    onComplete?: (() => void) | undefined;
+    backwards?: boolean | undefined;
+}) => {
+    start: ({ duration, repeat, repeatResolve, repeatDelay, }?: {
+        duration?: number | undefined;
+        repeat?: number | undefined;
+        repeatResolve?: number | undefined;
+        repeatDelay?: number | undefined;
+    }) => Promise<any>;
+    stop: () => void;
+};
+
+declare class Sphere extends BaseObject {
+    radius: number;
+    material?: THREE.Material;
+    options?: any;
+    create(): void;
+}
+
+declare class SphereShadow extends BaseObject {
+    options: Required<Options_13>;
+    constructor(options: Options_13);
+    create(): Promise<void>;
+}
+
+declare class Sprite extends BaseObject {
+    create(): void;
+    setDesiredPixelSize(size: number): void;
+}
+
+declare class Target extends BaseObject {
+    options: Opt;
+    time: {
+        value: number;
+    };
+    offset: THREE.Vector2;
+    timer: ReturnType<typeof setTimeout> | null;
+    inTween: TWEEN.Tween<any> | null;
+    outTween: TWEEN.Tween<any> | null;
+    constructor(options: Opt);
+    createWave(color: string): THREE.Mesh<THREE.PlaneGeometry, THREE.ShaderMaterial, THREE.Object3DEventMap>;
+    createRipple(texture: THREE.Texture): THREE.Mesh<THREE.CylinderGeometry, THREE.ShaderMaterial, THREE.Object3DEventMap>;
+    createCylinder(texture: THREE.Texture): THREE.Object3D<THREE.Object3DEventMap>;
+    createTorus(color: string): THREE.Mesh<THREE.TorusGeometry, THREE.MeshBasicMaterial, THREE.Object3DEventMap>;
+    create(): Promise<void>;
+    erase(): void;
+    update(delta: number, elapsed: number): void;
+}
+
+declare class Tetrahedron extends BaseObject {
+    create(): void;
+}
+
+export { THREE }
+
+declare const timeOut: (ms: number) => Promise<any>;
+
+declare class Torus extends BaseObject {
+    create(): void;
+}
+
+declare class TorusKnot extends BaseObject {
+    create(): void;
+}
+
+declare class Tube extends BaseObject {
+    options: Options_2;
+    constructor(options: Options_2);
+    create(): void;
+}
+
+export { TWEEN }
+
+export declare const VERSION = "0.30.0-beta.70";
+
+declare class Viewport {
+    editor: Editor;
+    vis?: Base;
+    extendsOptions: Record<string, any>;
+    cameraState: Record<string, number[]>;
+    delLoadObj?: string[];
+    options: Options_6;
+    constructor(editor: Editor, options: Options_6);
+    setSaveCamera(type: string): void;
+    addVis(type: string, options?: Record<string, any>): Promise<void>;
+    replaceVis(): boolean;
+    setVis(type: string, options?: Record<string, any>): Promise<void>;
+    setResetCameraUp(): void;
+    initEvent(): void;
+    addObj(type: string, options?: Record<string, any>): Promise<void>;
+    removeObj(uuid?: string): Promise<void>;
+    private copyObjKey;
+    copyObj(key: string): void;
+    clearCopyObj(): void;
+    pasteObj(): Promise<void>;
+    copyMListMaterial(key: string): Promise<void>;
+    clearCopyMListMaterial(): Promise<void>;
+    pasteMListMaterial(): Promise<void>;
+    pasteMListMaterial2Replace(replaceKey: string): Promise<void>;
+    addMListMaterial(material?: string | Record<string, any>, object3d?: THREE.Mesh, slot?: number): Promise<string | undefined>;
+    removeMListMaterial(key: string): Promise<void>;
+    setExtendsOptions(name: string, value: any): void;
+    toJSON(): {
+        eo: Record<string, any>;
+        cs: Record<string, number[]>;
+        delLoadObj: string[] | undefined;
+    };
+    fromJSON(json: any): void;
+    getLoadObj(): string[];
+    setTransformControlsModal(modal: 'translate' | 'rotate' | 'scale'): void;
+    dispose(): void;
+}
+
+export { }
+
+
+
+declare module '@turf/turf' {
+  export function point(...args: any[]): any;
+  export function polygon(...args: any[]): any;
+  export function booleanPointInPolygon(...args: any[]): boolean;
+  export function center(...args: any[]): any;
+  export function centroid(...args: any[]): any;
+  export function bbox(...args: any[]): any;
+  export function union(...args: any[]): any;
+}