@wwsy/cesium 0.0.4 → 0.0.5

package/dist/index.d.ts

@@ -2,39 +2,67 @@ import { Camera } from 'cesium';
 import * as Cesium from 'cesium';
 import { Clock } from 'cesium';
 import { Event as Event_3 } from 'cesium';
-import { Scene as Scene_2 } from 'cesium';
+import { Scene } from 'cesium';
 
 declare class AmapImageryProvider extends Cesium.UrlTemplateImageryProvider {
     constructor(options: imageryProviderOptions);
 }
 
-declare class Animation_2 {
-    _viewer: Viewer;
-    constructor(viewer: Viewer);
-    _bindEvent(): void;
-    _unbindEvent(): void;
-    start(): this;
-    stop(): this;
-}
-export { Animation_2 as Animation }
-
-export declare class AroundPoint extends Animation_2 {
-    constructor(viewer: Viewer, options: any);
-}
-
-export declare class AroundView extends Animation_2 {
-    private _options;
-    private _aroundAmount;
-    constructor(viewer: Viewer);
-    _bindEvent(): void;
-    _unbindEvent(): void;
-    private _update;
-}
-
-export declare class Attachment {
-    private _viewer;
-    constructor(viewer: Viewer);
-    createEvent(): void;
+/**
+ * 基础覆盖物、图层
+ * **/
+declare class BaseEntityLayer {
+    private _entityName;
+    private _customId;
+    private _customData;
+    private _bVisible;
+    private _bLocked;
+    protected _data: any;
+    constructor(data: BasicEntityLayerType);
+    _setBasic(): void;
+    get entityName(): string;
+    set entityName(value: string);
+    GetEntityName(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetEntityName(value: string): void;
+    get customId(): string;
+    set customId(value: string);
+    GetCustomId(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetCustomId(value: string): void;
+    get customData(): Record<string, any>;
+    set customData(value: Record<string, any>);
+    GetCustomData(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetCustomData(value: Record<string, any>): void;
+    get bVisible(): boolean;
+    set bVisible(value: boolean);
+    protected _visibleHook(value: boolean): void;
+    GetVisible(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetVisible(value: boolean): void;
+    get bLocked(): boolean;
+    set bLocked(value: boolean);
+    GetLocked(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetLocked(value: boolean): void;
+    Update(data: any): void;
+    protected _updateHook(): void;
 }
 
 declare interface BaseImageryLayer {
@@ -47,33 +75,48 @@ declare interface BaseImageryLayer {
     };
 }
 
-export declare class BaseLayerPicker {
-    private _imageryLayers;
-    private _selectedImageryLayer;
-    private _count;
-    private _viewer;
-    set selectedImageryLayer(imageryLayer: BaseImageryLayer);
-    get selectedImageryLayer(): BaseImageryLayer;
-    constructor(viewer: Viewer);
-    addImageryLayer(imageryLayer: Cesium.ImageryLayer | Cesium.ImageryLayer[], options: BaseImageryLayer['options']): this;
-    changeImageryLayer(index: number): this;
+declare type BasicEntityLayerType = Partial<BasicInfoAtomType> & Partial<VisibleAtomType> & Partial<EntityFlagAtomType>;
+
+/**
+ * @interface BasicInfoAtomType
+ * @param {string} entityName
+ * @param {string} customId
+ * @param {any} customData
+ * @param {string} parentEid
+ */
+declare interface BasicInfoAtomType {
+    entityName: string;
+    customId: string;
+    customData: any;
+    parentEid: string;
+}
+
+declare interface CameraBase {
+    location: number[];
+    locationLimit: number[][];
+    rotation: {
+        pitch: number;
+        yaw: number;
+    };
+    pitchLimit: number[];
+    yawLimit: number[];
+    viewDistanceLimit: number[];
+    fieldOfView: number;
 }
 
-export declare class CameraControl {
+declare class CameraControl {
     private _options;
     private _viewer;
     private _animationInstance;
     constructor(viewer: Viewer);
+    private _CameraChange;
     ToggleCameraSelfRotate(enable: boolean): void;
-    GetCameraPose(): void;
-    SetCameraPose(options: {
-        location: number[];
-        rotation: {
-            pitch: number;
-            yaw: number;
-        };
-        flyTime: number;
-    }): void;
+    GetCameraPose(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    SetCameraPose(options: CameraPoseData): void;
     ResetCameraPose(): void;
     GetCameraLimit(): void;
     SetCameraLimit(): void;
@@ -83,8 +126,12 @@ export declare class CameraControl {
     GetCameraSpeed(): void;
     SetCameraAnimation(): void;
     GetCameraAnimation(): void;
-    GetCameraInfo(): void;
-    UpdateCamera(): void;
+    GetCameraInfo(): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    UpdateCamera(options: CameraBase & CameraPoseData): void;
     Move(): void;
     Rotate(): void;
     Around(): void;
@@ -93,43 +140,61 @@ export declare class CameraControl {
     CameraStepRotate(): void;
     CameraStepZoom(): void;
     StopCameraStepUpdate(): void;
-    FlyTo(): void;
+    FlyTo(options: CameraFlytoData): void;
     FocusToNodes(): void;
     Focus(): void;
-    FocusToAll(): void;
+    FocusToAll(options?: {
+        types: string[];
+        bFilterForExclude: boolean;
+    }): void;
     Follow(): void;
     PlayRoam(): void;
     StopRoam(): void;
     GetCameraRoamingInfo(): void;
 }
 
-export declare class CameraRoam {
+declare interface CameraFlytoData extends Pick<CameraBase, 'rotation'> {
+    targetPosition: number[];
+    flyTime: number;
+}
+
+declare interface CameraPoseData extends Pick<CameraBase, 'location' | 'rotation'> {
+    flyTime: number;
+}
+
+declare class CameraRoam {
     constructor();
 }
 
-export declare class Coordinate {
+/**
+ * @type {Coord2DType}
+ * @alias Array<number>
+ */
+declare type Coord2DType = Array<number>;
+
+declare class Coordinate {
     private _viewer;
     get Picker(): {
         PickWorldPointByScreenPos: any;
     };
     constructor(viewer: any);
     GISToCartesian(coord: CoordType[]): Promise<{
-        message: string;
+        message: any;
         success: boolean;
         result: any;
     }>;
     CartesianToGIS(coord: CoordType[]): Promise<{
-        message: string;
+        message: any;
         success: boolean;
         result: any;
     }>;
     GISToScreenPos(coord: CoordType[]): Promise<{
-        message: string;
+        message: any;
         success: boolean;
         result: any;
     }>;
     PickWorldPointByScreenPos(position: number[]): Promise<{
-        message: string;
+        message: any;
         success: boolean;
         result: any;
     }>;
@@ -138,71 +203,54 @@ export declare class Coordinate {
     Exchange(): void;
 }
 
+declare type CoordType = Array<number>;
+
 /**
- * @Author : Caven Chen
+ * @type {CoordType}
+ * @alias Array<number>
  */
-export declare class CoordTransform {
-    /**
-     * BD-09 To GCJ-02
-     * @param lng
-     * @param lat
-     * @returns {number[]}
-     */
-    static BD09ToGCJ02(lng: any, lat: any): number[];
-    /**
-     * GCJ-02 To BD-09
-     * @param lng
-     * @param lat
-     * @returns {number[]}
-     * @constructor
-     */
-    static GCJ02ToBD09(lng: any, lat: any): number[];
-    /**
-     * WGS-84 To GCJ-02
-     * @param lng
-     * @param lat
-     * @returns {number[]}
-     */
-    static WGS84ToGCJ02(lng: any, lat: any): any[];
-    /**
-     * GCJ-02 To WGS-84
-     * @param lng
-     * @param lat
-     * @returns {number[]}
-     * @constructor
-     */
-    static GCJ02ToWGS84(lng: any, lat: any): any[];
-    /**
-     *
-     * @param lng
-     * @param lat
-     * @returns {number[]}
-     */
-    static delta(lng: any, lat: any): any[];
-    /**
-     *
-     * @param lng
-     * @param lat
-     * @returns {number}
-     */
-    static transformLng(lng: any, lat: any): any;
-    /**
-     *
-     * @param lng
-     * @param lat
-     * @returns {number}
-     */
-    static transformLat(lng: any, lat: any): number;
-    /**
-     *
-     * @param lng
-     * @param lat
-     * @returns {boolean}
-     */
-    static out_of_china(lng: any, lat: any): boolean;
+declare type CoordType_2 = Array<number>;
+
+/**
+ * @type {CoordZRefType}
+ * @alias 'surface'|'ground'|'altitude'
+ */
+declare type CoordZRefType = 'surface' | 'ground' | 'altitude';
+
+/**
+ * @type {deepPartial<T>}
+ */
+declare type deepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? deepPartial<T[K]> : T[K];
+};
+
+declare interface EntityDrillAtomType {
+    allowDrillPicking: boolean;
 }
 
-declare type CoordType = Array<number>;
+/**
+ * @interface EntityEidType
+ * @param {string | null} eid (optional)
+ */
+declare interface EntityEidType {
+    eid?: string | null;
+}
+
+/**
+ * @interface EntityFlagAtomType
+ * @param {boolean} bLocked
+ */
+declare interface EntityFlagAtomType {
+    bLocked: boolean;
+}
+
+/**
+ * @interface EntityOutlinerAtomType
+ * @param {string} index
+ */
+declare interface EntityOutlinerAtomType {
+    index: string;
+}
 
 declare class Event_2 {
     _types: {
@@ -221,14 +269,55 @@ declare class Event_2 {
     _registerEvent(): void;
     getEvent(type: string): Cesium.Event | undefined;
 }
-export { Event_2 as Event }
 
 declare class GroundSkyBox extends SkyBox_2 {
     constructor(options?: any);
     update(frameState: any, useHdr: any): any;
 }
 
-export declare class ImageryProvider {
+/**
+ * @interface ICalculateCoordZ
+ * @param {CoordZRefType} coordZRef
+ * @param {number} coordZOffset
+ */
+declare interface ICalculateCoordZ {
+    coordZRef: CoordZRefType;
+    coordZOffset: number;
+}
+
+/**
+ * @interface ICamera
+ * @param {number} hideDistance
+ * @param {string} hideType
+ * @param {string} scaleMode
+ */
+declare interface ICamera {
+    hideDistance: number;
+    hideType: string;
+    scaleMode: string;
+    url?: string;
+    size?: Array<number>;
+}
+
+/**
+ * @interface IEntity
+ * @param {number} overlapOrder
+ */
+declare interface IEntity {
+    overlapOrder: number;
+}
+
+/**
+ * @interface IInteraction
+ * @param {boolean} clickTop
+ * @param {boolean} hoverTop
+ */
+declare interface IInteraction {
+    clickTop: boolean;
+    hoverTop: boolean;
+}
+
+declare class ImageryProvider {
     static createAmapImageryProvider(options: imageryProviderOptions): Promise<AmapImageryProvider>;
     static createTianDiTuImageryProvider(options: imageryProviderOptions): Promise<TianDiTuImageryProvider>;
     static createImageryProvider(type: string, options: imageryProviderOptions): Promise<AmapImageryProvider>;
@@ -247,6 +336,14 @@ declare interface imageryProviderOptions extends Partial<Cesium.UrlTemplateImage
  */
 declare type imageryProviderStyle = 'vector' | 'raster' | 'topography' | 'vectorMark' | 'rasterMark' | 'topographyMark';
 
+/**
+ * @interface IOperations
+ * @param {ICalculateCoordZ} calculateCoordZ
+ */
+declare interface IOperations {
+    calculateCoordZ: ICalculateCoordZ;
+}
+
 declare type layerSource = 'gaode' | 'tianditu';
 
 declare class MapSwitch extends Widget {
@@ -258,105 +355,165 @@ declare class MapSwitch extends Widget {
     addMap(map: BaseImageryLayer['options']): void;
 }
 
-declare class MouseEvent_2 extends Event_2 {
-    private _viewer;
-    constructor(viewer: Viewer);
-    _registerEvent(): void;
-    _initDefaultEvent(): void;
-    _leftDownHandler(): void;
-    _leftUpHandler(): void;
-    _clickHandler(movement: any): boolean;
-    _dbClickHandler(): void;
-    _rightDownHandler(): void;
-    _rightUpHandler(): void;
-    _rightClickHandler(): void;
-    _mouseMoveHandler(): void;
-    _mouseWheelHandler(): void;
-    _getMouseInfo(position: Cesium.Cartesian2): {
-        target: any;
-        windowPosition: Cesium.Cartesian2;
-        position: any;
-        wgs84Position: any;
-        surfacePosition: any;
-        wgs84SurfacePosition: any;
+/**
+ * @type {MinMaxType}
+ * @alias Array<number>
+ */
+declare type MinMaxType = Array<number>;
+
+declare class Overlay extends BaseEntityLayer {
+    private _eid;
+    protected oType: string;
+    protected type: string;
+    private _state;
+    private _bRemoved;
+    private _allowDrillPicking;
+    private _overlayEvent;
+    private _layer;
+    private _operations;
+    protected layerType: string;
+    _delegate: any;
+    constructor(data: BasicEntityLayerType & Partial<EntityDrillAtomType>);
+    get EntityType(): string;
+    get Eid(): string;
+    get overlayEvent(): OverlayEvent;
+    private _getLayerCollection;
+    protected _mountedHook(): void;
+    private _onAdd;
+    protected _addedHook(): void;
+    private _onRemove;
+    protected _removedHook(): void;
+    Delete(): void;
+    emit(type: any, ...params: any[]): void;
+    onClick(callback: any, context?: any): void;
+    onMouseEnter(callback: any, context?: any): void;
+    onMouseLeave(callback: any, context?: any): void;
+    protected _visibleHook(visible: any): void;
+    protected _getCalculateCoordZ(): {
+        reference: Cesium.HeightReference;
+        height: number;
     };
-    _getMousePosition(windowPosition: Cesium.Cartesian2): {
-        windowPosition: Cesium.Cartesian2;
-        position: any;
-        wgs84Position: any;
-        surfacePosition: any;
-        wgs84SurfacePosition: any;
+}
+
+declare class OverlayEvent extends Event_2 {
+    constructor();
+}
+
+declare class Poi extends Overlay {
+    private _styleCache;
+    private _bHover;
+    constructor(data: PoiType);
+    _mountedHook(): void;
+    updateStyle(): Promise<void>;
+    private applyBillboard;
+    _renderBillboard(poiStyle?: Partial<PoiEntityAtomType>): Promise<{
+        image?: undefined;
+        pixelOffset?: undefined;
+        horizontalOrigin?: undefined;
+        verticalOrigin?: undefined;
+    } | {
+        image: string;
+        pixelOffset: Cesium.Cartesian2;
+        horizontalOrigin: Cesium.HorizontalOrigin;
+        verticalOrigin: Cesium.VerticalOrigin;
+    }>;
+    computeLayout(poiStyle?: Partial<PoiEntityAtomType>): {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker?: undefined;
+        label?: undefined;
+        text?: undefined;
+    } | {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        label: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        text: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
     };
-    /**
-     * 调整位置，将视图位置从像素坐标转换为归一化设备独立像素坐标。
-     * 这个函数用于处理不同设备上因DPI不同导致的显示问题，确保在高DPI设备上也能正确显示。
-     *
-     * @param {Object} position - 像素坐标，包含x和y属性。
-     * @returns {Cesium.Cartesian2} - 归一化设备独立像素坐标。
-     */
-    _adjustPosition(position: Cesium.Cartesian2): Cesium.Cartesian2;
-    _getTargetObject(target: any): {
-        overlayId: any;
-        layerId: any;
-        object: any;
-        feature: any;
+    getClientHeightWidth(poiStyle?: Partial<PoiEntityAtomType>): {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker?: undefined;
+        label?: undefined;
+        text?: undefined;
+    } | {
+        width: number;
+        height: number;
+        pivot: {
+            x: number;
+            y: number;
+        };
+        marker: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        label: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+        text: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
     };
-    _raiseEvent(type: any, mouseInfo: any): void;
-}
-export { MouseEvent_2 as MouseEvent }
-
-export declare const MouseEventType: {
-    MOUSE_MOVE: Cesium.ScreenSpaceEventType;
-    WHEEL: Cesium.ScreenSpaceEventType;
-    MOUSE_OVER: string;
-    MOUSE_OUT: string;
-    LEFT_DOWN: Cesium.ScreenSpaceEventType;
-    LEFT_UP: Cesium.ScreenSpaceEventType;
-    CLICK: Cesium.ScreenSpaceEventType;
-    RIGHT_DOWN: Cesium.ScreenSpaceEventType;
-    RIGHT_UP: Cesium.ScreenSpaceEventType;
-    RIGHT_CLICK: Cesium.ScreenSpaceEventType;
-    DB_CLICK: Cesium.ScreenSpaceEventType;
-};
+    _updateHook(): void;
+}
 
-export declare class Position {
-    private _lng;
-    private _lat;
-    private _alt;
-    private _heading;
-    private _pitch;
-    private _roll;
-    constructor(lng?: number, lat?: number, alt?: number, heading?: number, pitch?: number, roll?: number);
-    set lng(lng: number);
-    get lng(): number;
-    set lat(lat: number);
-    get lat(): number;
-    set alt(alt: number);
-    get alt(): number;
-    set heading(heading: number);
-    get heading(): number;
-    set pitch(pitch: number);
-    get pitch(): number;
-    set roll(roll: number);
-    get roll(): number;
-    serialize(): string;
-    distance(target: any): number;
-    clone(): Position;
-    copy(): Position;
-    toArray(): number[];
-    toString(): string;
-    toObject(): {
-        lng: number;
-        lat: number;
-        alt: number;
-        heading: number;
-        pitch: number;
-        roll: number;
-    };
-    static fromArray(arr: any): Position;
-    static fromString(str: any): Position;
-    static fromObject(obj: any): Position;
-    static deserialize(valStr: any): Position;
+declare interface PoiEntityAtomType {
+    markerVisible: boolean;
+    markerNormalUrl: string;
+    markerActivateUrl: string;
+    markerSize: MinMaxType;
+    labelVisible: boolean;
+    labelBgImageUrl: string;
+    labelBgSize: MinMaxType;
+    labelBgOffset: Coord2DType;
+    labelContent: Array<string>;
+    labelContentOffset: Coord2DType;
+    labelTop: boolean;
+    scrollSpeed: number;
+    textBoxWidth: number;
+    labelContentJustification: Tjustification;
+    labelContentAutoWrap: boolean;
+    scrollPolicy: TscrollPolicy;
+}
+
+declare interface PoiType extends EntityEidType, Partial<BasicInfoAtomType>, Partial<TransformAtom2DType>, Partial<VisibleAtomType>, Partial<EntityFlagAtomType>, Partial<EntityOutlinerAtomType> {
+    poiStyle?: Partial<PoiEntityAtomType>;
+    visible2D?: deepPartial<Visible2DAtomType>;
 }
 
 declare interface RegisterEvent {
@@ -364,7 +521,7 @@ declare interface RegisterEvent {
     func: (...args: any) => void;
 }
 
-export declare class Renderer {
+declare class Renderer {
     private _rendererEvent;
     private _viewer;
     private _removeEventsCache;
@@ -379,67 +536,61 @@ export declare class Renderer {
     emit(eventName: string, ...args: any): void;
 }
 
-export declare class RendererEvent extends Event_2 {
-    _viewer: Viewer;
-    constructor(viewer: Viewer);
-    on(type: any, callback: any, context?: any): Cesium.Event.RemoveCallback | undefined;
-}
-
-export declare const RenderEventType: {
-    onVideoReady: string;
-    stopedRenderCloud: string;
-};
-
-export declare const RenderSceneEventType: {
-    OnWdpSceneIsReady: string;
-    OnWdpSceneChanged: string;
-    OnMouseEnterEntity: string;
-    OnMouseOutEntity: string;
-    OnEntityClicked: string;
-    OnEntityDbClicked: string;
-    OnWebJSEvent: string;
-    MeasureResult: string;
-    OnMoveAlongPathProcessEvent: string;
-    OnRealTimeVideoEvent: string;
-    OnMoveAlongPathEndEvent: string;
-    OnCameraMotionStartEvent: string;
-    OnCameraMotionEndEvent: string;
-    OnCameraRoamingFrame: string;
-    PickPointEvent: string;
-    OnEntitySelectionChanged: string;
-    OnEntityNodeSelectionChanged: string;
-    OnEntityReady: string;
-    OnCreateGeoLayerEvent: string;
-    OnGeoLayerFeatureClicked: string;
-};
-
-export declare class Scene {
+declare class Scene_2 {
     private _viewer;
+    private _entitys;
+    private _layers;
+    get entitys(): any[];
+    get layers(): any[];
     constructor(viewer: Viewer);
-}
-
-export declare class SceneEvent extends Event_2 {
+    Add(entity: any, operations?: IOperations): void;
+    Update(): void;
+    Updates(): void;
+    Create(): void;
+    Creates(): void;
+    GetAll(): void;
+    GetLayers(): any[];
+    GetByEids(eids: string[]): Promise<{
+        message: any;
+        success: boolean;
+        result: any;
+    }>;
+    GetByEntityName(): void;
+    GetByCustomId(): void;
+    GetByTypes(): void;
+    Delete(): void;
+    _DeleteCache(id: string): void;
+    ClearByTypes(): void;
+    ClearByObjects(): void;
+    ClearByEids(): void;
+    ClearByCustomId(): void;
+    ClearByEntityName(): void;
+    UpdateByCustomId(): void;
+    UpdateByCustomIds(): void;
+    UpdateByEntityName(): void;
+    UpdateByEntityNames(): void;
+    SetVisibleByObjects(): void;
+    SetVisible(): void;
+    SetLocation(): void;
+    SetLocations(): void;
+    SetRotator(): void;
+    SetRotators(): void;
+    SetScale3D(): void;
+    SetScale3Ds(): void;
+    SetLocked(): void;
+    GetBound(): void;
+}
+
+declare class SceneEvent extends Event_2 {
     _camera: Camera;
-    _scene: Scene_2;
+    _scene: Scene;
     _clock: Clock;
     constructor(viewer: Viewer);
     on(type: any, callback: any, context?: any): Event_3.RemoveCallback | undefined;
     off(type: any, callback: any, context?: any): boolean;
 }
 
-export declare const SceneEventType: {
-    CAMERA_MOVE_END: string;
-    CAMERA_CHANGED: string;
-    PRE_UPDATE: string;
-    POST_UPDATE: string;
-    PRE_RENDER: string;
-    POST_RENDER: string;
-    MORPH_COMPLETE: string;
-    CLOCK_TICK: string;
-    RENDER_ERROR: string;
-};
-
-export declare class SkyBox {
+declare class SkyBox {
     private _defaultSkyBox;
     private _groundSkyBox;
     private _height;
@@ -467,7 +618,7 @@ export declare class SkyBox {
 
 declare const SkyBox_2: any;
 
-export declare class Terrain {
+declare class Terrain {
     private _scene;
     constructor(scene: Cesium.Scene);
     createEllipsoidTerrain(options?: ConstructorParameters<typeof Cesium.EllipsoidTerrainProvider>[0]): Promise<Cesium.EllipsoidTerrainProvider>;
@@ -485,26 +636,24 @@ declare class TianDiTuImageryProvider extends Cesium.UrlTemplateImageryProvider
     constructor(options: imageryProviderOptions);
 }
 
-export declare class Tools {
+declare type Tjustification = 'Left' | 'Center' | 'Right';
+
+declare class Tools {
     private _coordinate;
     constructor(viewer: any);
     get Coordinate(): Coordinate;
 }
 
-export declare class Transform {
-    static transformCartesianToWGS84(cartesian: Cesium.Cartesian3): Position;
-    static transformCartographicToWGS84(cartographic: any): Position;
-    static transformWGS84ToCartesian(position: any): Cesium.Cartesian3;
-    static transformWGS84ToCartographic(position: any): Cesium.Cartographic;
-    static transformCartesianArrayToWGS84Array(cartesianArr: any): any;
-    static transformWGS84ArrayToCartesianArray(WGS84Arr: any): any;
-    static transformWGS84ToMercator(position: any): Position;
-    static transformMercatorToWGS84(position: any): Position;
-    static transformWindowToWGS84(position: any, viewer: Viewer): Position;
-    static transformWindowToCartesian(position: any, viewer: Viewer): any;
-    static transformWGS84ToWindow(position: any, viewer: any): Cesium.Cartesian2;
+/**
+ * @interface TransformAtom2DType
+ * @param {CoordType} location
+ */
+declare interface TransformAtom2DType {
+    location: CoordType_2;
 }
 
+declare type TscrollPolicy = 'default' | 'always';
+
 declare class Viewer {
     private _delegate;
     private _baseLayerPicker;
@@ -525,6 +674,7 @@ declare class Viewer {
     get clock(): Cesium.Clock;
     get scene(): Cesium.Scene;
     get camera(): Cesium.Camera;
+    get dataSources(): Cesium.DataSourceCollection;
     get canvas(): HTMLCanvasElement;
     get widgetContainer(): HTMLElement;
     get widgets(): {
@@ -535,37 +685,42 @@ declare class Viewer {
     get viewerEvent(): ViewerEvent;
     get sceneEvent(): SceneEvent;
     get Terrain(): Terrain;
-    get Scene(): Scene;
+    get Scene(): Scene_2;
     get CameraControl(): CameraControl;
     get Tools(): Tools;
+    get imageryLayers(): Cesium.ImageryLayerCollection;
+    get Poi(): typeof Poi;
     constructor(options: WWSYCesiumType);
     private init;
     destroy(): void;
     addBaseLayer(baseLayer: Cesium.ImageryLayer | Cesium.ImageryLayer[], options: BaseImageryLayer['options']): this;
     changeBaseLayer(index: number): void;
 }
-export { Viewer }
 export default Viewer;
 
-export declare class ViewerEvent extends Event_2 {
+declare class ViewerEvent extends Event_2 {
     constructor();
 }
 
-export declare const ViewerEventType: {
-    MOUSE_MOVE: Cesium.ScreenSpaceEventType;
-    WHEEL: Cesium.ScreenSpaceEventType;
-    ADD_LAYER: string;
-    REMOVE_LAYER: string;
-    ADD_EFFECT: string;
-    REMOVE_EFFECT: string;
-    LEFT_DOWN: Cesium.ScreenSpaceEventType;
-    LEFT_UP: Cesium.ScreenSpaceEventType;
-    CLICK: Cesium.ScreenSpaceEventType;
-    RIGHT_DOWN: Cesium.ScreenSpaceEventType;
-    RIGHT_UP: Cesium.ScreenSpaceEventType;
-    RIGHT_CLICK: Cesium.ScreenSpaceEventType;
-    DB_CLICK: Cesium.ScreenSpaceEventType;
-};
+/**
+ * @interface Visible2DAtomType
+ * @param {ICamera} camera
+ * @param {IInteraction} interaction
+ * @param {IEntity} entity
+ */
+declare interface Visible2DAtomType {
+    camera: ICamera;
+    interaction: IInteraction;
+    entity: IEntity;
+}
+
+/**
+ * @interface VisibleAtomType
+ * @param {boolean} bVisible
+ */
+declare interface VisibleAtomType {
+    bVisible: boolean;
+}
 
 declare class Widget {
     _enable: boolean;
@@ -585,6 +740,8 @@ declare interface WWSYCesiumType {
     layerSource?: layerSource;
     layerType?: 'vector' | 'raster' | 'topography';
     layerMark?: boolean;
+    resolution: [number, number];
+    northFixAngle?: number;
 }
 
 export { }