import type { AllGeoJSON } from '@turf/turf';
import * as Cesium from 'cesium';
import type { Heatmap } from '@zouyaoji/heatmap.js';
import type { Rectangle } from 'cesium';
import * as turf from '@turf/turf';

/**
 * 添加widget button控件
 * @param earth - earth实例
 * @param btns - 按钮构造参数，可以是数组同时添加多个
 * @param options - 配置项
 * @param options.insertIndex - 插入位置，默认最后
 * @param options.customContainer - 自定义承载容器
 */
declare function addButton(earth: Earth, btns: WidgetButtonOptions | WidgetButtonOptions[], options?: {
    insertIndex?: number;
    customContainer?: HTMLElement;
}): void;

/**
 * 在元素上添加指定的name的class样式
 * @param el - DOM元素
 * @param name - class样式名称
 * @group 功能: Dom操作相关
 */
declare function addClass(el: HTMLElement, name: string): void;

/**
 * 对坐标（或坐标数组）增加 指定的海拔高度值
 * @param positions - 笛卡尔坐标数组
 * @param addHeight - 增加的海拔高度值
 * @returns 增加高度后的坐标（或坐标数组）`Cesium.Cartesian3|Cesium.Cartesian3[]`
 */
declare function addPositionsHeight(positions: Cesium.Cartesian3 | Cesium.Cartesian3[], addHeight?: number): Cesium.Cartesian3 | Cesium.Cartesian3[];

/**
 * 使用A*算法实现基于高程的最优路径规划
 * @param viewer - Cesium.Viewer实例
 * @param startPoint - 起点坐标，类型为ParserLatLngPointInput
 * @param endPoint - 终点坐标，类型为ParserLatLngPointInput
 * @param options - 配置选项，可选参数，默认为空对象
 * @param options.boxScale - 起点与终点组成矩形的放大倍数，作为寻路网格，默认为3
 * @param options.maxSlope - 设置可以通过的最大坡度，用于筛选可行走区域，取值范围为0到90度，默认为20
 * @param options.gridSize - 网格边长大小，单位米，网格越小精度越高，计算耗时越长，默认为50
 * @param options.splitGrid - 单个网格插值个数，对边线插值点，用于计算单个网格最大坡度，插值点数量越多，计算耗时越长，默认为10
 * @param options.colorRamp - 色带数组，一个包含键值对的数组，键是数值，值是对应的颜色字符串，默认为`[{ color: '#00FF00', value: 0 },{ color: '#FFFB00FF', value: 20 },{ color: '#FFB300FF', value: 30 },{ color: '#FF0000FF', value: 40 },{ color: '#240144', value: 90 }]`
 */
declare function astarElevationPathfinding(viewer: Cesium.Viewer, startPoint: ParserLatLngPointInput, endPoint: ParserLatLngPointInput, options?: {
    boxScale?: number;
    maxSlope?: number;
    gridSize?: number;
    splitGrid?: number;
    colorRamp?: ColorRamp_2;
}): Promise<{
    roadPath: number[][];
    gridList: any[];
    colorRampLegend: {
        ctx: CanvasRenderingContext2D;
        canvas: HTMLCanvasElement;
        image: string;
    } | undefined;
    gridGroundPrimitive: Cesium.GroundPrimitive | undefined;
    message: string;
}>;

/**
 * 基础类，SDK中所有类的基类
 */
declare abstract class BaseClass {
    #private;
    /** 原始构造参数备份 */
    readonly originOptions: any;
    /** 实例的唯一ID */
    readonly uuid: string;
    /**
     * 事件回调
     */
    protected _onEventHook?: Function | undefined;
    /**
     * 事件集合
     */
    protected _events?: Record<string, BaseListener[]>;
    /**
     * 事件广播传递的父元素集合
     */
    protected _eventParents?: Record<string, BaseClass>;
    /**
     * @param originOptions 构造参数
     * @returns 实例对象
     */
    constructor(originOptions?: any);
    /**
     * 内部on事件处理
     * @param type
     * @param fn
     * @param context
     */
    protected _on(type: EventTypeValue | string, fn: Function, context?: any): void;
    /**
     * 内部off事件处理
     * @param type
     * @param fn
     * @param context
     */
    protected _off(type: EventTypeValue | string, fn: Function, context?: any): void;
    /**
     *  事件广播
     * @param event - 事件信息
     */
    protected _propagateEvent(event: BaseEvent): void;
    /**
     * 销毁当前对象，delete所有属性
     */
    destroy(force?: boolean): void;
    /**
     * 绑定指定类型事件监听器，支持在监听中调用 event.stopPropagation() 组织事件冒泡
     * @param types - 事件类型
     * @param fn - 绑定的监听器回调方法
     * @param context - 侦听器的上下文(this关键字将指向的对象)。
     * @return 当前对象本身，可以链式调用
     * @group 方法: 事件相关
     */
    on(types: EventTypeValue | EventTypeValue[] | Record<EventTypeValue, any> | string | string[] | Record<any, any>, fn: Function, context?: any): this;
    /**
     * 解除绑定指定类型事件监听器
     * @param types - 事件类型,未传值时解绑所有事件
     * @param fn - 绑定的监听器回调方法,未传值时解绑所有指定类型对应事件
     * @param context - 侦听器的上下文(this关键字将指向的对象)。
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    off(types: EventTypeValue | EventTypeValue[] | Record<EventTypeValue, any> | string | string[] | Record<any, any>, fn: Function, context?: any): this;
    /**
     * 触发指定类型的事件。
     * @param type 事件类型
     * @param data 传输的数据或对象，可在事件回调方法中event对象中获取进行使用
     * @param propagate 将事件传播给父类 (用addEventParent设置)
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    emit(type: EventTypeValue | string, data?: any, propagate?: boolean): this;
    /**
     * 绑定一次性执行的指定类型事件监听器，与on类似，监听器只会被触发一次，然后被删除
     * @param types - 事件类型
     * @param fn - 绑定的监听器回调方法
     * @param context - 侦听器的上下文(this关键字将指向的对象)
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    once(types: EventTypeValue | EventTypeValue[] | Record<EventTypeValue, any> | string | string[] | Record<any, any>, fn: Function, context?: any): this;
    /**
     * 是否有绑定指定的事件
     * @param type - 事件类型
     * @param propagate - 是否判断指定的父类 (用addEventParent设置的)
     * @return 是否存在
     * @group 方法: 事件相关
     */
    hasListener(type: EventTypeValue | string, propagate?: boolean): boolean;
    /**
     * 添加抛出事件到父类，它将接收传播的事件
     * @param obj - 父类对象
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    addEventParent(obj: BaseClass): this;
    /**
     * 移除抛出事件到父类
     * @param obj - 父类对象
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    removeEventParent(obj: BaseClass): this;
    /**
     * 是否绑定了抛出事件到指定父类
     * @param obj - 父类对象
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    hasEventParent(obj: BaseClass): boolean;
}

/**
 * 基础特效抽象类（所有特效类的基类） - ^[请勿实例化该类]
 */
declare abstract class BaseEffect extends BaseClass {
    /**
     * 特效类型
     */
    protected abstract _type: EffectTypeKey;
    /**
     * 特效启用状态
     */
    protected _enable: boolean;
    /**
     * 状态： "created" | "inited" | "added" | "removed" | "destroyed"
     */
    protected _state: StateValue;
    /**
     * 是否已完成特效初始化
     */
    protected _initCompleted?: boolean;
    /**
     * Cesium后期特效实例对象
     */
    protected abstract _postProcessStage?: Cesium.PostProcessStage;
    /** 当前Earth管理类实例 */
    _earth?: Earth;
    /** BaseEffect构造参数 */
    options: BaseEffectOptions;
    /**
     * @param options - 基础特效类构造参数
     */
    constructor(options?: BaseEffectOptions);
    /**
     * 特效内部的Cesium.PostProcessStage实例
     * @readonly
     */
    get target(): Cesium.PostProcessStage | undefined;
    /**
     * 获取特效所属的earth实例
     * @@readonly
     */
    get earth(): Earth | undefined;
    /**
     * 获取Cesium.Viewer实例
     * @@readonly
     */
    get viewer(): Cesium.Viewer | undefined;
    /**
     * 特效类型
     * @readonly
     */
    get type(): "fog" | "rain" | "snow" | "snowCover" | "lightning";
    /**
     * 当前对象的状态
     * @readonly
     */
    get state(): StateValue;
    /**
     * 获取启用状态
     */
    get enable(): boolean;
    /**
     * 设置启用状态
     */
    set enable(val: boolean);
    /**
     * 对象添加到地球前内部初始化的钩子函数，只会调用一次，此时已赋值`_earth`
     */
    protected abstract _initHooks(): Promise<void>;
    /**
     * 对象添加到地球上时的钩子函数，每次add时都会调用，此时已赋值`_earth`
     */
    protected abstract _addHooks(): Promise<void>;
    /**
     * 对象从地球上移除而不销毁的钩子函数，每次remove时都会调用
     */
    protected abstract _removeHooks(): void;
    /**
     * 对象销毁的钩子函数
     */
    protected abstract _destroyHooks(): void;
    /**
     * 启用状态变化时的钩子函数
     * @param val
     */
    protected abstract _enableHooks(val: boolean): void;
    /**
     * 添加到地球上的钩子方法，earth内部会调用该函数
     * @param earth - Earth实例
     * @hidden
     */
    _onAdd(earth: Earth): Promise<void>;
    /**
     * 从地球上移除的钩子方法，earth内部会调用该函数
     * @hidden
     */
    _onRemove(): void;
    /**
     * 设置启用状态
     * @param val
     */
    setEnable(val: boolean): void;
    /**
     * 添加到地球上，同`earth.addEffect`
     * @param earth - Earth实例
     */
    addTo(earth: Earth): void;
    /**
     * 移除特效，同`earth.removeEffect`
     * @param isDestroy - 是否destroy销毁释放对象，默认值：false
     */
    removeTo(isDestroy?: boolean): void;
    /**
     * 判断是否已经完成加载并添加到地球上
     * @returns 返回一个`Promise<BaseEffect>`，BaseEffect为泛型，可自行指定
     */
    addedPromise<T extends BaseEffect = BaseEffect>(): Promise<T>;
    /**
     * 销毁释放对象
     */
    destroy(): void;
}

/**
 * 基础特效类构造参数类型
 */
declare interface BaseEffectOptions {
    /**
     * 特效是否显示，默认为true
     * @group BaseEffectOptions 特性参数
     */
    enable?: boolean;
    /**
     * 指定的事件冒泡对象，默认为earth对象，传入false时不冒泡
     * @group BaseEffectOptions 特性参数
     */
    eventParent?: BaseClass | false;
}

/**
 * 基类事件
 */
export declare interface BaseEvent<T = any> {
    data: T;
    sourceTarget: BaseClass;
    stopPropagation: () => void;
    target: BaseClass;
    type: EventTypeValue | string;
    _stopPropagation: boolean;
    /** 当图层事件被Earth监听时可用 */
    layer?: any;
    /** 父级监听到广播时可用 */
    propagatedFrom?: BaseClass;
}

declare abstract class BaseGraphicLayer extends BaseLayer {
    /** BaseGraphicLayer构造参数 */
    options: BaseGraphicLayerOptions;
    /**
     * 普通PrimitiveCollection数据集
     */
    protected _primitiveCollection?: Cesium.PrimitiveCollection;
    /**
     * 普通EntityCollection数据集
     */
    protected _dataSource?: Cesium.DataSource;
    constructor(options?: BaseGraphicLayerOptions);
    get isTile(): boolean;
    /**
     * 图层顺序层级
     */
    get zIndex(): number;
    /**
     * 设置图层顺序层级
     */
    set zIndex(val: number);
    get layerSource(): any;
    /**
     * 获取primitive数据集
     * @readonly
     */
    get primitiveCollection(): Cesium.PrimitiveCollection | undefined;
    /**
     * 获取entity数据集
     * @readonly
     */
    get dataSource(): Cesium.DataSource | undefined;
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _showHooks(val: boolean): void;
    protected _toJsonHooks(options: CreateLayerOptions): void;
    /**
     * 设置图层顺序层级
     * @param val
     */
    setZIndex(val: number): void;
}

declare interface BaseGraphicLayerOptions extends BaseLayerOptions {
    /**
     * 图层顺序，数字大的在上面
     * @group BaseGraphicLayerOptions 特性参数
     */
    zIndex?: number;
}

/**
 * 基础图层抽象类（所有图层类的基类） - ^[请勿实例化该类]
 */
declare abstract class BaseLayer extends BaseClass {
    /**
     * 支持的事件类型
     */
    static EventType: {
        openPopup: "openPopup";
        closePopup: "closePopup";
        destroyPopup: "destroyPopup";
        changePopupPosition: "changePopupPosition";
        showPopup: "showPopup";
        hidePopup: "hidePopup";
        add: "add";
        remove: "remove";
        addLayer: "addLayer";
        removeLayer: "removeLayer";
        show: "show";
        hide: "hide";
        click: "click";
        leftDown: "leftDown";
        leftUp: "leftUp";
        rightClick: "rightClick";
        rightDown: "rightDown";
        rightUp: "rightUp";
        middleClick: "middleClick";
        middleDown: "middleDown";
        middleUp: "middleUp";
        mouseDown: "mouseDown";
        mouseUp: "mouseUp";
        mouseOver: "mouseOver";
        mouseOut: "mouseOut";
    };
    /**
     * 图层类型
     */
    protected abstract _type: LayerTypeKey;
    /** 图层显隐 */
    protected _show: boolean;
    /** 状态： "created" | "inited" | "added" | "removed" | "destroyed" */
    protected _state: StateValue;
    /** 是否已完成图层初始化 */
    protected _initCompleted?: boolean;
    /** popup实例 */
    protected _popup?: Popup;
    /** 当前Earth管理类实例 */
    _earth?: Earth;
    /** BaseLayer构造参数 */
    options: BaseLayerOptions;
    /** 父级图层 */
    parent?: BaseLayer;
    /**
     * @param options - 基础图层类构造参数
     */
    constructor(options?: BaseLayerOptions);
    /**
     * 瓦片图层标识
     * @readonly
     */
    abstract get isTile(): boolean;
    /**
     * 图层融合数据源 - 可能是由DataSource或其他Collection数据源融合的数组，也可能是瓦片图层对应的内部Cesium.ImageryLayer对象或三维模型图层的Cesium.Cesium3DTileset对象或地形图层的Cesium.TerrainProvider对象
     * @readonly
     */
    abstract get layerSource(): any | any[];
    /**
     * 对象的id标识
     * @@readonly
     */
    get id(): string | number;
    /**
     * 对象的pid标识
     */
    get pid(): string | number;
    /**
     * 名称标识
     * @@readonly
     */
    get name(): string | number;
    /**
     * 获取图层所属的earth实例
     * @@readonly
     */
    get earth(): Earth | undefined;
    /**
     * 获取Cesium.Viewer实例
     * @@readonly
     */
    get viewer(): Cesium.Viewer | undefined;
    /**
     * 获取绑定的弹窗实例
     * @readonly
     */
    get popup(): Popup | undefined;
    /**
     * 图层类型
     * @readonly
     */
    get type(): "image" | "terrain" | "wms" | "wmts" | "xyz" | "tileset" | "geojson" | "group" | "colorPatternGrid" | "colorPatternGradient" | "heat" | "graphic";
    /**
     * 当前对象的状态
     * @readonly
     */
    get state(): StateValue;
    /**
     * 获取显隐
     */
    get show(): boolean;
    /**
     * 设置显隐状态
     */
    set show(val: boolean);
    /**
     * 对象添加到地图前内部初始化的钩子函数，只会调用一次，此时已赋值`_earth`
     */
    protected abstract _initHooks(): Promise<void>;
    /**
     * 对象添加到地球上时的钩子函数，每次add时都会调用，此时已赋值`_earth`
     */
    protected abstract _addHooks(): Promise<void>;
    /**
     * 对象从地球上移除而不销毁的钩子函数，每次remove时都会调用
     */
    protected abstract _removeHooks(): void;
    /**
     * 对象销毁的钩子函数
     */
    protected abstract _destroyHooks(): void;
    /**
     * 显隐状态变化时的钩子函数
     * @param val
     */
    protected abstract _showHooks(val: boolean): void;
    /**
     * 将图层转为Json简单对象的钩子函数
     * @param val
     */
    protected abstract _toJsonHooks(options: CreateLayerOptions): void;
    /**
     * 获取图层内所有数据的矩形范围边界值 - ^[函数重载]
     * @overload@overload
     */
    abstract getRectangle(isFormat: true): Extent | undefined;
    /**
     * 获取图层内所有数据的矩形范围边界值 - ^[函数重载]
     * @overload@overload
     */
    abstract getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    /**
     * 获取图层内所有数据的矩形范围边界值
     * @param isFormat - 是否格式化，格式化时示例： `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`，否则返回返回Cesium.Rectangle对象
     * @returns
     */
    abstract getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
    /**
     * 添加到地球上的钩子方法，earth内部会调用该函数
     * @param earth - Earth实例
     * @hidden
     */
    _onAdd(earth: Earth): Promise<void>;
    /**
     * 从地球上移除的钩子方法，earth内部会调用该函数
     * @hidden
     */
    _onRemove(): void;
    /**
     * 设置显隐状态
     * @param val
     */
    setShow(val: boolean): void;
    /**
     * 飞行定位至图层数据所在的视角
     * @param options - 飞行控制参数
     * @returns 返回一个是否调用成功的布尔值
     */
    flyTo(options?: FlyToControl | FlyToExtentControl): boolean;
    /**
     * 将图层转为Json简单对象，用于存储后再传参加载
     * @returns Json简单对象
     */
    toJSON(): CreateLayerOptions;
    /**
     * 添加到地球上，同`earth.addLayer`
     * @param earth - Earth实例
     */
    addTo(earth: Earth): void;
    /**
     * 移除图层，同`earth.removeLayer`
     * @param isDestroy - 是否destroy销毁释放对象，默认值：false
     */
    removeTo(isDestroy?: boolean): void;
    /**
     * 判断是否已经完成加载并添加到地球上
     * @returns 返回一个`Promise<BaseLayer>`，BaseLayer为泛型，可自行指定
     */
    addedPromise<T extends BaseLayer = BaseLayer>(): Promise<T>;
    /**
     * 绑定弹窗
     * @param options - 弹窗实例类构造参数
     */
    bindPopup(options?: PopupOptions): void;
    /**
     * 解除绑定弹窗
     */
    unbindPopup(): void;
    /**
     * 销毁释放对象
     */
    destroy(): void;
}

/**
 * 点击事件回调函数类型
 */
declare type BaseLayerClickEventFn = <T extends BaseLayer>(layer: T, event: BaseEvent<PickTargetInfo>) => any;

/**
 * 基础图层类构造参数类型
 */
declare interface BaseLayerOptions {
    /**
     * 图层id标识，默认为随机uuid
     * @group BaseLayerOptions 特性参数
     */
    id?: string | number;
    /**
     * 层父级的id，一般图层管理中使用，默认为-1
     * @group BaseLayerOptions 特性参数
     */
    pid?: string | number;
    /**
     * 图层名称，默认为uuid
     * @group BaseLayerOptions 特性参数
     */
    name?: string | number;
    /**
     * 图层是否显示，默认为true
     * @group BaseLayerOptions 特性参数
     */
    show?: boolean;
    /**
     * 图层自定义定位视角
     * @group BaseLayerOptions 特性参数
     */
    homeVision?: Vision;
    /**
     * 加载完成数据后是否自动飞行定位到数据所在的区域，默认为false
     * 以homeVision参数配置的图层自定义定位视角为最高优先级
     * @group BaseLayerOptions 特性参数
     */
    flyTo?: boolean;
    /**
     * 绑定鼠标点击弹窗
     * @group BaseLayerOptions 特性参数
     */
    popup?: PopupOptions | boolean;
    /**
     * 指定的事件冒泡对象，默认为earth对象，传入false时不冒泡
     * @group BaseLayerOptions 特性参数
     */
    eventParent?: BaseClass | false;
    /**
     * 内部使用的辅助图层标识(noLayerManage)，设置为true的不对外展示，如earth.getLayers方法将不会获取isInternal为true的图层
     * @group BaseLayerOptions 特性参数
     */
    isInternal?: boolean;
}

/**
 * 基类事件监听器，通常将一类事件的所有监听器以集合的形式存储
 */
declare interface BaseListener {
    fn: Function;
    ctx: object | undefined;
}

/**
 * 通用材质 转换处理类
 */
declare class BaseMaterialConver extends BaseOptsConver {
    /**
     * 转换为Cesium相关属性值
     * @param style - 样式配置
     * @param  czmVal - Cesium属性值
     * @returns Cesium属性值
     */
    static toCesiumVal(style: Record<string, any>, czmVal?: Record<string, any>): any;
    /**
     * 转换为json简单对象，用于导出
     * @param czmVal - Cesium属性值
     * @param style - json简单对象
     * @returns json简单对象
     */
    static toJSON(czmVal: Record<string, any>, style?: Record<string, any>): Record<string, any>;
    get excludedKeys(): string[];
    protected _toOneCesiumVal(key: string, value: any, style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toOneJson(key: string, value: any, style: Record<string, any>): void;
    protected _getExcludedStyle(): never[];
    toJSON(czmVal: Record<string, any>, style?: Record<string, any>): Record<string, any>;
}

/**
 * 材质属性抽象基础类 - ^[请勿实例化该类]
 */
declare abstract class BaseMaterialProperty {
    /**
     */
    protected _definitionChanged: Cesium.Event<(...args: any[]) => void>;
    /**
     */
    protected _color?: any;
    /**
     */
    protected _colorSubscription?: any;
    /**
     */
    protected _speed?: any;
    /**
     */
    protected _speedSubscription?: any;
    options: Record<string, any>;
    /**
     * @param options - 参数对象
     */
    constructor(options?: {});
    get isConstant(): boolean;
    get definitionChanged(): Cesium.Event<(...args: any[]) => void>;
    /**
     * 获取材质名称
     * @param time - 检索值的时间。
     * @returns 材质名称
     */
    abstract getType(time?: Cesium.JulianDate): string;
    /**
     * 获取所提供时间的属性值。
     * @param time - 检索值的时间。
     * @param result - 用于存储值的对象，如果省略，则创建并返回一个新的实例。
     * @returns 修改的result参数或一个新的实例(如果没有提供result参数)。
     */
    abstract getValue<T = any>(time?: Cesium.JulianDate, result?: T): T;
    /**
     * 将此属性与提供的属性进行比较并返回, 如果两者相等返回true，否则为false
     * @param other - 比较的对象
     * @returns 两者是否为同一个对象
     */
    abstract equals(other?: Cesium.Property): boolean;
}

/**
 * 转换options参数处理基类
 */
declare class BaseOptsConver {
    /**
     * 根据样式配置获取颜色
     * @param style - 样式配置
     * @returns 颜色
     */
    static getColorByStyle(style: Record<string, any>): Cesium.Color;
    options: Record<string, any>;
    constructor(options?: Record<string, any>);
    /**
     * 排除的不用处理的属性
     */
    get excludedKeys(): string[];
    /**
     * 需要导出的复杂属性
     */
    get exportKeys(): string[];
    protected _toCesiumValBefore(style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toCesiumValEnd(style: Record<string, any>, czmVal: Record<string, any>): void;
    /**
     * 通用处理
     * @param key
     * @param value
     * @param style
     * @param czmVal
     */
    protected _toOneCesiumVal(key: string, value: any, style: Record<string, any>, czmVal: Record<string, any>): void;
    /**
     * 将cesium属性转为style ，用于导出json
     * @param key
     * @param value
     * @param style
     */
    protected _toOneJson(key: string, value: any, style: Record<string, any>): void;
    /**
     * 转换为Cesium相关属性值
     * @param style - 样式配置
     * @param czmVal - Cesium属性值
     * @return Cesium属性值
     */
    toCesiumVal(style: Record<string, any>, czmVal?: Record<string, any>): Record<string, any>;
    /**
     * 转换为json简单对象，用于导出
     * @param czmVal - Cesium属性值
     * @param style - json简单对象
     * @returns json简单对象
     */
    toJSON(czmVal: Record<string, any>, style?: Record<string, any>): Record<string, any>;
    /**
     * 根据样式配置获取颜色
     * @param style - 样式配置
     * @returns Cesium.Color颜色
     */
    getColorByStyle(style: Record<string, any>): Cesium.Color;
    /**
     * 根据样式配置获取outline颜色
     * @param style - 样式配置
     * @returns Cesium.Color颜色
     */
    getOutlineColorByStyle(style: Record<string, any>): Record<string, any>;
}

/**
 * 矢量数据style转换处理基类
 */
declare class BaseStyleConver extends BaseOptsConver {
    isEntity?: boolean;
    get excludedKeys(): string[];
    protected _toCesiumValBefore(style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _getExcludedStyle(): string[];
    protected _toOneCesiumVal_Point(key: string, value: any, style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toOneCesiumVal_Poly(key: string, value: any, style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toOneJson_Poly(key: string, value: any, style: Record<string, any>): void;
    protected _toOneJson_Point(key: string, value: any, style: Record<string, any>): void;
}

/**
 * 基础瓦片图层抽象类（所有瓦片图层的基类） - ^[请勿实例化该类]
 */
declare abstract class BaseTileLayer extends BaseLayer {
    protected abstract _type: LayerTypeKey;
    /**
     * 透明度：0~1
     */
    protected _opacity: number;
    /**
     * 图层服务代理
     */
    protected _proxy?: Cesium.Proxy;
    /**
     * Cesium影像图层
     */
    protected _imageryLayer?: Cesium.ImageryLayer & {
        _kbe3d_layerId?: string | number;
        _kbe3d_zIndex?: number;
    };
    /**
     * 矩形范围边界
     */
    protected _rectangle: Cesium.Rectangle;
    /** BaseTileLayer构造参数 */
    options: BaseTileLayerOptions;
    /**
     * @param options - BaseTileLayer构造参数
     */
    constructor(options?: BaseTileLayerOptions);
    get isTile(): boolean;
    /**
     * 瓦片图层对应的内部ImageryLayer对象
     * @readonly
     */
    get layerSource(): Cesium.ImageryLayer | undefined;
    /**
     * 图层顺序层级
     */
    get zIndex(): number;
    /**
     * 设置图层顺序层级
     */
    set zIndex(val: number);
    /**
     * 瓦片图层对应的内部Cesium.ImageryProvider对象
     * @readonly
     */
    get imageryProvider(): Cesium.ImageryProvider | undefined;
    /**
     * 透明度，取值范围：0.0-1.0
     */
    get opacity(): number;
    /**
     * 设置透明度，取值范围：0.0-1.0
     */
    set opacity(val: number);
    /**
     * 透明度，同opacity。从0.0到1.0。
     */
    get alpha(): number;
    /**
     * 设置透明度，取值范围：0.0-1.0
     */
    set alpha(value: number);
    /**
     * 亮度，取值范围：0.0-3.0。
     */
    get brightness(): number | undefined;
    /**
     * 设置亮度，取值范围：0.0-3.0。
     */
    set brightness(value: number);
    /**
     * 对比度，取值范围：0.0-3.0，1.0使用未修改的图像颜色，小于1.0会降低对比度，而大于1.0则会提高对比度。
     */
    get contrast(): number;
    /**
     * 设置对比度，取值范围：0.0-3.0，1.0使用未修改的图像颜色，小于1.0会降低对比度，而大于1.0则会提高对比度。
     */
    set contrast(value: number);
    /**
     * 色调，取值范围：0.0-3.0，0.0 时未修改的图像颜色。
     */
    get hue(): number;
    /**
     * 设置色调，取值范围：0.0-3.0，0.0 时未修改的图像颜色。
     */
    set hue(value: number);
    /**
     * 饱和度，取值范围：0.0-3.0，1.0使用未修改的图像颜色，小于1.0会降低饱和度，而大于1.0则会增加饱和度。
     */
    get saturation(): number;
    /**
     * 设置饱和度，取值范围：0.0-3.0，1.0使用未修改的图像颜色，小于1.0会降低饱和度，而大于1.0则会增加饱和度。
     */
    set saturation(value: number);
    /**
     * 伽马校正值，取值范围：0.0-3.0，1.0使用未修改的图像颜色。
     */
    get gamma(): number;
    /**
     * 设置伽马校正值，取值范围：0.0-3.0，1.0使用未修改的图像颜色。
     */
    set gamma(value: number);
    /**
     * 瓦片数据范围
     */
    get rectangle(): Cesium.Rectangle;
    /**
     * 设置瓦片数据范围
     */
    set rectangle(value: Cesium.Rectangle);
    /**
     * 创建瓦片图层对应的ImageryProvider对象
     * @param options - 参数对象，具体每类瓦片图层都不一样 - {@link ImageryProvider}
     * @returns 创建完成的 Cesium.ImageryProvider 对象
     */
    protected abstract _createImageryProvider(options: any): Cesium.ImageryProvider | Promise<Cesium.ImageryProvider>;
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _showHooks(val: boolean): void;
    protected _toJsonHooks(options: CreateLayerOptions): void;
    /**
     * 设置图层顺序层级
     */
    setZIndex(val: number): void;
    setOpacity(val: number): void;
    /**
     * 设置透明度，取值范围：0.0-1.0
     * @param value
     */
    setAlpha(value: number): void;
    /**
     * 设置亮度，取值范围：0.0-1.0。
     * @param value
     */
    setBrightness(value: number): void;
    /**
     * 设置对比度。 1.0使用未修改的图像颜色，小于1.0会降低对比度，而大于1.0则会提高对比度。
     * @param value
     */
    setContrast(value: number): void;
    /**
     * 设置色调。 0.0 时未修改的图像颜色。
     * @param value
     */
    setHue(value: number): void;
    /**
     * 设置饱和度。 1.0使用未修改的图像颜色，小于1.0会降低饱和度，而大于1.0则会增加饱和度。
     * @param value
     */
    setSaturation(value: number): void;
    /**
     * 设置伽马校正值。 1.0使用未修改的图像颜色。
     * @param value
     */
    setGamma(value: number): void;
    /**
     * 设置瓦片数据范围
     */
    setRectangle(value: Cesium.Rectangle): void;
    /**
     * 获取瓦片图层的矩形范围边界值 - ^[函数重载]
     * @overload@overload
     */
    getRectangle(isFormat: true): Extent | undefined;
    /**
     * 获取瓦片图层的矩形范围边界值 - ^[函数重载]
     * @overload@overload
     */
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    /**
     * 获取瓦片图层的矩形范围边界值 - ^[函数重载]
     * @overload@overload
     */
    getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
}

/**
 * 基础瓦片图层类构造参数类型
 * @remarks 其他参数，详细见各个{@link Cesium.ImageryProvider}对应的图层类构造方法的参数
 */
declare interface BaseTileLayerOptions extends BaseLayerOptions {
    /**
     * 图层顺序，数字大的在上面
     * @group BaseTileLayerOptions 特性参数
     */
    zIndex?: number;
    /**
     * 图层的矩形范围
     * 输入格式可以是英文逗号隔开的字符串: `xxx,xxx,xxx,xxx`、数组: `[xxx, xxx, xxx, xxx]`、对象: `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`、或`Cesium.Rectangle`对象
     * 不管输入格式如何，都应遵循xmin,ymin,xmax,ymax的顺序，最终将输入格式转换为Cesium.Rectangle格式，默认值为 `Cesium.Rectangle.MAX_VALUE`
     * @default Cesium.Rectangle.MAX_VALUE
     */
    rectangle?: ParserRectangleInput;
    /**
     * 图层透明度， 取值范围：0.0-1.0(与opacity二选一即可，两个都存在时alpha优先)，默认值：1
     * @group BaseTileLayerOptions 特性参数
     */
    alpha?: number;
    /**
     * 当启用日照阴影时，夜间图层透明度，取值范围：0.0-1.0(与opacity二选一即可，两个都存在时alpha优先)，默认值：1
     * @group BaseTileLayerOptions 特性参数
     */
    nightAlpha?: number;
    /**
     * 当启用日照阴影时，日间图层透明度，取值范围：0.0-1.0(与opacity二选一即可，两个都存在时alpha优先)，默认值：1
     * @group BaseTileLayerOptions 特性参数
     */
    dayAlpha?: number;
    /**
     * 亮度，取值范围：0.0-3.0，默认值：1
     * @group BaseTileLayerOptions 特性参数
     */
    brightness?: number;
    /**
     * 对比度，取值范围：0.0-3.0，1.0使用未修改的图像颜色，小于1.0会降低对比度，而大于1.0则会提高对比度，默认值：1
     * @group BaseTileLayerOptions 特性参数
     */
    contrast?: number;
    /**
     * 色调，取值范围：0.0-3.0，0.0使用未修改的图像颜色，默认值：0
     * @group BaseTileLayerOptions 特性参数
     */
    hue?: number;
    /**
     * 饱和度，取值范围：0.0-3.0，1.0使用未修改的图像颜色，小于1.0会降低饱和度，而大于1.0则会增加饱和度，默认值：1
     * @group BaseTileLayerOptions 特性参数
     */
    saturation?: number;
    /**
     * 伽马校正值，取值范围：0.0-3.0，1.0使用未修改的图像颜色，默认值：1
     * @group BaseTileLayerOptions 特性参数
     */
    gamma?: number;
    /**
     * 图层透明度，取值范围：0~1
     * @group BaseTileLayerOptions 特性参数
     */
    opacity?: number;
    /**
     * 图层代理服务，服务本身需要自行使用nginx或其他手段保证其存在
     * @group BaseTileLayerOptions 特性参数
     */
    proxy?: Cesium.Proxy | string;
    /**
     * 瓦片数据的坐标系信息，默认为墨卡托投影 `CRS.EPSG3857` {@link CRSValue}
     */
    crs?: CRSValue;
    /**
     * 标识瓦片的国内坐标系（用于自动纠偏或加偏），自动将瓦片转为map对应的chinaCRS类型坐标系 {@link ChinaCRSValue}
     */
    chinaCRS?: ChinaCRSValue;
    [x: string]: any;
}

/**
 * 经纬度坐标转换，
 * 百度坐标 (BD09) 转换为 国测局坐标 (GCJ02)
 * @param arrdata - 百度坐标 (BD09)坐标数据，示例：[117.225590,31.832916]
 * @returns 国测局坐标 (GCJ02)坐标数据，示例：[117.22559,31.832917]
 * @group 功能: 坐标转换相关
 */
declare function bd2gcj(arrdata: number[]): number[];

/**
 * 百度坐标 (BD09) 转 标准无偏坐标（WGS84）
 * @param arrdata - 百度坐标 (BD09)坐标数据，示例：[117.232039,31.839177]
 * @returns 标准无偏坐标（WGS84）坐标数据，示例：[117.220102, 31.834912]
 * @group 功能: 坐标转换相关
 */
declare function bd2wgs(arrdata: number[]): number[];

declare namespace camera {
    export {
        isCenter,
        isExtent,
        cancelFlyTo,
        flyTo,
        flyToPoint,
        flyToExtent,
        flyToPositions,
        getCameraDistance,
        getCameraVision,
        getExtent,
        zoomIn,
        zoomOut,
        getCameraAltitude,
        getZoomLevelByCameraAltitude,
        Center,
        Orientation,
        Rotation,
        Extent,
        Vision,
        CameraViewInfo,
        FlyToControl,
        FlyToPointControl,
        FlyToExtentControl,
        FlyToOptions,
        FlyToExtentOptions,
        FlyToPointOptions
    }
}

/**
 * 相机视角信息
 */
declare interface CameraViewInfo extends Center, Orientation {
}

/**
 * 取消视角飞行
 * @param viewer - Cesium.Viewer实例
 */
declare function cancelFlyTo(viewer: Cesium.Viewer): void;

/**
 * Cesium笛卡尔空间坐标 转 经纬度坐标
 * 常用于转换geojson
 * @param cartesian - Cesium笛卡尔空间xyz坐标
 * @param noAlt - 是否包含高度值
 * @returns 经纬度坐标，示例：[123.123456, 32.654321, (可选)198.7]
 * @group 功能: 坐标转换相关
 */
declare function cartesian2lonlat(cartesian: Cesium.Cartesian3, noAlt?: boolean): number[] | null;

/**
 * Cesium笛卡尔空间坐标 转 WebMercator投影平面坐标
 * @param position - Cesium笛卡尔空间xyz坐标
 * @returns 墨卡托投影平面坐标，示例：[13048882, 3741659, 20.1]，如果输入无效则返回null
 * @group 功能: 坐标转换相关
 */
declare function cartesian2mercator(position: Cesium.Cartesian3): number[] | null;

/**
 * Cesium笛卡尔空间坐标数组 转 经纬度坐标数组
 * 常用于转换geojson
 * @param positions {Cesium.Cartesian3[]} Cesium笛卡尔空间xyz坐标数组
 * @param noAlt {boolean} [noAlt=false] 是否包含高度值
 * @returns {number[][]} 经纬度坐标数组，示例：[ [123.123456, 32.654321, (可选)198.7], ... ]
 * @group 功能: 坐标转换相关
 */
declare function cartesians2lonlats(positions: Cesium.Cartesian3[], noAlt?: boolean): number[][];

/**
 * Cesium笛卡尔空间坐标数组 转 WebMercator投影平面坐标数组
 * @param positions - Cesium笛卡尔空间xyz坐标数组
 * @returns WebMercator投影平面坐标数组，示例：[[13048882, 3741659, 20.1], [13048882, 3741659, 21.2]]，如果输入无效则返回null
 * @group 功能: 坐标转换相关
 */
declare function cartesians2mercators(positions: Cesium.Cartesian3[]): number[][] | null;

/** 中心点 */
declare interface Center {
    /** Center纬度值: -90 至 90 */
    lat: number;
    /** Center经度值: -180 至 180 */
    lng: number;
    /** Center高度值，单位：米 */
    alt: number;
}

export { Cesium }

/**
 * 国内偏移坐标系枚举
 * @enum
 */
declare const ChinaCRS: {
    /**
     * 标准无偏坐标系
     */
    readonly WGS84: "WGS84";
    /**
     * 国测局(GCJ02)偏移坐标系
     */
    readonly GCJ02: "GCJ02";
    /**
     * 百度(BD09) 偏移坐标系
     */
    readonly BD09: "BD09";
};

/**
 * 国内偏移坐标系key联合类型
 */
declare type ChinaCRSKey = keyof typeof ChinaCRS;

/**
 * 国内偏移坐标系value联合类型
 */
declare type ChinaCRSValue = (typeof ChinaCRS)[keyof typeof ChinaCRS];

/**
 * 面状: 圆形扫描效果材质类
 */
declare class CircleScanMaterialProperty extends BaseMaterialProperty {
    protected _image: string;
    constructor(options: CircleScanMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "CircleScan";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状: 圆形扫描效果材质构造器类型
 */
declare interface CircleScanMaterialPropertyOptions {
    /**
     * 背景图片URL
     */
    image: string;
    /**
     * 扫描效果的颜色。可以是字符串（CSS颜色值）或Cesium.Color对象
     * 默认为红色半透明（new Cesium.Color(1, 0, 0, 0.5)）
     * 注意：在TypeScript接口中，我们不能直接设置默认值。这个默认值应在使用接口时提供
     */
    color?: string | Cesium.Color;
}

/**
 * 面状: 圆形扩散波纹效果材质类
 */
declare class CircleWaveMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _count: number;
    /**
     */
    protected _gradient: number;
    constructor(options?: CircleWaveMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "CircleWave";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状: 圆形扩散波纹效果的材质构造器类型
 */
declare interface CircleWaveMaterialPropertyOptions {
    /**
     * 波纹的颜色，默认为Cesium的黄色（Cesium.Color.YELLOW）
     */
    color?: Cesium.Color | string;
    /**
     * 波纹扩散的速度，默认为10
     */
    speed?: number;
    /**
     * 显示的圆圈个数，默认为1
     */
    count?: number;
    /**
     * 透明度的幂方（0-1），用于控制波纹的虚化效果，0表示无虚化效果，1表示完全均匀渐变，默认为0.1
     */
    gradient?: number;
}

/**
 * 裁剪模型方向枚举
 * @enum
 */
declare const ClipType: {
    /** z水平面, 切底部 */
    readonly Z: 1;
    /** z水平面，切顶部 */
    readonly ZR: 2;
    /** x垂直面,切西向 */
    readonly X: 3;
    /** x垂直面,切东向 */
    readonly XR: 4;
    /** y垂直面, 切南向 */
    readonly Y: 5;
    /** y垂直面，切北向 */
    readonly YR: 6;
};

/**
 * 裁剪模型key联合类型
 */
declare type ClipTypeKey = keyof typeof ClipType;

/**
 * 裁剪模型value联合类型
 */
declare type ClipTypeValue = (typeof ClipType)[keyof typeof ClipType];

/** 云层渲染配置项，用于添加积云效果 */
declare interface CloudOptions {
    /**
     * 是否显示云层。默认为 `true`。
     */
    show?: boolean;
    /**
     * 噪声纹理中期望的细节量。数值越大，细节越丰富。默认为 `16.0`。
     */
    noiseDetail?: number;
    /**
     * 噪声纹理中数据的期望偏移量。默认为 `Cartesian3.ZERO`，表示无偏移。
     */
    noiseOffset?: Cesium.Cartesian3;
    /**
     * 仅用于调试。确定是否以不透明颜色渲染广告牌。默认为 `false`。
     */
    debugBillboards?: boolean;
    /**
     * 仅用于调试。确定云层是否以不透明椭球体形式渲染。默认为 `false`。
     */
    debugEllipsoids?: boolean;
}

/**
 * 聚合渲染配置项，用于设置Entity点数据的聚合相关参数。
 */
declare interface ClusteringOptions {
    /**
     * 是否开启聚合。
     * @default false
     */
    enabled?: boolean;
    /**
     * 多少像素矩形范围边界内聚合。
     * @default 20
     */
    pixelRange?: number;
    /**
     * 是否贴地显示聚合点。
     * @default true
     */
    clampToGround?: boolean;
    /**
     * 内置样式时，圆形图标的半径大小（单位：像素）。
     * @default 30
     */
    radius?: number;
    /**
     * 内置样式时，数字的颜色。
     * @default '#ffffff'
     */
    fontColor?: string;
    /**
     * 内置样式时，圆形图标的背景颜色。
     * @default 'rgba(181, 226, 140, 0.6)'
     */
    color?: string;
    /**
     * 内置样式时，圆形图标的透明度。
     * @default 0.5
     */
    opacity?: number;
    /**
     * 圆形图标的边框宽度（单位：像素），0不显示。
     * @default 5
     */
    borderWidth?: number;
    /**
     * 内置样式时，圆形图标的边框颜色。
     * @default 'rgba(110, 204, 57, 0.5)'
     */
    borderColor?: string;
    /**
     * 内置样式时，圆形图标边框的透明度。
     * @default 0.6
     */
    borderOpacity?: number;
    /**
     * 处理聚合图标被模型遮挡的问题，z值越小，图标则越接近屏幕，但是当视高处于该z值绝对值以下时，将无法看到。
     * @default new Cesium.Cartesian3(0, 0, -100)
     */
    eyeOffset?: Cesium.Cartesian3;
    /**
     * 自定义聚合的图标样式。
     * @param count - 聚合中的点数。
     * @returns 返回自定义的图标图像。
     */
    getImage?: (count: number) => any;
}

/**
 * 颜色材质 转换处理类
 */
declare class ColorOptsConver extends BaseMaterialConver {
    /**
     * 转换为Cesium相关属性值
     * @param style - 样式配置
     * @param czmVal - Cesium属性值
     * @param isProperty - 是否为Property
     * @return Cesium属性值
     */
    static toCesiumVal(style: Record<string, any>, czmVal?: Record<string, any>, isProperty?: boolean): any;
    static toJSON(czmVal: Record<string, any>, style?: Record<string, any>, isProperty?: boolean): any;
    toCesiumVal(style: Record<string, any>): Cesium.Color | {
        color: Cesium.Color;
    };
    toJSON(czmVal: Record<string, any>, style?: Record<string, any>): Record<string, any>;
}

/**
 * colorPatternGradient色斑晕染图层类
 * @see {@link ftp://baseProxy/views/demos/layer/color-pattern-gradient/ | 查看演示效果}
 * @example
 * ```ts
 * const colorPatternGradientLayer = new KBE3D.layers.ColorPatternGradientLayer({
 id: 'test-colorPatternGradient',
 name: 'test-colorPatternGradient-name',
 flyTo: true,
 rectangle: [60, -10, 150, 60],
 height: 0,
 aboveGround: true,
 colorRamp: [
 {
 color: '#1dff74',
 value: -40,
 },
 {
 color: '#67fe20',
 value: -36,
 },
 {
 color: '#8aff54',
 value: -32,
 },
 {
 color: '#9eff6c',
 value: -28,
 },
 {
 color: '#aaff83',
 value: -24,
 },
 {
 color: '#b8ff98',
 value: -20,
 },
 {
 color: '#d7fe97',
 value: -16,
 },
 {
 color: '#fcfc98',
 value: -12,
 },
 {
 color: '#fee168',
 value: -8,
 },
 {
 color: '#ffdc59',
 value: -4,
 },
 {
 color: '#ffcc04',
 value: 0,
 },
 {
 color: '#feba01',
 value: 4,
 },
 {
 color: '#faa600',
 value: 8,
 },
 {
 color: '#ff8a00',
 value: 12,
 },
 {
 color: '#f7740a',
 value: 16,
 },
 {
 color: '#fd5c14',
 value: 20,
 },
 {
 color: '#ff4432',
 value: 24,
 },
 {
 color: '#ff3610',
 value: 28,
 },
 {
 color: '#f4272f',
 value: 32,
 },
 {
 color: '#cd1320',
 value: 36,
 },
 {
 color: '#9e0007',
 value: 40,
 },
 {
 color: '#760006',
 value: 41,
 },
 ],
 uniformOptions: {
 alpha: 0.8,
 image: (await import('./assets/tempreatrue.png')).default,
 },
 })
 earth.addLayer(colorPatternGradientLayer)
 await colorPatternGradientLayer.addedPromise()
 //  do something...
 * ```
 */
declare class ColorPatternGradientLayer extends BaseGraphicLayer {
    protected _type: LayerTypeKey;
    /**
     * 色斑晕染图元
     */
    protected _colorPatternGradientPrimitive?: Cesium.Primitive | Cesium.GroundPrimitive;
    /**
     * 色带
     */
    protected _colorRamp: ColorRamp;
    /**
     * 矩形范围边界
     */
    protected _rectangle: Cesium.Rectangle;
    /**
     * 是否贴地
     */
    protected _aboveGround: boolean;
    /**
     * 离地高度
     */
    protected _height: number;
    /**
     * 色斑晕染图片材质的外部控制变量
     */
    protected _uniforms: ColorPatternGradientMaterialOptions;
    /**
     * colorPatternGradient色斑晕染图层类构造参数
     */
    options: ColorPatternGradientLayerOptions;
    /**
     * @param options - colorPatternGradient色斑晕染图层类构造参数
     */
    constructor(options: ColorPatternGradientLayerOptions);
    /**
     * 获取矩形范围边界
     * @readonly
     */
    get rectangle(): Cesium.Rectangle;
    /**
     * 获取色带
     */
    get colorRamp(): ColorRamp;
    /**
     * 设置色带，并调整图层渲染
     */
    set colorRamp(val: ColorRamp);
    /**
     * 透明度
     */
    get opacity(): number | undefined;
    /**
     * 设置透明度
     */
    set opacity(val: number | undefined);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _showHooks(val: boolean): void;
    protected _toJsonHooks(options: CreateLayerOptions): void;
    /**
     * 生成一个基于颜色映射的图像
     * @param min - 数值范围的最小值
     * @param max - 数值范围的最大值
     * @param colors - 一个包含键值对的数组，键是数值，值是对应的颜色字符串（如 "#FF0000"）
     * @param ctype - 插值类型，'linear' 或其他值（默认`undefined`）
     * @returns 生成的图像数据的 URL（前缀为 "data:" 协议的字符串URI，例如: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby..."）
     */
    protected _getImgByColorRamp(min: number, max: number, colors: ColorRamp, ctype?: string): string | undefined;
    /**
     * 初始化根据图层类的构造参数创建uniforms
     */
    protected _createUniforms(options: ColorPatternGradientLayerUniformOptions): ColorPatternGradientMaterialOptions;
    /**
     * 创建色斑晕染图元
     */
    protected _createColorPatternGradientPrimitive(): Cesium.Primitive | Cesium.GroundPrimitive;
    getRectangle(isFormat: true): Extent | undefined;
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
    /**
     * 获取当前图层的图例图片
     * @param ctype - 图例渲染类型（linear：线性渐变，block：色块）
     * @returns 返回前缀为 "data:" 协议的字符串URI，例如: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby..."
     */
    getLegendImage(ctype?: 'linear' | 'block'): string | undefined;
    /**
     * 设置色带，并调整图层渲染
     */
    setColorRamp(val: ColorRamp): void;
    /**
     * 设置色斑晕染图片材质的外部控制变量，并调整图层渲染
     */
    setUniforms(val: Partial<ColorPatternGradientLayerUniformOptions>): void;
    /**
     * 设置透明度
     */
    setOpacity(val: number): void;
}

/**
 * colorPatternGradient色斑晕染图层类构造参数
 */
declare interface ColorPatternGradientLayerOptions extends BaseGraphicLayerOptions {
    /**
     * 色带 - ^[必传项]
     * @example
     * ```
     [
     { color: "#00FF00", value: 0.5 },
     { color: "#FFFF00", value: 2 },
     { color: "#FF0000", value: 6 }
     ]
     * ```
     */
    colorRamp: ColorRamp;
    /**
     * 材质变量参数
     */
    uniformOptions: ColorPatternGradientLayerUniformOptions;
    /**
     * 图层的矩形范围
     * 输入格式可以是英文逗号隔开的字符串: `xxx,xxx,xxx,xxx`、数组: `[xxx, xxx, xxx, xxx]`、对象: `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`、或`Cesium.Rectangle`对象
     * 不管输入格式如何，都应遵循xmin,ymin,xmax,ymax的顺序，最终将输入格式转换为Cesium.Rectangle格式，默认值为 `Cesium.Rectangle.MAX_VALUE`
     * @default Cesium.Rectangle.MAX_VALUE
     */
    rectangle?: ParserRectangleInput;
    /**
     * 离地高度，单位：米，默认值：0，`aboveGround`为false时适用
     */
    height?: number;
    /**
     * 是否贴地
     */
    aboveGround?: boolean;
}

/**
 * colorPatternGradient色斑晕染图层类材质变量参数类型
 */
declare interface ColorPatternGradientLayerUniformOptions {
    /**
     * 基础背景图片 - ^[必传项]
     * 可接受如下格式的图片数据:
     * 1. 前端项目public目录下的静态资源
     * @example
     * ```
     * uniformOptions: {
     image: '/assets/tempreatrue.png',
     }
     * ```
     * 2. 前端项目src或其他目录下的资源动态引入
     * @example
     * ```
     * // vite示例
     * uniformOptions: {
     image: (await import('@/assets/tempreatrue.png')).default,
     }
     // webpack示例
     uniformOptions: {
     image: require('@/assets/tempreatrue.png'),
     }
     * ```
     * 3. 前缀为 "data:" 协议的字符串URI
     * @example
     * ```
     * uniformOptions: {
     image: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby...',
     }
     * ```
     */
    image: string;
    /**
     * 透明度，默认值为`0.8`
     */
    alpha?: number;
    /**
     * 生成的晕染图片尺寸，默认值为`new Cesium.Cartesian2(2880, 1440)`
     */
    resultSize?: Cesium.Cartesian2;
}

/**
 * 色斑晕染图片材质构造参数 - ^[Primitive使用]
 */
declare interface ColorPatternGradientMaterialOptions {
    /**
     * 基础背景图片
     * 可接受如下格式的图片数据:
     * 1. 前端项目public目录下的静态资源
     * @example
     * ```
     u_image: '/assets/demo.png',
     * ```
     * 2. 前端项目src或其他目录下的资源动态引入
     * @example
     * ```
     * // vite示例
     u_image: (await import('@/assets/demo.png')).default,
     // webpack示例
     u_image: require('@/assets/demo.png'),
     * ```
     * 3. 前缀为 "data:" 协议的字符串URI
     * @example
     * ```
     image: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby...',
     * ```
     */
    u_image: string;
    /**
     * 数据最小值
     */
    u_minValue: number;
    /**
     * 数据最大值
     */
    u_maxValue: number;
    /**
     * 根据数据最小值和最大值生成的色带图片，前缀为 "data:" 协议的字符串URI，例如: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby..."
     */
    u_colorImage: string;
    /**
     * 透明度 0.0~1.0之间，默认值为 0.8
     */
    u_alpha?: number;
    /**
     * 渲染图片的大小尺寸，单位为 px
     * @example
     * ```
     * new Cesium.Cartesian2(2880, 1440)
     * ```
     */
    u_resultSize?: Cesium.Cartesian2;
}

/**
 * colorPatternGrid色斑网格图层类
 * @see {@link ftp://baseProxy/views/demos/layer/color-pattern-grid/ | 查看演示效果}
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 // 创建图层
 const url = `${
 import.meta.env.BASE_URL
 }data/T1279_FLY_WARN_20210526000000_20210526120000.nc`
 const colorPatternGridLayer = new KBE3D.layers.ColorPatternGridLayer({
 url,
 id: 'test-color-pattern-grid',
 name: 'test-color-pattern-grid-name',
 flyTo: true,
 heightScale: 1000,
 })

 // 添加图层
 // earth.addLayer(colorPatternGridLayer)
 // 或
 colorPatternGridLayer.addTo(earth)
 await colorPatternGridLayer.addedPromise()

 //  do something...
 * ```
 */
declare class ColorPatternGridLayer extends BaseGraphicLayer {
    /**
     * 默认色带
     * @readonly
     * @example
     * ```
     * [
     { color: '#00FF00', value: 0.5 },
     { color: '#FFFF00', value: 2 },
     { color: '#FF0000', value: 6 },
     ]
     ```
     */
    static DEFAULT_COLOR_RAMP: {
        color: string;
        value: number;
    }[];
    protected _type: LayerTypeKey;
    /**
     * 数据大小
     */
    protected _size?: number[];
    /**
     * 所有的网格层级，从0开始
     */
    protected _levelList?: number[];
    /**
     * 显示的网格层级
     */
    protected _showLevel?: number[];
    /**
     * 色带
     */
    protected _colorRamp: ColorRamp;
    /**
     * 矩形范围边界
     */
    protected _rectangle?: Cesium.Rectangle;
    /**
     * 透明度
     */
    protected _alpha: number;
    /**
     * colorPatternGrid色斑网格图层类构造参数
     */
    options: ColorPatternGridLayerOptions;
    /**
     * 加载完成处理后的nc数据
     */
    ncFileResult?: {
        lonArray: Float32Array;
        latArray: Float32Array;
        levArray: Float32Array;
        valArray: Float32Array;
        minx: number;
        maxx: number;
        miny: number;
        maxy: number;
        nx: number;
        ny: number;
        nz: number;
        maxVal: number;
        minVal: number;
    };
    /**
     * @param options - colorPatternGrid色斑网格图层类构造参数
     */
    constructor(options: ColorPatternGridLayerOptions);
    /**
     * 获取数据大小
     * @readonly
     */
    get size(): number[] | undefined;
    /**
     * 获取层级数组
     * @readonly
     */
    get levelList(): number[] | undefined;
    /**
     * 获取显示的网格层级
     */
    get showLevel(): number[] | undefined;
    /**
     * 设置显示的网格层级，不传值则显示全部
     */
    set showLevel(val: number[] | undefined);
    /**
     * 获取色带
     */
    get colorRamp(): ColorRamp;
    /**
     * 设置色带
     */
    set colorRamp(val: ColorRamp);
    /**
     * 透明度
     */
    get alpha(): number;
    /**
     * 设置透明度
     */
    set alpha(val: number);
    /**
     * 透明度
     */
    get opacity(): number;
    /**
     * 设置透明度
     */
    set opacity(val: number);
    /**
     * 获取矩形范围边界
     * @readonly
     */
    get rectangle(): Cesium.Rectangle | undefined;
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _showHooks(val: boolean): void;
    protected _toJsonHooks(options: CreateLayerOptions): void;
    /**
     * 数据处理: 数组转对象
     */
    protected _arrayToMap(array: any): any;
    /**
     * 数据处理: y轴对调
     */
    protected _dealValues(data: any, nx: number, ny: number): Float32Array;
    /**
     * 加载nc数据
     * @param url - 加载的nc数据文件地址
     * @returns Promise
     */
    protected _loadNcFile(url: string): Promise<any>;
    getRectangle(isFormat: true): Extent | undefined;
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
    /**
     * 设置显示的网格层级，不传值则显示全部
     * @param val - 显示的网格层级
     */
    setShowLevel(val: number[] | undefined): void;
    /**
     * 设置色带
     */
    setColorRamp(val: ColorRamp): void;
    /**
     * 设置透明度
     */
    setAlpha(val: number): void;
    /**
     * 设置透明度
     */
    setOpacity(val: number): void;
}

/**
 * colorPatternGrid色斑网格图层类构造参数
 */
declare interface ColorPatternGridLayerOptions extends BaseGraphicLayerOptions {
    /**
     * 加载的.nc数据地址 - ^[必传项]
     * @example
     * 在public文件夹下的 `/data/xxx.nc` 本地资源文件
     * 或 可以访问的 `http://xxx/data/xxx.nc` 在线资源文件
     * @remarks
     * ```
     * NetCDF数据格式要求
     文件有效性：
     NetCDF文件必须是完整的且未损坏，符合NetCDF格式标准。
     维度定义：
     文件必须包含至少三个维度：lon（经度）、lat（纬度）和level（层次或高度）。
     每个维度应具有明确的长度，定义该维度上数据点的数量。
     变量定义：
     必须包含以下四个变量：
     lon（经度）：用于定义经度坐标，数据类型应与读取代码兼容（如Float32）。
     lat（纬度）：用于定义纬度坐标，数据类型应与读取代码兼容。
     level（层次或高度）：用于定义数据的高度或深度层次，数据类型应与读取代码兼容。
     value（数据值）：包含实际分析的数据，应与lon、lat和level维度相关联，数据类型应与读取代码兼容。
     数据类型兼容性：
     所有变量的数据类型应与读取代码中的数据类型声明相匹配（如Float32）。
     变量属性（可选但推荐）：
     为变量添加描述性属性，如单位、标准名称、坐标系统等，以提高数据的可理解性和可重用性。
     数据布局：
     value变量应以其维度（lon、lat、level）为索引进行组织。
     * ```
     */
    url: string;
    /**
     * 显示的网格层级，默认全部显示
     */
    showLevel?: number[];
    /**
     * 色带
     * @example
     * ```
     [
     { color: "#00FF00", value: 0.5 },
     { color: "#FFFF00", value: 2 },
     { color: "#FF0000", value: 6 }
     ]
     * ```
     */
    colorRamp?: ColorRamp;
    /**
     * 高度缩放，默认值：1
     */
    heightScale?: number;
    /**
     * 间隔，默认值：0.5
     */
    interval?: number;
    /**
     * 透明度，默认值：1.0
     */
    alpha?: number;
}

/**
 * 色带数组类型
 * @example
 * ```ts
 * [
 { color: '#00FF00', value: 0.5 },
 { color: '#FFFF00', value: 2 },
 { color: '#FF0000', value: 6 },
 ]
 * ```
 */
declare type ColorRamp = Array<{
    color: string;
    value: number;
}>;

/**
 * 色带数组类型
 * @example
 * ```ts
 * [
 { color: '#00FF00', value: 0.5 },
 { color: '#FFFF00', value: 2 },
 { color: '#FF0000', value: 6 },
 ]
 * ```
 */
declare type ColorRamp_2 = Array<{
    color: string;
    value: number;
}>;

declare namespace convers {
    export {
        BaseMaterialConver,
        BaseOptsConver,
        BaseStyleConver,
        ColorOptsConver,
        ImageOptsConver,
        LabelStyleConver,
        PolylineStyleConver
    }
}
export { convers }

/**
 * 转换图层配置参数
 */
declare function converTileLayerOptions<T extends BaseTileLayerOptions>(options: BaseTileLayerOptions): T;

/**
 * 创建一个tagName的HTML元素，将其class设置为className，并可选择将其添加到container元素中
 * @param tagName - 元素类型，比如 div
 * @param className - 附加的class样式名，默认为空字符串
 * @param container - 添加到指定的父节点，默认不添加
 * @returns 创建好的DOM元素
 * @group 功能: Dom操作相关
 */
declare function createDom(tagName: string, className?: string, container?: HTMLElement | null): HTMLElement;

/**
 * 创建图层的工厂方法，type为图层的类型，其他参数详细见各个{@link EffectTypeKey }对应的图层类构造方法参数
 * @param options - 图层参数
 */
declare function createEffect<T extends BaseEffect = BaseEffect>(options: CreateEffectOptions): T | undefined;

/**
 * 创建特效的工厂构造参数，type为特效的类型，其他参数详细见各个{@link EffectTypeKey }对应的特效类构造方法参数
 */
declare interface CreateEffectOptions {
    /** 特效类型 */
    type: EffectTypeKey;
    [x: string]: any;
}

/**
 * 创建图层的工厂方法，type为图层的类型，其他参数详细见各个{@link LayerTypeKey }对应的图层类构造方法参数
 * @param options - 图层参数
 */
declare function createLayer<T extends BaseLayer = BaseLayer>(options: CreateLayerOptions): T | undefined;

/**
 * 创建图层的工厂构造参数，type为图层的类型，其他参数详细见各个{@link LayerTypeKey }对应的图层类构造方法参数
 */
declare interface CreateLayerOptions {
    /** 图层类型 */
    type: LayerTypeKey;
    [x: string]: any;
}

/**
 * 创建材质（Primitive）
 * 通常与 Primitive 类型的几何对象一起使用，提供高度的自定义能力，支持通过 Fabric 对象定义复杂的着色器代码
 * @param type - 材质类型
 * @param options - 创建参数,具体对照{@link MaterialTypeValue}的注释说明
 * @returns Cesium.Material材质对象
 */
declare function createMaterial<T = Record<string, any>>(type: MaterialTypeValue, options: T): Cesium.Material | undefined;

/**
 * 创建材质（Entity）
 * 提供便捷的图像材质应用方式
 * @param type - 材质类型
 * @param options - 创建参数,具体对照{@link MaterialTypeValue}的注释说明
 * @returns 材质属性对象
 */
declare function createMaterialProperty(type: MaterialTypeValue, options: Record<string, any>): Cesium.MaterialProperty | undefined;

/**
 * 创建svg元素
 * @param width - 宽度
 * @param height - 高度
 * @param path - url路径
 * @param container - 添加到指定的父节点(可选)
 * @returns 创建的svg元素
 * @group 功能: Dom操作相关
 */
declare function createSvg(width: number, height: number, path: string, container?: HTMLElement | null): SVGSVGElement;

/**
 * 创建Video元素
 * @param url - url地址
 * @param type - 视频类型（可选）
 * @param className - 样式名称（可选）
 * @param container - 添加到指定的父节点（可选）
 * @returns 创建的Video元素
 * @group 功能: Dom操作相关
 */
declare function createVideo(url: string, type?: string, className?: string, container?: HTMLElement): HTMLVideoElement;

/**
 * 坐标系枚举
 * @enum
 */
declare const CRS: {
    /**
     * Web墨卡托投影坐标系
     */
    readonly EPSG3857: "EPSG:3857";
    /**
     * WGS84地理坐标系
     */
    readonly EPSG4326: "EPSG:4326";
    /**
     * 中国大地2000 （CGCS2000）地理坐标系
     */
    readonly EPSG4490: "EPSG:4490";
    /**
     * CGCS2000 Gauss-Kruger Zone 平面投影，3度分带，横坐标前加带号。
     * 范围：EPSG:4513 到 EPSG:4533
     */
    readonly CGCS2000_GK_Zone_3: "CGCS2000_GK_Zone_3";
    /**
     * CGCS2000 Gauss-Kruger Zone 平面投影，6度分带，横坐标前加带号。
     * 范围：EPSG:4491 到 EPSG:4501
     */
    readonly CGCS2000_GK_Zone_6: "CGCS2000_GK_Zone_6";
    /**
     * CGCS2000 Gauss-Kruger CM 平面投影，3度分带，横坐标前不加带号。
     * 范围：EPSG:4534 到 EPSG:4554
     */
    readonly CGCS2000_GK_CM_3: "CGCS2000_GK_CM_3";
    /**
     * CGCS2000 Gauss-Kruger CM 平面投影，6度分带，横坐标前不加带号。
     * 范围：EPSG:4502 到 EPSG:4512
     */
    readonly CGCS2000_GK_CM_6: "CGCS2000_GK_CM_6";
};

/**
 * 坐标系key联合类型
 */
declare type CRSKey = keyof typeof CRS;

/**
 * 坐标系value联合类型
 */
declare type CRSValue = (typeof CRS)[keyof typeof CRS];

/**
 * 自定义shader的类型，用于创建内置shader效果
 * @enum
 */
declare const CustomShaderType: {
    /**
     * 动态视距线型颜色的特效（常用于白膜）
     */
    readonly DistanceColorChange: "DistanceColorChange";
    /**
     * 动态渐变立体扫描特效的特效（常用于白膜）
     */
    readonly DynamicHalo: "DynamicHalo";
};

/**
 * 自定义shader的类型key联合类型
 */
declare type CustomShaderTypeKey = keyof typeof CustomShaderType;

/**
 * 各个自定义shader的类型所需的参数类型
 */
declare interface CustomShaderTypeOptions {
    /**
     * 动态视距线型颜色变化特效（常用于白膜）
     */
    DistanceColorChange: {
        /** 最远距离，超过该距离后颜色将不再变化，默认值为10000 */
        far?: number;
        /**
         * 初始颜色(css color)，默认值为`#0000ff`
         * <span class="colorSwath" style="background: #0000ff;"></span>
         */
        baseColor?: string | Cesium.Color;
        /** 变化的原色，红绿蓝三选一，默认值为`g`，颜色将从`#0000ff`向`#00ffff`根据视距产生变化 */
        changedRgbIndex?: 'r' | 'g' | 'b';
    };
    /**
     * 动态渐变立体扫描特效（常用于白膜）
     */
    DynamicHalo: {
        /**
         * 底部基础颜色(css color)，默认值为`#000000`
         * <span class="colorSwath" style="background: #000000;"></span>
         */
        baseColorBottom?: string | Cesium.Color;
        /**
         * 顶部基础颜色(css color)，默认值为`#4B0082`
         * <span class="colorSwath" style="background: #4B0082;"></span>
         */
        baseColorTop?: string | Cesium.Color;
        /** 物体的基础高度，需要修改成一个合适的建筑基础高度（单位：米），默认值为`0` */
        baseHeight?: number;
        /** 渐变的高度范围（单位：米），默认值为`400` */
        heightRange?: number;
        /** 光环移动的范围（单位：米），默认值为`400` */
        glowRange?: number;
        /**
         * 点亮颜色(css color)，默认值为`#6900ff`
         * <span class="colorSwath" style="background: #6900ff;"></span>
         */
        lightColor?: string | Cesium.Color;
        /** 点亮的范围半径，（单位：米），默认值为`1000` */
        lightRadius?: number;
        /** 点亮的中心点 */
        lightPosition?: ParserLatLngPointInput;
        /**
         * 点击事件回调，可在此动态调整点亮中心点
         * @example
         * ```
         * onClick: (layer, event) => {
         *   layer.setUniforms({
         *      lightPosition: event.data.cartesian,
         *      lightRadius: 1000,
         *      lightColor: Cesium.Color.RED,
         *   })
         * }
         * ```
         */
        onClick?: (layer: TilesetLayer, event: BaseEvent<PickTargetInfo>) => any;
    };
}

/**
 * 自定义shader的类型value联合类型
 */
declare type CustomShaderTypeValue = (typeof CustomShaderType)[keyof typeof CustomShaderType];

/**
 * 圆锥: 波纹扩散效果材质 - ^[Primitive使用]
 */
declare class CylinderWaveMaterial extends Cesium.Material {
    frameTime: number;
    animateFrame?: number;
    constructor(options?: CylinderWaveMaterialOptions);
    /**
     * 动态修改雷达材质中的offset变量，从而实现动态效果
     */
    protected _updateOffset(): void;
    /**
     * 销毁释放对象
     */
    destroy(): void;
}

/**
 * 圆锥: 波纹扩散效果材质构造器类型 - ^[Primitive使用]
 */
declare interface CylinderWaveMaterialOptions {
    /**
     * 波纹的颜色。默认为`new Cesium.Color(2, 1, 0.0, 0.8)`。
     * 可以是字符串或Cesium.Color对象。
     */
    color?: string | Cesium.Color;
    /**
     * 圈的数量。默认为`30`。
     */
    repeat?: number;
    /**
     * 圈的宽度比例。默认为`0.3`。
     */
    thickness?: number;
    /**
     * 每秒刷新次数。默认为`60`。因为requestAnimationFrame固定每秒60次的渲染，所以如果不想这么快，就把该数值调小一些。
     */
    frameRate?: number;
}

/**
 * 圆锥: 波纹扩散效果材质
 */
declare class CylinderWaveMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _repeat: number;
    /**
     */
    protected _thickness: number;
    /**
     */
    protected _offset: number;
    constructor(options?: CylinderWaveMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "CylinderWave";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 圆锥: 波纹扩散效果材质构造器类型
 */
declare interface CylinderWaveMaterialPropertyOptions {
    /**
     * 波纹的颜色。默认为`new Cesium.Color(2, 1, 0.0, 0.8)`。
     * 可以是字符串或Cesium.Color对象。
     */
    color?: string | Cesium.Color;
    /**
     * 圈的数量。默认为`30`。
     */
    repeat?: number;
    /**
     * 圈的宽度比例。默认为`0.3`。
     */
    thickness?: number;
}

/**
 * 复制克隆对象
 * @param obj 原始对象
 * @param removeKeys 不复制的属性名 数组，默认为空数组
 * @param level 拷贝的层级最大深度,避免死循环，默认为5
 * @returns 克隆后的对象
 */
declare function deepClone<T>(obj: T, removeKeys?: string[], level?: number): T;

/**
 * 合并两个对象或数组
 * @param target - 目标对象
 * @param source - 合并对象
 * @param [optionsArgument] - 其他选项
 * @param optionsArgument.clone - 是否克隆为新的对象
 * @returns 合并后的对象或数组
 */
declare function deepMerge<T extends object, U extends object = T>(target: T, source: U, optionsArgument?: {
    clone: boolean;
}): T;

/**
 * 合并多个对象或数组
 * @param array - 多个对象或数组的联合数组
 * @param [optionsArgument] - 其他选项
 * @param optionsArgument.clone - 是否克隆为新的对象
 * @returns 合并后的对象或数组
 * @throws
 ```ts
 new Error(
 'first argument should be an array with at least two elements',
 )
 ```
 */
declare function deepMergeAll<T extends object>(array: T[], optionsArgument?: {
    clone: boolean;
}): T[];

/**
 * 经度/纬度 十进制 转为 度分秒格式
 * @param value - 经度或纬度值
 * @returns 度分秒对象，如：{ degree:113, minute:24, second:40, str: "113° 24' 40\"" }
 * @group 功能: 坐标转换相关
 */
declare function degree2dms(value: number): {
    degree: number;
    minute: number;
    second: number;
    str: string;
};

/**
 * 经度/纬度 度分秒 转为 十进制
 * @param degree - 度
 * @param minute - 分
 * @param second - 秒
 * @returns 十进制
 * @group 功能: 坐标转换相关
 */
declare function dms2degree(degree: number, minute: number, second: number): number;

/**
 * html dom 转 Base64
 * @group 功能: image操作相关
 */
declare function dom2Base64(dom: HTMLDivElement, options?: Dom2Base64Option): Promise<string>;

/**
 * html dom 转 Base64 相关参数，同domtoimage.toPng
 */
declare interface Dom2Base64Option {
    filter?: (node: Element) => boolean;
    [someAttr: string]: any;
}

/**
 * 构建管理三维球的主入口
 */
export declare class Earth extends BaseClass {
    /**
     * 支持的事件类型
     */
    static EventType: {
        add: "add";
        remove: "remove";
        addLayer: "addLayer";
        removeLayer: "removeLayer";
        addEffect: "addEffect";
        removeEffect: "removeEffect";
        enable: "enable";
        unable: "unable";
        show: "show";
        hide: "hide";
        click: "click";
        clickGraphic: "clickGraphic";
        clickTileGraphic: "clickTileGraphic";
        clickMap: "clickMap";
        dblClick: "dblClick";
        leftDown: "leftDown";
        leftUp: "leftUp";
        mouseMove: "mouseMove";
        mouseMoveTarget: "mouseMoveTarget";
        wheel: "wheel";
        rightClick: "rightClick";
        rightDown: "rightDown";
        rightUp: "rightUp";
        middleClick: "middleClick";
        middleDown: "middleDown";
        middleUp: "middleUp";
        mouseDown: "mouseDown";
        mouseUp: "mouseUp";
        mouseOver: "mouseOver";
        mouseOut: "mouseOut";
        pinchStart: "pinchStart";
        pinchEnd: "pinchEnd";
        pinchMove: "pinchMove";
        keydown: "keydown";
        keyup: "keyup";
        cameraMoveStart: "cameraMoveStart";
        cameraMoveEnd: "cameraMoveEnd";
        cameraChanged: "cameraChanged";
        preUpdate: "preUpdate";
        postUpdate: "postUpdate";
        preRender: "preRender";
        postRender: "postRender";
        renderError: "renderError";
        morphStart: "morphStart";
        morphComplete: "morphComplete";
        clockTick: "clockTick";
        terrainChange: "terrainChange";
        tileLoadProgress: "tileLoadProgress";
        openPopup: "openPopup";
        closePopup: "closePopup";
        destroyPopup: "destroyPopup";
        changePopupPosition: "changePopupPosition";
        showPopup: "showPopup";
        hidePopup: "hidePopup";
    };
    /**
     * earth实例缓存
     */
    static EarthCache: Map<string, Earth>;
    /**
     * 通过实例唯一id获取Earth实例对象
     * @param uuid - Earth实例唯一id
     * @param delay - 延迟获取，默认值为`5000`，单位ms
     * @returns Earth实例对象，调度超时将返回`undefined`
     * @group 静态方法
     */
    static getInstance(uuid: string, delay?: number): Promise<Earth | undefined>;
    /** Cesium.Viewer构造参数 */
    readonly viewerOptions: ViewerOptions;
    /** earth构造参数 */
    readonly earthOptions: EarthOptions;
    /** Cesium.Viewer实例 */
    readonly viewer: Cesium.Viewer;
    /** 图层id累加器 */
    protected _layerIdx: number;
    /** 所有的图层id数组 */
    protected _arrLayerIdx: Array<number | string>;
    /** 图层缓存Record记录，key为图层的id */
    protected _layerCache: Record<string | number, BaseLayer>;
    /** 特效缓存Record记录，key为特效实例类的type */
    protected _effectCache: Record<string, BaseEffect>;
    /** 场景事件 */
    protected _sceneEvent: SceneEvent;
    /** 鼠标事件 */
    protected _mouseEvent: MouseEvent_2;
    /** popup实例 */
    protected _popup?: Popup;
    /** 是否禁用所有鼠标事件，默认值为 false */
    protected _disableMouseEvent?: boolean;
    /** 鼠标移动提示框 */
    mouseTooltip: MouseTooltip;
    /** 是否禁用浏览器默认的鼠标右键菜单 */
    disableDefaultContextMenu: boolean;
    /**
     * @param view - 渲染容器的id或dom节点或已创建的Cesium.Viewer实例
     * @param viewerOptions - viewer构造参数 - ^[当view为渲染容器的id或dom节点时有效]
     * @param earthOptions - earth构造参数
     */
    constructor(view: string | Element | Cesium.Viewer, viewerOptions?: ViewerOptions, earthOptions?: EarthOptions);
    /**
     * 获取在地球上渲染的ImageryLayer图像图层的集合类
     * @readonly
     */
    get imageryLayers(): Cesium.ImageryLayerCollection;
    /**
     * 获取在地球上渲染的ImageryLayer图像图层的集合类中的图层数组
     * @readonly
     */
    get imageryLayersArr(): Array<Cesium.ImageryLayer>;
    /**
     * 获取要可视化的 DataSource 实例集
     * @readonly
     */
    get dataSources(): Cesium.DataSourceCollection;
    /**
     * 获取未绑定到特定数据源的实体的集合。这是 dataSourceDisplay.defaultDataSource.entities 的快捷方式。
     * @readonly
     */
    get entities(): Cesium.EntityCollection;
    /**
     * 是否加载了地形
     * @readonly
     */
    get hasTerrain(): boolean;
    /**
     * 获取viewer的容器dom
     * @readonly
     */
    get container(): Element;
    /**
     * 获取特效缓存Record记录，key为特效实例类的type
     * @readonly
     */
    get effects(): Record<string, BaseEffect>;
    /**
     * 获取bindPopup绑定的实例
     * @readonly
     */
    get popup(): Popup | undefined;
    /**
     * 获取是否禁用所有鼠标事件
     */
    get disableMouseEvent(): boolean | undefined;
    /**
     * 设置是否禁用所有鼠标事件
     */
    set disableMouseEvent(value: boolean | undefined);
    /**
     * 创建viewer
     */
    protected _createViewer(view: string | Element | Cesium.Viewer): Cesium.Viewer;
    /**
     * 初始化按钮控件
     */
    protected _initWidgets(): void;
    /**
     * 自定义Cesium渲染异常处理函数
     * @param handler - 处理函数
     */
    setRenderErrorHandler(handler: RenderErrorHandler): void;
    /**
     * 设置Cesium Ion等服务的Token，未传值的项将使用内部token
     * @param token
     */
    setToken(token?: Partial<Token>): void;
    /**
     * 设置是否禁用所有鼠标事件
     */
    setDisableMouseEvent(value?: boolean): void;
    /**
     * 设置是否禁用浏览器默认的鼠标右键菜单
     */
    setDisableDefaultContextMenu(value: boolean): void;
    /**
     * 销毁释放对象
     */
    destroy(): void;
    /**
     * 在相机飞行途中取消飞行
     * @group 方法: 相机视角相关
     */
    cancelFlyTo(): void;
    /**
     * 飞行到默认视角
     * @param options - 相机飞行控制参数
     * @group 方法: 相机视角相关
     */
    flyHome(options?: FlyToControl): void;
    /**
     * 相机飞行
     * @param options
     * @group 方法: 相机视角相关
     */
    flyTo(options: FlyToOptions): void;
    /**
     * 根据目标点定位(非相机位置)
     * @param point - 点
     * @param options - 飞行到点控制参数
     * @group 方法: 相机视角相关
     */
    flyToPoint(point: ParserLatLngPointInput, options?: FlyToPointControl): void;
    /**
     * 根据矩形范围边界定位(非相机位置)
     * @param extent - 矩形范围边界
     * @param options - 飞行到矩形范围边界控制参数
     * @group 方法: 相机视角相关
     */
    flyToExtent(extent: Extent, options?: FlyToExtentControl): void;
    /**
     * 定位至坐标数组
     * @param positions - Cesium.Cartesian3[]坐标数组
     * @param options - 飞行到坐标数组控制参数
     * @group 方法: 相机视角相关
     */
    flyToPositions(positions: Cesium.Cartesian3[], options?: FlyToPointControl): void;
    /**
     * 获取当前相机视角信息
     * @param simplify - 是否简化返回信息
     * @returns - 包含经纬度、高度、航向、俯仰（可能包含翻滚角）的对象
     * @group 方法: 相机视角相关
     */
    getCameraVision(simplify?: boolean): camera.CameraViewInfo;
    /**
     * 获取当前视域边界
     * @param digits 经纬度保留的小数位数，默认为 6
     * @returns - 当前视域边界
     * @group 方法: 相机视角相关
     */
    getExtent(digits?: number): Extent;
    /**
     * 初始化图层配置
     * @group 方法: 图层相关
     */
    protected _initLayers(): void;
    /**
     * 获取图层ID值，按顺序取值，没有id的图层，会自动使用本方法进行id赋值处理
     * @returns 图层ID
     * @group 方法: 图层相关
     */
    protected _getNextLayerId(): number;
    /**
     * 根据id获取已加载的图层，默认返回类型为BaseLayer，如需更加友好的代码提示，请为方法添加适当的泛型
     * @param id - 图层id或uuid
     * @returns 图层对象或undefined
     * @group 方法: 图层相关
     * @example
     * ```
     * earth.getLayerById<KBE3D.layers.WmsLayer>('demo')
     * ```
     */
    getLayerById<T extends BaseLayer = BaseLayer>(id: string | number): T | undefined;
    /**
     * 根据指定属性获取已加载的图层，默认返回类型为BaseLayer，如需更加友好的代码提示，请为方法添加适当的泛型
     * @param value - 属性值（如id、name值）
     * @param attr - 属性名称
     * @returns 图层对象或undefined
     * @group 方法: 图层相关
     * @example
     * ```
     * earth.getLayerByAttr<KBE3D.layers.WmsLayer>('demo', 'id')
     * ```
     */
    getLayerByAttr<T extends BaseLayer = BaseLayer>(value: string | number, attr?: string): T | undefined;
    /**
     * 获取已加载的所有图层，默认返回类型为BaseLayer，如需更加友好的代码提示，请为方法添加适当的泛型
     * @returns 图层数组
     * @group 方法: 图层相关
     * @example
     * ```
     * earth.getLayers<KBE3D.layers.WmsLayer[]>()
     * ```
     */
    getLayers<T = BaseLayer[]>(): T;
    /**
     * 获取已加载的所有瓦片图层，可以用于卷帘对比，默认返回类型为BaseLayer，如需更加友好的代码提示，请为方法添加适当的泛型
     * @returns 瓦片图层数组
     * @group 方法: 图层相关
     * @example
     * ```
     * earth.getTileLayers<KBE3D.layers.WmsLayer[]>()
     * ```
     */
    getTileLayers<T = BaseLayer[]>(): T;
    /**
     * 遍历每一个图层并将其作为参数传递给回调函数
     * @param method - 回调方法
     * @param context - 侦听器的上下文(this关键字将指向的对象)
     * @group 方法: 图层相关
     */
    eachLayer(method: (layer: BaseLayer, index: number) => any, context?: any): void;
    /**
     * 添加图层到地球上
     * @param layer - 图层对象
     * @param showVal - 如果传值，覆盖图层的show属性
     * @group 方法: 图层相关
     */
    addLayer(layer: BaseLayer, showVal?: boolean): void;
    /**
     * 移除图层
     * @param layer - 需要移除的图层对象或id
     * @param isDestroy - 是否destroy销毁释放对象，默认值：false
     * @group 方法: 图层相关
     */
    removeLayer(layer: BaseLayer | string | number, isDestroy?: boolean): void;
    /**
     * 按配置进行初始化相关特效
     */
    protected _initEffects(): void;
    /**
     * 添加特效到地球上
     * @param effect - 特效对象
     * @param enable - 如果传值，覆盖特效的enable属性
     * @group 方法: 特效相关
     */
    addEffect(effect: BaseEffect, enable?: boolean): void;
    /**
     * 移除特效对象
     * @param effect - 需要移除的特效对象
     * @param isDestroy - 是否destroy销毁释放对象，默认值：false
     * @group 方法: 特效相关
     */
    removeEffect(effect: BaseEffect | string, isDestroy?: boolean): void;
    /**
     * 绑定弹窗
     * @param options - 弹窗实例类构造参数
     */
    bindPopup(options?: PopupOptions): void;
    /**
     * 解除绑定弹窗
     */
    unbindPopup(): void;
    /**
     * 下载截屏
     */
    downLoadScreenShot(options?: {
        /**
         * 截屏区域的dom选择器，设置之后将会把对应的dom与viewer.canvas进行图片合并
         */
        screenSelector?: string;
        /**
         * 截屏区域的dom的节点过滤器，返回值为true的将被包含
         */
        nodeFilter?: (node: Element) => boolean;
        /**
         * 文件名称
         */
        fileName?: string;
    }): void;
    /**
     * 截屏输出base64
     */
    getScreenShotBase64(options?: {
        /**
         * 截屏区域的dom选择器，设置之后将会把对应的dom与viewer.canvas进行图片合并
         */
        screenSelector?: string;
        /**
         * 截屏区域的dom的节点过滤器，返回值为true的将被包含
         */
        nodeFilter?: (node: Element) => boolean;
    }): Promise<string>;
    /**
     * 绑定指定类型事件监听器，支持在监听中调用 event.stopPropagation() 组织事件冒泡
     * @param types - 事件类型
     * @param fn - 绑定的监听器回调方法
     * @param context - 侦听器的上下文(this关键字将指向的对象)。
     * @return 当前对象本身，可以链式调用
     * @group 方法: 事件相关
     */
    on(types: EventTypeValue | EventTypeValue[] | Record<EventTypeValue, any> | string | string[] | Record<any, any>, fn: Function, context?: any): this;
    /**
     * 解除绑定指定类型事件监听器
     * @param types - 事件类型,未传值时解绑所有事件
     * @param fn - 绑定的监听器回调方法,未传值时解绑所有指定类型对应事件
     * @param context - 侦听器的上下文(this关键字将指向的对象)。
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    off(types: EventTypeValue | EventTypeValue[] | Record<EventTypeValue, any> | string | string[] | Record<any, any>, fn: Function, context?: any): this;
}

/**
 * Earth构造参数类型
 */
export declare interface EarthOptions {
    /** 当前实例的唯一id，静态方法Earth.getInstance调用时使用，默认为随机uuid */
    uuid?: string | number;
    /** 设置Cesium Ion等服务的token */
    token?: Partial<Token>;
    /** 是否显示地图缩放控制按钮 */
    zoomButton?: boolean;
    /** 是否显示雾天气特效控制按钮 */
    fogButton?: boolean;
    /** 是否显示雨天气特效控制按钮 */
    rainButton?: boolean;
    /** 是否显示闪电特效控制按钮 */
    lightningButton?: boolean;
    /** 是否显示雪天气特效控制按钮 */
    snowButton?: boolean;
    /** 是否显示积雪覆盖模型特效控制按钮 */
    snowCoverButton?: boolean;
    /** 默认相机视角 */
    homeVision?: Vision;
    /** 图层配置 */
    layers?: CreateLayerOptions[];
    /**  特效配置 */
    effects?: CreateEffectOptions[];
    /** 是否禁用浏览器默认的鼠标右键菜单，默认值为 `true`  */
    disableDefaultContextMenu?: boolean;
    /** 鼠标拾取配置 */
    mouseMove?: MouseMoveEventOptions;
}

declare namespace effects {
    export {
        BaseEffectOptions,
        BaseEffect,
        FogEffectOptions,
        FogEffect,
        RainEffectOptions,
        RainEffect,
        SnowEffectOptions,
        SnowEffect,
        SnowCoverEffectOptions,
        SnowCoverEffect,
        LightningEffectOptions,
        LightningEffect
    }
}
export { effects }

declare namespace effects_2 {
    export {
        createEffect,
        CreateEffectOptions
    }
}

/**
 * 特效类型
 * @enum
 */
declare const EffectType: {
    /** 雾天气效果 */
    fog: typeof FogEffect;
    /** 雨天气效果 */
    rain: typeof RainEffect;
    /** 雪天气效果 */
    snow: typeof SnowEffect;
    /** 积雪效果 */
    snowCover: typeof SnowCoverEffect;
    /** 闪电效果 */
    lightning: typeof LightningEffect;
};

/**
 * 特效类型key联合类型
 */
declare type EffectTypeKey = keyof typeof EffectType;

/**
 * 特效类型value联合类型
 */
declare type EffectTypeValue = (typeof EffectType)[keyof typeof EffectType];

/**
 * 球体: 电弧球体效果材质
 */
declare class EllipsoidElectricMaterialProperty extends BaseMaterialProperty {
    constructor(options?: EllipsoidElectricMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "EllipsoidElectric";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 球体: 电弧球体效果材质构造器类型
 */
declare interface EllipsoidElectricMaterialPropertyOptions {
    /**
     * 电弧球体的颜色。
     * 默认为红色（`new Cesium.Color(1, 0, 0, 1.0)`）。
     */
    color?: Cesium.Color;
    /**
     * 电弧球体的旋转或变化速度。
     * 值越大，变化越快。
     * 默认为`5.0`。
     */
    speed?: number;
}

/**
 * 球体: 波纹球体效果材质
 */
declare class EllipsoidWaveMaterialProperty extends BaseMaterialProperty {
    constructor(options?: EllipsoidWaveMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "EllipsoidWave";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 球体: 波纹球体效果材质构造器类型
 */
declare interface EllipsoidWaveMaterialPropertyOptions {
    /**
     * 波纹球体的颜色。
     * 默认为红色（`new Cesium.Color(1, 0, 0, 1.0)`）。
     */
    color?: Cesium.Color;
    /**
     * 波纹扩散的速度。
     * 值越大，波纹扩散得越快。
     * 默认为`5.0`。
     */
    speed?: number;
}

/**
 * 删除所有子元素
 * @param el - DOM元素
 * @group 功能: Dom操作相关
 */
declare function empty(el: HTMLElement): void;

/**
 * 进入全屏
 * @param el - 指定DOM元素
 * @returns 是否执行
 * @group 功能: Dom操作相关
 */
declare function enterFullscreen(el: HTMLElement | SVGElement): boolean;

declare namespace enums {
    export {
        ChinaCRS,
        ChinaCRSKey,
        ChinaCRSValue,
        ClipType,
        ClipTypeKey,
        ClipTypeValue,
        CRS,
        CRSKey,
        CRSValue,
        CustomShaderType,
        CustomShaderTypeKey,
        CustomShaderTypeValue,
        CustomShaderTypeOptions,
        EffectType,
        EffectTypeKey,
        EffectTypeValue,
        EventType,
        EventTypeKey,
        EventTypeValue,
        LayerType,
        LayerTypeKey,
        LayerTypeValue,
        LifeCycleState,
        LifeCycleStateKey,
        LifeCycleStateValue,
        MaterialType,
        MaterialTypeKey,
        MaterialTypeValue,
        MoveType,
        MoveTypeKey,
        MoveTypeValue,
        State,
        StateKey,
        StateValue,
        TerrainType,
        TerrainTypeKey,
        TerrainTypeValue
    }
}
export { enums }

/**
 * 事件枚举
 * @enum
 */
declare const EventType: {
    /**
     * 添加对象(图层和earth同时抛出)
     */
    readonly add: "add";
    /**
     * 移除对象(图层和earth同时抛出)
     */
    readonly remove: "remove";
    /**
     * 添加图层(图层和earth同时抛出)
     */
    readonly addLayer: "addLayer";
    /**
     * 移除图层(图层和earth同时抛出)
     */
    readonly removeLayer: "removeLayer";
    /**
     * 添加特效(特效和earth同时抛出)
     */
    readonly addEffect: "addEffect";
    /**
     * 移除特效(特效和earth同时抛出)
     */
    readonly removeEffect: "removeEffect";
    /**
     *启用(特效和earth同时抛出)
     */
    readonly enable: "enable";
    /**
     *停用(特效和earth同时抛出)
     */
    readonly unable: "unable";
    /**
     *显示(图层和earth同时抛出)
     */
    readonly show: "show";
    /**
     *隐藏(图层和earth同时抛出)
     */
    readonly hide: "hide";
    /**
     * 鼠标事件: 左键单击（earth抛出，如果拾取到图元，将“同时”在所在图层(前提是通过图元能找到所在图层)抛出该事件，并在earth抛出‘clickGraphic’或‘clickTileGraphic’）
     */
    readonly click: "click";
    /**
     * 鼠标事件: 左键单击到矢量或模型数据时（earth抛出）
     */
    readonly clickGraphic: "clickGraphic";
    /**
     * 鼠标事件: 左键单击到wms或arcgis瓦片服务的对应矢量数据时（earth抛出）
     */
    readonly clickTileGraphic: "clickTileGraphic";
    /**
     * 鼠标事件: 左键单击地图空白（未单击到矢量或模型数据）时（earth抛出）
     */
    readonly clickMap: "clickMap";
    /**
     * 鼠标事件: 左键双击（earth抛出）
     */
    readonly dblClick: "dblClick";
    /**
     * 鼠标事件: 左键鼠标按下（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly leftDown: "leftDown";
    /**
     * 鼠标事件: 左键鼠标按下后释放（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly leftUp: "leftUp";
    /**
     * 鼠标事件: 鼠标移动（earth抛出）
     */
    readonly mouseMove: "mouseMove";
    /**
     * 鼠标事件: 鼠标移动拾取目标（earth抛出）
     */
    readonly mouseMoveTarget: "mouseMoveTarget";
    /**
     * 鼠标事件: 鼠标滚轮滚动（earth抛出）
     */
    readonly wheel: "wheel";
    /**
     * 鼠标事件: 右键单击（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly rightClick: "rightClick";
    /**
     * 鼠标事件: 右键鼠标按下（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly rightDown: "rightDown";
    /**
     * 鼠标事件: 右键鼠标按下后释放（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly rightUp: "rightUp";
    /**
     * 鼠标事件: 中键单击（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly middleClick: "middleClick";
    /**
     * 鼠标事件: 中键鼠标按下（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly middleDown: "middleDown";
    /**
     * 鼠标事件: 中键鼠标按下后释放（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly middleUp: "middleUp";
    /**
     * 鼠标事件: 鼠标按下 [左中右3键都触发]（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly mouseDown: "mouseDown";
    /**
     * 鼠标事件: 鼠标按下后释放 [左中右3键都触发]（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly mouseUp: "mouseUp";
    /**
     * 鼠标事件: 鼠标移入（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly mouseOver: "mouseOver";
    /**
     * 鼠标事件: 鼠标移出（如果拾取到图元，将在所在图层(前提是通过图元能找到所在图层)抛出该事件，“否则”在earth抛出）
     */
    readonly mouseOut: "mouseOut";
    /**
     * 触摸屏事件: （earth抛出）
     */
    readonly pinchStart: "pinchStart";
    /**
     * 触摸屏事件: （earth抛出）
     */
    readonly pinchEnd: "pinchEnd";
    /**
     * 触摸屏事件: 在触摸屏上两指移动（earth抛出）
     */
    readonly pinchMove: "pinchMove";
    /**
     * 键盘事件: 按键按下（earth抛出）
     */
    readonly keydown: "keydown";
    /**
     * 键盘事件: 按键按下后释放（earth抛出）
     */
    readonly keyup: "keyup";
    /**
     * 场景事件: 相机开启移动前（earth抛出）
     */
    readonly cameraMoveStart: "cameraMoveStart";
    /**
     * 场景事件: 相机移动完成后（earth抛出）
     */
    readonly cameraMoveEnd: "cameraMoveEnd";
    /**
     * 场景事件: 相机位置完成（earth抛出）
     */
    readonly cameraChanged: "cameraChanged";
    /**
     * 场景事件: 场景更新前（earth抛出）
     */
    readonly preUpdate: "preUpdate";
    /**
     * 场景事件: 场景更新后（earth抛出）
     */
    readonly postUpdate: "postUpdate";
    /**
     * 场景事件: 场景渲染前（earth抛出）
     */
    readonly preRender: "preRender";
    /**
     * 场景事件: 场景渲染后（earth抛出）
     */
    readonly postRender: "postRender";
    /**
     * 场景事件: 场景渲染失败（earth抛出）
     */
    readonly renderError: "renderError";
    /**
     * 场景事件: 场景模式(2D/3D/哥伦布)变换前（earth抛出）
     */
    readonly morphStart: "morphStart";
    /**
     * 场景事件: 完成场景模式(2D/3D/哥伦布)变换（earth抛出）
     */
    readonly morphComplete: "morphComplete";
    /**
     * 场景事件: 时钟跳动（earth抛出）
     */
    readonly clockTick: "clockTick";
    /**
     * 场景事件: 地形变化（earth抛出）
     */
    readonly terrainChange: "terrainChange";
    /**
     * 场景事件: 地图中瓦片加载进度变化（earth抛出）
     */
    readonly tileLoadProgress: "tileLoadProgress";
    /**
     * Popup事件: 打开弹窗（Popup实例抛出、earth抛出、所在图层抛出）
     */
    readonly openPopup: "openPopup";
    /**
     * Popup事件: 关闭弹窗（Popup实例抛出、earth抛出、所在图层抛出）
     */
    readonly closePopup: "closePopup";
    /**
     * Popup事件: 销毁弹窗（Popup实例抛出、earth抛出、所在图层抛出）
     */
    readonly destroyPopup: "destroyPopup";
    /**
     * Popup事件: 弹窗位置变化（Popup实例抛出、earth抛出、所在图层抛出）
     */
    readonly changePopupPosition: "changePopupPosition";
    /**
     * Popup事件: 显示Popup（Popup实例抛出、earth抛出、所在图层抛出）
     */
    readonly showPopup: "showPopup";
    /**
     * Popup事件: 隐藏Popup（Popup实例抛出、earth抛出、所在图层抛出）
     */
    readonly hidePopup: "hidePopup";
    /**
     * tileVisible事件(TilesetLayer抛出)
     * tileVisible事件是在 CesiumJS 的 Cesium3DTileset 中定义的。这个事件特别用于在渲染过程中，每当一个瓦片（tile）变得可见时触发。这个机制允许开发者在瓦片被渲染到场景中时，对其进行自定义的样式设置或处理。
     * 事件细节
     * 触发时机：每当在渲染帧中遍历到一个可见的 Cesium 3D 瓦片时，tileVisible 事件就会被触发。这意味着如果在一个帧中有多个瓦片变得可见，这个事件可能会被多次触发，每次触发都对应一个不同的可见瓦片。
     * 事件数据：事件监听器会接收到一个 Cesium3DTile 对象作为参数。这个对象代表了触发事件的瓦片，允许开发者访问该瓦片的属性和方法，进而进行自定义的处理或样式设置。
     * 使用场景：这个事件的一个典型使用场景是，当需要根据瓦片的某些属性（如高度、材质等）来动态改变其样式时。例如，你可能想要高亮显示某个特定区域的建筑，或者改变某些瓦片的颜色以表示不同的状态或信息。
     * 性能注意事项：由于这个事件是在渲染过程中触发的，因此在事件监听器中应避免执行复杂的操作或创建/修改大量的 Cesium 实体（entities）或原始体（primitives）。这样做可能会导致渲染性能下降，影响应用的流畅性。
     * 示例用法
     * 假设你有一个 Cesium 3D 瓦片集（Cesium3DTileset），并希望对每个可见的瓦片应用一些自定义样式，你可以这样设置事件监听器：
     ```ts
     var tileset = viewer.scene.primitives.add(new Cesium.Cesium3DTileset({
     url: 'path/to/your/tileset.json'
     }));
     tileset.tileVisible.addEventListener(function(tile) {
     // 这里可以访问 tile 对象，并根据需要修改其样式
     // 注意：由于性能原因，这里的操作应该尽可能简单
     console.log('Tile is visible:', tile);
     // 例如，假设我们想要改变瓦片的某个属性
     // 注意：这只是一个示例，实际中可能需要修改 Cesium 的内部状态或使用其他方法
     // tile.someProperty = newValue; // 假设的属性修改
     });
     ```
     */
    readonly tileVisible: "tileVisible";
    /**
     * TilesetLayer事件: 3dtiles模型，模型瓦片初始化完成
     * 该回调只执行一次
     */
    readonly initialTilesLoaded: "initialTilesLoaded";
    /**
     * TilesetLayer事件: 3dtiles模型，当前批次模型加载完成
     * 该回调会执行多次，视角变化后重新加载一次完成后都会回调
     */
    readonly allTilesLoaded: "allTilesLoaded";
    /**
     * WmsLayer/WmtsLayer事件: 完成读取wms/wmts服务图层服务原始配置信息
     */
    readonly loadMetadata: "loadMetadata";
};

/**
 * 事件key联合类型
 */
declare type EventTypeKey = keyof typeof EventType;

/**
 * 事件value联合类型
 */
declare type EventTypeValue = (typeof EventType)[keyof typeof EventType];

/**
 * 退出全屏
 * @returns 是否执行
 * @group 功能: Dom操作相关
 */
declare function exitFullscreen(): boolean;

/** 矩形范围边界 */
declare interface Extent {
    /** Extent最小经度值, -180 至 180 */
    xmin: number;
    /** Extent最大经度值, -180 至 180 */
    xmax: number;
    /** Extent最小纬度值, -90 至 90 */
    ymin: number;
    /** Extent最大纬度值, -90 至 90 */
    ymax: number;
    /** Extent高度设置 */
    height?: number;
}

/**
 * 根据条件过滤树结构数据
 * @param tree - 目标树结构
 * @param func - 回调函数
 * @param config - 配置项
 * @returns 过滤后的树结构数据
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 children: 'children',
 }
 ```
 */
declare function filterTree<T = any>(tree: T[], func: (n: T) => boolean, config?: Partial<TreeMappingConfig>): T[];

/**
 * 找到一个符合条件的节点
 * @param tree - 目标树结构
 * @param func - 回调函数
 * @param config - 配置项
 * @returns 符合条件的节点
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 children: 'children',
 }
 ```
 */
declare function findNode<T = any>(tree: any, func: TreeCallbackFn, config?: Partial<TreeMappingConfig>): T | undefined;

/**
 * 找到多个符合条件的节点
 * @param tree - 目标树结构
 * @param func - 回调函数
 * @param config - 配置项
 * @returns 符合条件的节点集合
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 children: 'children',
 }
 ```
 */
declare function findNodeAll<T = any>(tree: any, func: TreeCallbackFn, config?: Partial<TreeMappingConfig>): T[];

/**
 * 找到符合条件的最终节点，并将节点的父级一级一级向上全部返回
 * @param tree - 目标树结构
 * @param func - 回调函数
 * @param config - 配置项
 * @returns [...祖，父，子]
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 children: 'children',
 }
 ```
 */
declare function findPath<T = any>(tree: any, func: TreeCallbackFn, config?: Partial<TreeMappingConfig>): T[] | null;

/**
 * 找到符合条件的最终节点集合，并将节点的父级一级一级向上全部返回
 * @param tree - 目标树结构
 * @param func - 回调函数
 * @param config - 配置项
 * @returns [[...祖，父，子], [...祖，父，子]， ...]
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 children: 'children',
 }
 ```
 */
declare function findPathAll(tree: any, func: TreeCallbackFn, config?: Partial<TreeMappingConfig>): any[];

/**
 * 定时闪烁高亮Entity（点、线、面）
 */
declare class FlickerEntity {
    entitys?: Cesium.Entity | Cesium.Entity[];
    color?: Cesium.Color;
    maxAlpha?: number;
    time?: number;
    onEnd?: (...args: any[]) => any;
    interval?: NodeJS.Timeout;
    timeEndVal?: NodeJS.Timeout;
    constructor();
    protected _updateClr(): void;
    protected _startTime(): void;
    protected _stopTime(): void;
    /**
     * 高亮闪烁Enity实体对象
     */
    startFlicker(entitys: Cesium.Entity | Cesium.Entity[], opts?: StartFlickerOptions): this;
    /**
     * 停止高亮闪烁
     */
    stopFlicker(): void;
}

/**
 * 相机飞行
 * @param viewer - Cesium.Viewer实例
 * @param options - 相机飞行参数
 */
declare function flyTo(viewer: Cesium.Viewer, options: FlyToOptions): void;

/**
 * 相机飞行控制参数
 */
declare interface FlyToControl extends Partial<Orientation> {
    /**
     * 飞行时间（单位：秒）。如果省略，SDK内部会根据飞行距离计算出理想的飞行时间。
     */
    duration?: number;
    /**
     * 飞行完成后要执行的函数。
     */
    complete?: Cesium.Camera.FlightCompleteCallback;
    /**
     * 飞行取消时要执行的函数。
     */
    cancel?: Cesium.Camera.FlightCancelledCallback;
    /**
     * 变换矩阵表示飞行结束时相机所处的参照系。
     */
    endTransform?: Cesium.Matrix4;
    /**
     * 飞行高峰时的最大高度。
     */
    maximumHeight?: number;
    /**
     * 如果相机飞得比这个值高，在飞行过程中调整俯仰以向下看，并保持地球在视口。
     */
    pitchAdjustHeight?: number;
    /**
     * 地球上的两点之间总有两条路。这个选项迫使相机选择战斗方向飞过那个经度。
     */
    flyOverLongitude?: number;
    /**
     * 仅在通过flyOverLongitude指定的lon上空飞行，只要该方式的时间不超过flyOverLongitudeWeight的短途时间。
     */
    flyOverLongitudeWeight?: number;
    /**
     * 是否将目的地从世界坐标转换为场景坐标（仅在不使用3D时相关）。
     */
    convert?: boolean;
    /**
     * 控制在飞行过程中如何插值时间。
     */
    easingFunction?: Cesium.EasingFunction.Callback;
}

/**
 * 根据矩形范围边界定位(非相机位置)
 * @param viewer - Cesium.Viewer实例
 * @param extent - 矩形范围边界
 * @param options - 飞行到矩形范围边界控制参数
 */
declare function flyToExtent(viewer: Cesium.Viewer, extent: Extent, options?: FlyToExtentControl): void;

/**
 * 相机飞行到目标区域控制参数(非相机位置)
 */
declare interface FlyToExtentControl extends FlyToControl, Partial<Orientation> {
    /**
     * 缩放系数 - ^[自定义: 额外参数配置]
     */
    scale?: number;
    /**
     * 最低高度 - ^[自定义: 额外参数配置]
     */
    minHeight?: number;
    /**
     * 最大高度 - ^[自定义: 额外参数配置]
     */
    maxHeight?: number;
    /**
     * 最小俯仰角，-90 至 90 - ^[自定义: 额外参数配置]
     */
    minPitch?: number;
    /**
     * 最大俯仰角，-90 至 90 - ^[自定义: 额外参数配置]
     */
    maxPitch?: number;
}

/**
 * 相机飞行到目标区域参数，不包含Center
 */
declare interface FlyToExtentOptions extends Partial<Extent>, Partial<FlyToExtentControl> {
}

/**
 * 相机飞行参数，Center(相机位置)和Extent(要观察的视域范围)都有的情况下，Center优先
 */
declare interface FlyToOptions extends Vision, Partial<FlyToControl> {
}

/**
 * 根据目标点定位(非相机位置)
 * @param viewer - Cesium.Viewer实例
 * @param point - 点
 * @param options - 飞行到点控制参数
 */
declare function flyToPoint(viewer: Cesium.Viewer, point: ParserLatLngPointInput, options?: FlyToPointControl): void;

/**
 * 相机飞行到目标点控制参数(非相机位置)
 */
declare interface FlyToPointControl extends FlyToControl, Partial<Orientation> {
    /**
     * 缩放系数 - ^[自定义: 额外参数配置]
     */
    scale?: number;
    /**
     * 最小视角高度 - ^[自定义: 额外参数配置]
     */
    minHeight?: number;
    /**
     * 最大视角高度 - ^[自定义: 额外参数配置]
     */
    maxHeight?: number;
    /**
     * 视角高度 - ^[自定义: 额外参数配置]
     */
    radius?: number;
    /**
     * 是否为贴地对象 - ^[自定义: 额外参数配置]
     */
    clampToGround?: boolean;
    /**
     * 最小俯仰角，-90 至 90 - ^[自定义: 额外参数配置]
     */
    minPitch?: number;
    /**
     * 最大俯仰角，-90 至 90 - ^[自定义: 额外参数配置]
     */
    maxPitch?: number;
}

/**
 * 相机飞行到目标点参数，不包含Extent
 */
declare interface FlyToPointOptions extends Partial<Center>, Partial<FlyToPointControl> {
}

/**
 * 定位至坐标数组
 * @param viewer - Cesium.Viewer实例
 * @param positions - Cesium.Cartesian3[]坐标数组
 * @param options - 相机飞行参数
 */
declare function flyToPositions(viewer: Cesium.Viewer, positions: Cesium.Cartesian3[], options?: FlyToPointControl): void;

/**
 * 雾天气特效类
 */
declare class FogEffect extends BaseEffect {
    protected _type: EffectTypeKey;
    protected _postProcessStage?: Cesium.PostProcessStage;
    /**
     * 雾天气特效类构造参数
     */
    options: FogEffectOptions;
    /**
     * 雾强度，默认值为`new Cesium.Cartesian4(10, 0.0, 1000, 0.9)`
     */
    fogByDistance: Cesium.Cartesian4;
    /**
     * 雾颜色，默认值为`Cesium.Color.WHITE`白色
     */
    color: Cesium.Color;
    /**
     * 最高限定高度，超出该高度不显示雾场景效果
     */
    maxHeight?: number;
    constructor(options?: FogEffectOptions);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _enableHooks(val: boolean): void;
    /**
     * 加控制，只在相机高度低于一定高度时才开启本效果
     * @param event
     */
    protected _camera_changedHandler(event: any): void;
}

/**
 * 雾天气特效类构造参数类型
 */
declare interface FogEffectOptions extends BaseEffectOptions {
    /**
     * 雾强度，默认值为`new Cesium.Cartesian4(500, 0.0, 5000, 0.7)`
     * 即500米以内不可见度为0，500~5000米不可见度在0.0到0.7之间线性变化，5000米之外，不可见度为0.7
     */
    fogByDistance?: Cesium.Cartesian4;
    /**
     * 雾颜色，默认值为`Cesium.Color.WHITE`白色
     */
    color?: Cesium.Color;
    /**
     * 最高限定高度，超出该高度不显示雾场景效果，默认值为`9000`
     */
    maxHeight?: number;
}

/**
 * 遍历树结构数据
 * @param tree - 目标树结构
 * @param func - 回调函数
 * @param config - 配置项
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 children: 'children',
 }
 ```
 */
declare function forEachTree<T = any>(tree: T[], func: (n: T) => any, config?: Partial<TreeMappingConfig>): void;

/**
 * 格式化数字，返回指定小数位的数字
 * @param num 数字
 * @param digits 小数位数
 * @returns 返回digits指定小数位的数字
 */
declare function formatNum(num: number, digits?: number): number;

/**
 * 格式化 Rectangle 矩形对象，返回经纬度值的范围
 * @param rectangle Cesium Rectangle 矩形对象
 * @param digits 经纬度保留的小数位数，默认为 6
 * @returns 返回经纬度范围对象，包括 xmin、xmax、ymin、ymax 四个属性
 */
declare function formatRectangle(rectangle: Cesium.Rectangle, digits?: number): Extent;

/**
 * 经纬度坐标转换，
 * 国测局坐标 (GCJ02) 转换为 百度坐标 (BD09)
 * @param arrdata - 国测局坐标 (GCJ02) 坐标数据，示例：[117.225590,31.832916]
 * @returns 百度坐标 (BD09)坐标数据，示例：[117.232039,31.839177]
 * @group 功能: 坐标转换相关
 */
declare function gcj2bd(arrdata: number[]): number[];

/**
 * 经纬度坐标转换，
 * 国测局坐标 (GCJ02) 转换为 标准无偏坐标（WGS84）
 * @param arrdata - 国测局坐标 (GCJ02) 坐标数据，示例：[117.225590,31.832916]
 * @returns 标准无偏坐标（WGS84）坐标数据，示例：[117.220102, 31.834912]
 * @group 功能: 坐标转换相关
 */
declare function gcj2wgs(arrdata: number[]): number[];

/**
 * 将投影坐标对象转为经纬度坐标对象
 * @param bounds - 对象: `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`
 * @returns 对象: `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`
 */
declare function geLatLngBounds(bounds: Extent): {
    xmin: number;
    ymin: number;
    xmax: number;
    ymax: number;
};

/**
 * geojson矢量图层类
 * 该类中矢量数据是使用Ceisum原生方法加载的entity对象
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const geojsonLayer = new KBE3D.layers.GeojsonLayer({
 id: 'test1',
 name: 'test1',
 flyTo: true,
 source: '/data/即墨区.json',
 outline: KBE3D.Cesium.Color.GREEN,
 label: {
 textField: 'name',
 constructorOptions: {
 fillColor: KBE3D.Cesium.Color.RED,
 },
 },
 popup: {
 entity: true,
 },
 })
 earth.addLayer(geojsonLayer)
 geojsonLayer.on('click', (event: BaseEvent<PickTargetInfo>) => {
 const forceData = JSON.stringify(
 event.data?.sourceTarget._attr,
 )
 geojsonLayer.popup?.open(forceData, event.data.cartesian)
 })
 * ```
 */
declare class GeojsonLayer extends BaseGraphicLayer {
    protected _type: LayerTypeKey;
    /**
     * 文字标注的primitive集
     */
    protected _labelCollection?: Cesium.LabelCollection;
    /**
     * GeojsonDataSource数据集
     */
    protected _dataSource?: Cesium.GeoJsonDataSource;
    /**
     * 透明度：0~1
     */
    protected _opacity: number;
    /**
     * 所有的geojson数据原始对象（多次load合并后）
     */
    protected _allGeojsonData?: AllGeoJSON;
    /**
     * GeojsonLayer构造参数
     */
    options: GeojsonLayerOptions;
    constructor(options: GeojsonLayerOptions);
    get layerSource(): any;
    /**
     * 文字标注的primitive集
     * @readonly
     */
    get labelCollection(): Cesium.LabelCollection | undefined;
    /**
     * Entity矢量数据的集合类
     * @readonly
     */
    get entities(): Cesium.EntityCollection | undefined;
    /**
     * Entity矢量数据实例的集合
     * @readonly
     */
    get entitiesValues(): Cesium.Entity[] | undefined;
    /**
     * 所有的geojson数据原始对象（多次load合并后）
     * @readonly
     */
    get allGeojsonData(): AllGeoJSON | undefined;
    /**
     * 透明度，取值范围：0.0-1.0
     */
    get opacity(): number;
    /**
     * 设置透明度，取值范围：0.0-1.0
     */
    set opacity(val: number);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    /**
     * 获取对象数组中，_attr属性与传入attr对象一致的数组
     * @param oriArr - entity数组
     * @param attr - 对比的属性
     * @returns 过滤后attr属性一致的数组
     */
    protected _filterEqualsAttr(oriArr: any[], attr: Record<string, any>): Cesium.Entity[];
    /**
     * 处理load加载的数据
     * @param dataSource
     */
    protected _handlerDataSource(dataSource: Cesium.DataSource): void;
    protected _addLabel(entity: Cesium.Entity, text: string, options?: Cesium.LabelGraphics.ConstructorOptions, attr?: Record<string, any>): Cesium.Label | undefined;
    /**
     * 获取Entity矢量对象上绑定的数据
     * @param entity Entity矢量对象
     * @returns Record数据
     */
    protected _getEntityAttr(entity: Cesium.Entity): Record<string, any>;
    /**
     * 更新entity的透明度
     * @param color
     * @param opacity
     */
    protected _updatEntityAlpha(color: Cesium.ConstantProperty, opacity: number): Cesium.ConstantProperty | undefined;
    getRectangle(isFormat: true): Extent | undefined;
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
    flyTo(options?: FlyToControl | FlyToExtentControl): boolean;
    /**
     * 设置图层顺序层级
     * @param val
     */
    setZIndex(val: number): void;
    /**
     * 加载geojson数据
     * 如果未设置source参数，将根据其他入参刷新已存在的旧数据的相关配置，与构造参数的配置合并
     * @param newOptions - 新设定的参数，会与类的构造参数合并
     */
    load(newOptions?: Partial<GeojsonLayerLoadOptions>): Promise<void>;
    /**
     * 设置透明度
     * @param value - 透明度
     */
    setOpacity(value: number): void;
}

declare interface GeojsonLayerLoadOptions {
    /**
     * geojson数据的URL 或 geojson数据对象 或 一个返回geojson数据对象的Promise 或 是一个返回geojson数据对象方法 或 Cesium.Resource请求对象
     */
    source?: Record<string, any> | string | Promise<Record<string, any>> | ((...args: any[]) => Record<string, any>) | Cesium.Resource;
    /**
     * 是否保留地球上已经加载的数据，默认为`false`
     */
    keepOldSource?: boolean;
    /**
     * 图层透明度， 0~1，默认为`1`
     */
    opacity?: number;
    /**
     * 为每个点创建的地图图钉的默认大小，以像素为单位，默认为 `48`
     */
    markerSize?: number;
    /**
     * 为每个点创建的地图图钉的默认符号，默认为 `undefined`
     * 可接受如下格式的图片数据:
     * 1. 前端项目public目录下的静态资源
     * @example
     * ```
     markerSymbol: '/assets/demo.png',
     * ```
     * 2. 前端项目src或其他目录下的资源动态引入
     * @example
     * ```
     * // vite示例
     markerSymbol: (await import('@/assets/demo.png')).default,
     // webpack示例
     markerSymbol: require('@/assets/demo.png'),
     * ```
     * 3. 前缀为 "data:" 协议的字符串URI
     * @example
     * ```
     markerSymbol: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby...',
     * ```
     */
    markerSymbol?: string;
    /**
     * 为每个点创建的地图图钉的默认颜色，默认为 `Cesium.Color.ROYALBLUE`
     * 可以是css颜色值、Cesium.Color对象或函数，用于生成颜色
     */
    markerColor?: string | Cesium.Color | ((...args: any[]) => string | Cesium.Color | undefined);
    /**
     * 折线和多边形轮廓的默认颜色，默认为 `Cesium.Color.GREEN`
     * 可以是css颜色值、Cesium.Color对象或函数，用于生成颜色
     */
    outline?: string | Cesium.Color | ((...args: any[]) => string | Cesium.Color | undefined);
    /**
     * 折线和多边形轮廓的默认宽度，默认为 `1`
     */
    outlineWidth?: number;
    /**
     * 多边形内部的默认颜色，默认为 `Cesium.Color.YELLOW`，如需调整透明度，请通过`opacity`属性进行设置，在这里设置无效
     * 可以是css颜色值、Cesium.Color对象或函数，用于生成颜色
     */
    fill?: string | Cesium.Color | ((...args: any[]) => string | Cesium.Color | undefined);
    /**
     * 是否要将几何特征（多边形或线串）固定在地面上，默认为`false`
     */
    clampToGround?: boolean;
    /**
     * 文字标注构造，不传值或设置为`false`将不会启用
     */
    label?: {
        /**
         * 指定文本在geojson数据properties属性中的字段名，支持显式换行符“\n”
         */
        textField: string;
        /**
         * label构造器参数类型
         * @defaultValue
         * ```ts
         * {
         // Cesium default
         show: true,
         font: '30px sans-serif',
         style: Cesium.LabelStyle.FILL,
         scale: 1,
         showBackground: false,
         backgroundColor: new Cesium.Color(0.165, 0.165, 0.165, 0.8),
         backgroundPadding: new Cesium.Cartesian2(7, 5),
         pixelOffset: Cesium.Cartesian2.ZERO,
         eyeOffset: Cesium.Cartesian3.ZERO,
         horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
         verticalOrigin: Cesium.VerticalOrigin.CENTER,
         heightReference: Cesium.HeightReference.NONE,
         fillColor: Cesium.Color.WHITE,
         outlineColor: Cesium.Color.BLACK,
         outlineWidth: 1,
         // custom settings
         scaleByDistance: new Cesium.NearFarScalar(1000, 1, 80000, 0.5),
         }
         * ```
         */
        constructorOptions?: Cesium.LabelGraphics.ConstructorOptions;
    };
}

/**
 * geojson矢量图层类构造参数类型
 */
declare interface GeojsonLayerOptions extends BaseGraphicLayerOptions, GeojsonLayerLoadOptions {
}

/**
 * 返回给定DOM id的元素，或者返回元素本身
 * @param id - dom的id
 * @returns DOM元素
 * @group 功能: Dom操作相关
 */
declare function get(id: string | HTMLElement): HTMLElement | null;

/**
 * 从给定位置选择第一个与之相交的 3D Tileset
 * @param viewer - Cesium.Viewer实例
 * @param positions - 要从中选择 3D Tileset 的位置
 * @returns 如果找到，则返回选择的 3D Tileset；否则返回 null
 */
declare function get3DTilesetByPosition(viewer: Cesium.Viewer, positions: Cesium.Cartesian3 | Cesium.Cartesian3[]): Cesium.Cesium3DTileset | null;

/**
 * 取properties属性值，简化Cesium内的属性，去掉getValue等，取最简的键值对。
 * @param attr - Cesium内的属性对象
 * @param onlySimpleType - 是否只获取简易类型的对象
 * @returns 最简的键值对属性对象
 */
declare function getAttrVal(attr: Record<string, any>, onlySimpleType?: boolean): Record<string, any>;

/**
 * 求贝塞尔曲线坐标，核心为turf.bezierSpline，仅支持二维平面
 * @param positions - 三个点以上的坐标数组
 * @param closure - 是否闭合曲线
 * @returns Cesium.Cartesian3坐标数组
 */
declare function getBezierCurve(positions: ParserLatLngPointInput[], closure?: boolean): ParserLatLngPointInput[] | (Cesium.Cartesian3 | Cesium.Cartesian3[])[];

/**
 * 获取相机的高度值
 * @param viewer - Cesium.Viewer实例
 * @returns 相机的高度值
 */
declare function getCameraAltitude(viewer: Cesium.Viewer): number;

/**
 * 获取相机到屏幕中心点的距离。
 * @returns 相机到屏幕中心点的距离，单位：米。
 */
declare function getCameraDistance(viewer: Cesium.Viewer): number;

/**
 * 获取当前相机视角信息
 * @param viewer - Cesium.Viewer实例
 * @param simplify - 是否简化返回信息
 * @returns - 包含经纬度、高度、航向、俯仰（可能包含翻滚角）的对象
 */
declare function getCameraVision(viewer: Cesium.Viewer, simplify?: boolean): CameraViewInfo;

/**
 * 获取canvas中心点的经纬度坐标
 * @param viewer - Cesium.Viewer实例
 * @returns 屏幕中心点的经纬度坐标
 */
declare function getCanvasCenterCoords(viewer: Cesium.Viewer): LatLngPoint | undefined;

/**
 * 根据笛卡尔三维坐标点获取canvasXY坐标
 * @param viewer - Cesium.Viewer实例
 * @param position - 笛卡尔三维坐标点
 * @returns 返回该点的canvasXY坐标
 */
declare function getCanvasXY(viewer: Cesium.Viewer, position: ParserLatLngPointInput): Cesium.Cartesian2;

/**
 * 求坐标数组的中心点
 * @param arr - 坐标数组
 * @param height - 指定中心点的高度值，默认为所有点的最高高度
 * @returns Cesium.Cartesian3中心点坐标
 */
declare function getCenterFromParserArr(arr: ParserLatLngPointInput[], height?: number): any;

/**
 * 求2点的中间点（贴地表）
 * @param mpt1 - 点1坐标
 * @param mpt2 - 点2坐标
 * @returns 2个点是否为重复的点，类型为Cesium.Cartesian3
 */
declare function getCenterFromTwoCart3(mpt1: Cesium.Cartesian3, mpt2: Cesium.Cartesian3): Cesium.Cartesian3;

/**
 * 获取Cesium颜色对象
 * @param color css颜色值、Cesium.Color对象或函数，用于生成颜色
 * @param defval 默认值，类型为Cesium.Color
 * @param eventParams 是回调方法时传入回调的参数，可以是任意类型
 * @returns {Cesium.Color} 颜色值
 */
declare function getCesiumColor(color: string | Cesium.Color | ((eventParams?: any) => string | Cesium.Color | undefined) | Cesium.Property | undefined, defval?: Cesium.Color, eventParams?: any): Cesium.Color;

/**
 * 获取Cesium对象值的最终value值。
 * 因为Cesium经常属性或绑定一层，通过本方法可以内部去判断是否有getValue或_value进行取最终value值。
 * @param obj - Cesium对象值
 * @param ClassName - Cesium的类名，方便识别判断。应为一个构造函数。
 * @param time - 如果具有时间属性，取指定时间的值
 * @returns 最终value值
 */
declare function getCesiumValue(obj: any, ClassName?: any, time?: Cesium.JulianDate): any;

/**
 * 根据经度值 获取CGCS2000投影坐标对应的 EPSG值
 * @param lng - 经度值
 * @param fd6 - 是否为6度分带，true:6度分带, false:3度分带
 * @param hasAddDH - 横坐标前是否加带号
 * @returns EPSG值，如果不存在则返回undefined
 * @group 功能: 坐标转换相关
 */
declare function getCGCS2000EPSGByLng(lng: number, fd6: boolean, hasAddDH?: boolean): string | undefined;

/**
 * 根据加带号的横坐标值 获取CGCS2000投影坐标对应的EPSG值
 * @param x - 根据加带号的横坐标值
 * @returns EPSG值，如果不存在则返回undefined
 * @group 功能: 坐标转换相关
 */
declare function getCGCS2000EPSGByX(x: number): string | undefined;

/**
 * 获取dom元素上的class样式名称
 * @param el - DOM元素
 * @returns class样式名称
 * @group 功能: Dom操作相关
 */
declare function getClass(el: HTMLElement | SVGElement): string;

/**
 * 根据配置信息获取Cesium颜色对象。
 * @param style 配置信息
 * @param style.color 颜色值，可以是字符串、Cesium.Color对象或函数，函数应返回Cesium.Color对象
 * @param style.opacity 透明度，范围在0.0到1.0之间
 * @param style.randomColor 是否使用随机颜色
 * @param style.minimumRed 随机颜色时的最小红色值（如果style.randomColor为true）
 * @param style.maximumRed 随机颜色时的最大红色值（如果style.randomColor为true）
 * @param style.minimumGreen 随机颜色时的最小绿色值（如果style.randomColor为true）
 * @param style.maximumGreen 随机颜色时的最大绿色值（如果style.randomColor为true）
 * @param style.minimumBlue 随机颜色时的最小蓝色值（如果style.randomColor为true）
 * @param style.maximumBlue 随机颜色时的最大蓝色值（如果style.randomColor为true）
 * @param defval 默认值，默认为Cesium.Color.YELLOW
 * @returns 颜色值，类型为Cesium.Color
 */
declare function getColorByStyle(style: {
    color?: string | Cesium.Color | ((style: any) => Cesium.Color);
    opacity?: number;
    randomColor?: boolean;
    minimumRed?: number;
    maximumRed?: number;
    minimumGreen?: number;
    maximumGreen?: number;
    minimumBlue?: number;
    maximumBlue?: number;
    [x: string]: any;
}, defval?: Cesium.Color): Cesium.Color;

/**
 * 获取当前图层的图例图片
 * @param colorRamp - 颜色渐变数组，例如：`[{ value: 0, color: '#ff0000' }, { value: 100, color: '#0000ff' }]`
 * @param ctype - 图例渲染类型（linear：线性渐变，block：色块）
 * @returns 返回canvas以及绘制上下文ctx以及image前缀为 "data:" 协议的字符串URI，例如: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby..."
 */
declare function getColorRampLegend(colorRamp: ColorRamp_2, ctype?: 'linear' | 'block'): {
    ctx: CanvasRenderingContext2D;
    canvas: HTMLCanvasElement;
    image: string;
} | undefined;

/**
 * 获取canvasXY坐标（如鼠标所在位置)对应的笛卡尔三维坐标点
 * @param viewer - Cesium.Viewer实例
 * @param position - canvasXY坐标
 * @param config - 其他配置参数
 * @param config.onlyPickModelPosition - 是否只取模型上的交叉点
 * @param config.noPickEntity - 需要被排除的实体对象
 * @returns 如果找到合适的地理坐标点则返回该点的Cartesian3笛卡尔坐标，否则返回 null
 */
declare function getCurrentMousePosition(viewer: Cesium.Viewer, position: Cesium.Cartesian2, config?: {
    onlyPickModelPosition?: boolean;
    noPickEntity?: any;
}): Cesium.Cartesian3 | undefined;

/**
 * 获取当前视域边界
 * @param viewer - Cesium.Viewer实例
 * @param digits 经纬度保留的小数位数，默认为 6
 * @returns 当前视域边界
 */
declare function getExtent(viewer: Cesium.Viewer, digits?: number): Extent;

/**
 * 根据路径获取图片Base64编码
 * @group 功能: image操作相关
 */
declare function getImgBase64(src: string): Promise<string>;

/**
 * 获取 坐标数组中的最高高程值
 * @param positions - 笛卡尔坐标数组
 * @param defaultVal - 默认高程值
 * @returns 最高高程值
 */
declare function getMaxHeight(positions: Cesium.Cartesian3[], defaultVal?: number): number;

/**
 * 将经纬度坐标对象转为投影坐标对象
 * @param bounds - 对象: `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`
 * @returns 对象: `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`
 */
declare function getMercatorBounds(bounds: Extent): {
    xmin: number;
    ymin: number;
    xmax: number;
    ymax: number;
};

/**
 * 计算两点间的曲线链路的点集获取抛物曲线
 * @param start - 开始节点
 * @param end - 结束节点
 * @param angularityFactor - 曲率因子，默认值10000
 * @param numOfSingleLine - 点集数量，默认值50
 * @returns Cesium.Cartesian3曲线坐标数组
 */
declare function getParabolaCurve(start: ParserLatLngPointInput, end: ParserLatLngPointInput, angularityFactor?: number, numOfSingleLine?: number): Cesium.Cartesian3[];

/**
 * 获取entity polygon面的外围坐标
 * @param polygon - entity.polygon对象
 * @returns Cartesian3坐标数组
 */
declare function getPolygonPositions(polygon: Cesium.PolygonGraphics): Cesium.Cartesian3[];

/**
 * 获取位置属性对象的最终 Cartesian3 值，根据传入的位置对象，内部判断是否有 getValue 方法或 _value 属性来获取最终的 Cartesian3 值。
 * @param position - 位置属性对象，可以是 Cartesian3、SampledPositionProperty 或其他类型 - {Cesium.Cartesian3 | Cesium.SampledPositionProperty | any}
 * @param  time - 指定的时间值，默认为当前时间 - {Cesium.JulianDate}
 * @returns 返回具体的 Cesium.Cartesian3 对象坐标值，如果无法获取则返回 undefined
 */
declare function getPositionValue(position: Cesium.Cartesian3 | Cesium.SampledPositionProperty | any, time?: Cesium.JulianDate): Cesium.Cartesian3 | undefined;

/**
 * 根据给定值和 CanvasRenderingContext2D 获取颜色值
 * @param ctx CanvasRenderingContext2D 对象
 * @param value 用于计算颜色的值，范围在 0 到 90 之间
 * @returns 包含 RGBA、RGB、HEX 颜色值以及红、绿、蓝、透明度值的对象
 */
declare function getRampValueColor(ctx: CanvasRenderingContext2D, value: number, minValue: number, maxValue: number): {
    rgba: string;
    rgb: string;
    hex: string;
    r: number;
    g: number;
    b: number;
    a: number;
};

/**
 * 获取坐标数组的矩形范围边界值
 * @param positions - 坐标数组
 * @param isFormat - 是否格式化
 * @returns isFormat：true时，返回格式化对象，如： `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`; isFormat：false时返回Cesium.Rectangle对象;
 */
declare function getRectangle(positions: Array<ParserLatLngPointInput>, isFormat?: boolean): Cesium.Rectangle | Extent;

/**
 * 返回元素上某个样式属性的值
 * @param el - 指定的DOM元素
 * @param style - 样式名称
 * @returns 样式的值或null
 * @group 功能: Dom操作相关
 */
declare function getStyle(el: HTMLElement, style: string): string | null;

/**
 * 获取使用 3D Tiles 的指定位置的表面高度
 * @param viewer - Cesium.Viewer实例
 * @param position - 要获取高度的位置
 * @param options - 高度计算的选项
 * @returns 使用 3D Tiles 的指定位置的表面高度
 */
declare function getSurface3DTilesHeight(viewer: Cesium.Viewer, position: Cesium.Cartesian3, options?: HeightOptions): number;

/**
 * 获取指定位置的表面高度
 * @param viewer - Cesium.Viewer实例
 * @param position - 要获取高度的位置
 * @param options - 高度计算的选项
 * @returns 指定位置的表面高度
 */
declare function getSurfaceHeight(viewer: Cesium.Viewer, position: Cesium.Cartesian3, options?: HeightOptions): number;

/**
 * 获取指定位置的地形表面高度
 * @param viewer - Cesium.Viewer实例
 * @param position - 要获取高度的位置
 * @param options - 高度计算的选项
 * @returns 指定位置的地形表面高度
 */
declare function getSurfaceTerrainHeight(viewer: Cesium.Viewer, position: Cesium.Cartesian3, options?: HeightOptions): number;

/**
 * 文字转base64图片的函数
 * @param text - 文字内容
 * @param textStyle - 文本样式参数对象
 * @returns 返回canvas对象，如果无法创建则返回null
 */
declare function getTextImage(text: string, textStyle?: TextStyleOptions): HTMLCanvasElement | null;

/**
 * 根据"WGS84" | "GCJ02" | "BD09"坐标系类型获取对应的坐标转换方法
 * srcCoordType 转 dstCoordType 对应的方法名称
 * @param srcCoordType - 原始的坐标系
 * @param dstCoordType - 转换后的坐标系
 * @returns PointTrans中对应的坐标转换方法
 */
declare function getTransFun(srcCoordType: ChinaCRSValue, dstCoordType: ChinaCRSValue): any;

/**
 * 根据高度获取地图层级
 * @param altitude - 高度值
 * @returns 地图层级，通常为 1-22
 */
declare function getZoomLevelByAltitude(altitude: number): number;

/**
 * 获取当前相机高度的地图层级
 * @param viewer - Cesium.Viewer实例
 * @returns 当前相机高度的地图层级
 */
declare function getZoomLevelByCameraAltitude(viewer: Cesium.Viewer): number;

/**
 * graphic矢量图层类
 * 该类中用于加载Ceisum原生entity对象和primitive对象
 */
declare class GraphicLayer extends BaseGraphicLayer {
    protected _type: LayerTypeKey;
    /**
     * 透明度：0~1
     */
    protected _opacity: number;
    /**
     graphic矢量数据图层类构造参数
     */
    options: GraphicLayerOptions;
    constructor(options?: GraphicLayerOptions);
    getRectangle(isFormat: true): Extent | undefined;
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
}

/**
 * graphic矢量图层类构造参数类型
 */
declare interface GraphicLayerOptions extends BaseGraphicLayerOptions {
    /**
     * 图层透明度， 0~1
     */
    opacity?: number;
}

/**
 * group图层组类
 * 可以用于将多个图层组合起来方便控制（比如将 卫星底图 和 文字注记层 放在一起控制管理），或用于 图层管理 的图层分组节点（虚拟节点）
 */
declare class GroupLayer extends BaseLayer {
    protected _type: LayerTypeKey;
    /**
     * 子图层数组
     */
    protected _arrLayer: BaseLayer[];
    /**
     group图层组类构造参数
     */
    options: GroupLayerOptions;
    /**
     * @param options - group图层组类构造参数
     */
    constructor(options?: GroupLayerOptions);
    get isTile(): boolean;
    get layerSource(): any;
    get zIndex(): number;
    set zIndex(val: number);
    /**
     * 子图层的个数
     * @readonly
     */
    get length(): number;
    /**
     * 是否拥有子图层
     * @readonly
     */
    get hasChildLayer(): boolean;
    /**
     * 是否空组 ，空组目前就图层管理用于图层分组节点（虚拟节点）
     * @readonly
     */
    get hasEmptyGroup(): boolean;
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _showHooks(val: boolean): void;
    protected _toJsonHooks(options: CreateLayerOptions): void;
    setZIndex(val: number): void;
    getRectangle(isFormat: true): Extent | undefined;
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
    /**
     * 添加子图层，并绑定关联关系。
     * @param childlayer - 子图层对象
     */
    addLayer(childlayer: BaseLayer): void;
    /**
     * 移除子图层，并解除关联关系
     * @param childlayer - 子图层对象
     */
    removeLayer(childlayer: BaseLayer): true | undefined;
    /**
     * 遍历每一个子图层并将其作为参数传递给回调函数
     * @param method - 回调方法
     * @param context - 侦听器的上下文(this关键字将指向的对象)
     */
    eachLayer(method: (layer: BaseLayer) => any, context?: any): void;
    /**
     * 获取地图所有的子图层对象(包括pid和id关联的图层)
     * @returns 所有子图层对象
     */
    getChildLayers(): BaseLayer[];
    /**
     * 根据图层id或uuid或name获取图层
     * @param value - 图层id或uuid或name
     * @returns 图层对象
     */
    getLayer(value: string | number): BaseLayer | undefined;
    /**
     * 是否有同名的子图层，一般用于新增时判断
     * @param name - 图层名称
     * @param excludedLayer - 可以指定不进行判断的图层，比如当前图层本身
     * @returns 是否同名
     */
    hasLayer(name: string | number, excludedLayer?: BaseLayer): boolean;
}

/**
 * group图层组类构造参数
 */
declare interface GroupLayerOptions extends BaseLayerOptions {
    /**
     * 子图层数组，每个子图层的配置见按各类型图层配置即可
     */
    layers?: CreateLayerOptions[];
    /**
     * 图层顺序，数字大的在上面
     */
    zIndex?: number;
}

/**
 * guid生成器
 * @param randomBlocks - 随机块的数量
 * @returns guid - 139aca66-2024bc60-2f847b9701be62a163 // Fixed length: 36
 * @group 功能: 随机ID相关
 */
declare function guid(randomBlocks?: number): string;

/**
 * 判断元素是否有指定class样式
 * @param el - DOM元素
 * @param name - class样式名称
 * @returns 包含返回`true`，不包含返回`false`
 * @group 功能: Dom操作相关
 */
declare function hasClass(el: HTMLElement, name: string): boolean;

/**
 * heat平面热力图层类
 */
declare class HeatLayer extends BaseGraphicLayer {
    protected _type: LayerTypeKey;
    /**
     * 矩形范围边界
     */
    protected _rectangle?: Cesium.Rectangle;
    /**
     * heatmap.js热力图实例
     */
    protected _heat?: Heatmap<'value', 'x', 'y'>;
    /**
     * heatmap.js渲染所需的临时dom
     */
    protected _container?: HTMLDivElement;
    /**
     * 热力数据生成的primitive对象
     */
    protected _primitive?: Cesium.Primitive | Cesium.GroundPrimitive;
    /**
     * 热力数据点数组
     */
    protected _points: HeatPoint[];
    /**
     * 色带
     */
    protected _colorRamp: ColorRamp;
    /**
     * 色带
     */
    protected _maxVal: number;
    /**
     * 色带
     */
    protected _minVal: number;
    /**
     * GeojsonLayer构造参数
     */
    options: HeatLayerOptions;
    constructor(options: HeatLayerOptions);
    /**
     * 获取热力数据的矩形范围边界
     * @readonly
     */
    get rectangle(): Rectangle | undefined;
    /**
     * 获取热力图样式配置参数
     */
    get heatStyle(): HeatStyleOptions | undefined;
    /**
     * 设置热力图样式配置参数
     */
    set heatStyle(value: HeatStyleOptions | undefined);
    /**
     * 获取热力数据点数组
     */
    get points(): HeatPoint[] | undefined;
    /**
     * 设置热力数据点数组
     */
    set points(value: HeatPoint[] | undefined);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    /**
     * 热力数据渲染
     */
    protected _render(): void;
    /**
     * 处理数据并返回生成的图片
     * @returns 图片：前缀为 "data:" 协议的字符串URI
     */
    protected _createHeatCanvasImg(): any;
    /**
     * 创建普通平面热力图图元对象
     * @param image - 图片：前缀为 "data:" 协议的字符串URI
     */
    protected _createPrimitive(image: string): void;
    /**
     * 设置热力数据
     * @param value 热力数据（含热力值）
     */
    setPoints(value?: HeatPoint[]): void;
    /**
     * 设置热力图样式配置参数，与初始参数进行合并
     * @param value 热力图样式配置
     */
    setHeatStyle(value?: HeatStyleOptions): void;
    /**
     * 添加新的坐标点
     * @param point 坐标点（含热力值）
     */
    addPosition(point: HeatPoint): void;
    getRectangle(isFormat: true): Extent | undefined;
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    getRectangle(isFormat?: boolean): Extent | Cesium.Rectangle | undefined;
    /**
     * 获取当前图层的图例图片
     * @param ctype - 图例渲染类型（linear：线性渐变，block：色块）
     * @returns 返回前缀为 "data:" 协议的字符串URI，例如: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby..."
     */
    getLegendImage(ctype?: 'linear' | 'block'): string | undefined;
}

/**
 *  heat平面热力图层类构造参数类型
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const heatLayer = new KBE3D.layers.HeatLayer({
 id: 'test1',
 name: 'test1',
 flyTo: true,
 source: url,
 })
 earth.addLayer(heatLayer)
 * ```
 */
declare interface HeatLayerOptions extends BaseGraphicLayerOptions {
    /**
     * 热力数据的json URL 或 热力数据数组对象(数组中的对象应至少包含x、y、value三个属性) 或 一个返回热力数据数组对象的Promise 或 是一个返回热力数据数组对象的方法 或 Cesium.Resource请求对象
     */
    source?: Array<HeatPoint> | string | Promise<Array<HeatPoint>> | ((...args: any[]) => Array<HeatPoint>) | Cesium.Resource;
    /**
     * 热力图样式配置参数
     */
    heatStyle?: HeatStyleOptions;
    /**
     * 高度，相对于椭球面的高度，默认值`0`
     */
    height?: number;
    /**
     * 是否贴地
     */
    aboveGround?: boolean;
    /**
     * Canvas最大尺寸（单位：像素），调大精度更高，但过大容易内存溢出，默认值`5000`
     */
    maxCanvasSize?: number;
    /**
     * Canvas最小尺寸（单位：像素），默认值`700`
     */
    minCanvasSize?: number;
}

/**
 * 平面热力图片材质构造参数 - ^[Primitive使用]
 */
declare interface HeatMaterialOptions {
    /**
     * 基础背景图片
     * 可接受如下格式的图片数据:
     * 1. 前端项目public目录下的静态资源
     * @example
     * ```
     u_image: '/assets/demo.png',
     * ```
     * 2. 前端项目src或其他目录下的资源动态引入
     * @example
     * ```
     * // vite示例
     u_image: (await import('@/assets/demo.png')).default,
     // webpack示例
     u_image: require('@/assets/demo.png'),
     * ```
     * 3. 前缀为 "data:" 协议的字符串URI
     * @example
     * ```
     image: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNby...',
     * ```
     */
    u_image: string;
}

/**
 * 热力点
 */
declare interface HeatPoint {
    x: number;
    y: number;
    value: number;
    [attrs: string]: any;
}

/**
 * 平面热力图样式配置参数类型
 * 详情也可查阅 @see {@link https://www.patrick-wied.at/static/heatmapjs/docs.html | heatmap文档}
 */
declare interface HeatStyleOptions {
    /**
     * 最大不透明度，取值范围0.0-1.0，默认值为`0.8`
     */
    maxOpacity?: number;
    /**
     * 最小不透明度，取值范围0.0-1.0，默认值为`0.3`
     */
    minOpacity?: number;
    /**
     * 将应用于所有数据点的模糊因子。模糊因子越高，渐变将越平滑，默认值为`0.85`
     */
    blur?: number;
    /**
     * 每个数据点将具有的半径，默认值为`25`
     */
    radius?: number;
    /**
     * 色带(对象类型，其中key的取值范围为0~1)，默认值为如下示例值
     * @example
     * ```
     * { 0: 'blue', 0.2: 'green', 0.4: 'yellow', 0.7: 'red', 1:'purple' }
     * ```
     */
    gradient?: Record<number, string>;
}

/**
 * 选项，用于控制高度计算的行为
 */
declare interface HeightOptions {
    /**
     * 是否检查 3D Tiles 的高度，如果未提供，默认为 true
     */
    has3dtiles?: boolean;
    /**
     * 要计算高度的地理位置
     */
    cartographic?: Cesium.Cartographic;
    /**
     * 高度获取后的回调函数
     */
    callback?: (height: number, cartographic: Cesium.Cartographic) => void;
    /**
     * 是否使用异步高度计算
     */
    async?: boolean;
    /**
     * 在计算高度时要排除的不进行贴模型计算的模型对象，可以是： primitives, entities, 或 3D Tiles features
     */
    objectsToExclude?: Cesium.Cesium3DTileFeature[];
}

/**
 * 3dtiles模型高亮特效类，支持feature的描边、单体颜色高亮
 */
declare class HighlightTileset {
    /** Cesium.Viewer实例 */
    _viewer: Cesium.Viewer;
    /** 应用高亮的3dtiles模型对象 */
    _tileset: Cesium.Cesium3DTileset;
    /**
     * 描边特效缓存
     */
    edgeCache: Record<string, Cesium.PostProcessStage>;
    /**
     * 选中缓存
     */
    selected: Record<string, Cesium.Cesium3DTileFeature[]>;
    /**
     * 高亮模式缓存
     */
    highlightSchemaCache: Record<string, HighlightTilesetSchema>;
    /**
     * @param options - 3dtiles模型高亮特效类构造函数
     */
    constructor(options: HighlightTilesetOptions);
    /**
     * 添加自定义高亮模式
     * @param schema - 自定义高亮模式
     */
    addHighlightSchema(schema: HighlightTilesetSchema): void;
    /**
     * 更新自定义高亮模式
     * @param schema - 自定义高亮模式
     * @param mergeSchema - 是否与更新前的schema合并，默认为true
     */
    updateHighlightSchema(schema: HighlightTilesetSchema, mergeSchema?: boolean): void;
    /**
     * 移除自定义高亮模式
     * @param schemaId  - 用于高亮的模式Id
     */
    removeHighlightSchema(schemaId: string): void;
    /**
     * 开启单个高亮
     * @param feature - 需要高亮的特征
     * @param schemaId - 用于高亮的模式Id
     * @param clear - 是否清除之前的高亮
     */
    openHighlight(feature: Cesium.Cesium3DTileFeature, schemaId?: string | number, clear?: boolean): void;
    /**
     * 关闭单个高亮
     * @param feature  - 高亮的特征
     * @param schemaId  - 用于高亮的模式Id
     */
    closeHighlight(feature: Cesium.Cesium3DTileFeature, schemaId?: string | number): void;
    /**
     * 根据schemaId清除所有高亮
     * @param schemaId  - 用于高亮的模式Id，默认使用`default`
     */
    clearHighlight(schemaId?: string | number): void;
    /**
     * 清除所有schemaId对应的模式的高亮
     */
    clearAllHighlight(): void;
    /**
     * 销毁释放对象
     */
    destroy(): void;
}

/** 3dtiles模型高亮特效类构造函数 */
declare interface HighlightTilesetOptions {
    /** Cesium.Viewer实例 */
    viewer: Cesium.Viewer;
    /** 用于高亮的模型对象 */
    tileset: Cesium.Cesium3DTileset;
    /** 高亮模式，默认将采用内部定义好的defaultSchema */
    schema?: HighlightTilesetSchema;
    /** 传入自定义高亮模式后，是否与默认的defaultSchema合并 */
    mergeSchema?: boolean;
}

/** 3dtiles模型高亮模式类型 */
declare interface HighlightTilesetSchema {
    /** 模式id */
    id: string | number;
    /** 高亮样式的类型：'edge' | 'full'(描边|整体)，默认为 `edge` - ^[注意：当模型设置了`customShader`的情况下，`full`模式将不再适用] */
    type?: 'edge' | 'full';
    /**
     * 高亮的颜色，支持css颜色值，当它为Cesium.Color.WHITE（白色）时，特征的颜色不会改变，默认为 Cesium.Color.CYAN（青蓝色）
     * <span class="colorSwath" style="background: #00ffff;"></span>
     */
    selectedColor?: Cesium.Color | string;
    /**
     * 边缘强度，取值范围在0到1之间，默认值为`0.01` - ^[仅当`type`为`edge`时适用]
     * 如果你想要几乎所有计算出的边缘都被视为“显著”的，那么你可以将length设置为一个相对较小的值。
     * 如果你只想要非常明显的深度变化才被视为“显著”的，那么你应该将length设置为一个相对较大的值。
     */
    length?: number;
}

/**
 * 图片对象 转 Base64编码
 * @group 功能: image操作相关
 */
declare function image2Base64(img: HTMLImageElement): string;

/**
 * 通用：图片材质2，没有加载完成前的白色闪烁，但也不支持纯白色的图片
 */
declare class Image2MaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _image: string;
    /**
     */
    protected _opacity: any;
    constructor(options: Image2MaterialPropertyOptions);
    /**
     * 获取 材质名称
     *
     * @param {Cesium.JulianDate} [time] 检索值的时间。
     * @returns {string} 材质名称
     */
    getType(time?: Cesium.JulianDate): "Image2";
    /**
     * 获取所提供时间的属性值。
     *
     * @param {Cesium.JulianDate} [time] 检索值的时间。
     * @param {object} [result] 用于存储值的对象，如果省略，则创建并返回一个新的实例。
     * @returns {object} 修改的result参数或一个新的实例(如果没有提供result参数)。
     */
    getValue(time?: Cesium.JulianDate, result?: any): any;
    /**
     * 将此属性与提供的属性进行比较并返回, 如果两者相等返回true，否则为false
     * @param { Cesium.Property} [other] 比较的对象
     * @returns {boolean}  两者是同一个对象
     */
    equals(other?: Cesium.Property): any;
}

/**
 * 通用：图片材质2构造器类型
 */
declare interface Image2MaterialPropertyOptions {
    /**
     * 背景图片的URL。
     */
    image: string;
    /**
     * 材质的透明度。
     * 默认为`1`（完全不透明）。
     */
    opacity?: number;
    /**
     * 材质的颜色。
     * 注意：这个颜色可能用于与图片进行混合或覆盖，具体取决于材质的渲染逻辑。
     * 默认为Cesium的白色（`Cesium.Color.WHITE`）。
     */
    color?: Cesium.Color | string;
}

/**
 * image图层类
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const imageLayer = new KBE3D.layers.ImageLayer({
 id: 'test',
 name: 'test',
 url: '/img/world/blue.jpg',
 flyTo: true,
 })
 earth.addLayer(imageLayer)
 * ```
 */
declare class ImageLayer extends BaseTileLayer {
    /**
     * 创建用于图层的 ImageryProvider对象
     * @param options -  image图层类构造参数
     * @group 静态方法
     */
    static createImageryProvider(options: ImageLayerOptions): Cesium.SingleTileImageryProvider;
    protected _type: LayerTypeKey;
    /** image图层类构造参数 */
    options: ImageLayerOptions;
    /**
     * @param options - image图层类构造参数
     */
    constructor(options: ImageLayerOptions);
    protected _createImageryProvider(options: ImageLayerOptions): Cesium.ImageryProvider;
}

/**
 * image图层类构造参数类型
 * @property url - 服务地址
 * @property [tileWidth] - 瓦片的宽度，以像素为单位。
 * @property [tileHeight] - 瓦片的高度，以像素为单位。
 * @property [rectangle = Rectangle.MAX_VALUE] - 图像覆盖的矩形区域，通常应该指地理范围或屏幕上的像素范围，Rectangle.MAX_VALUE作为默认值可能表示一个非常大的矩形，覆盖整个可能的空间或屏幕。
 * @property [credit] - 数据源的归属信息，会显示在画布上。
 * @property [ellipsoid] - 椭球体。如果未指定，则使用WGS84椭球体。
 */
declare interface ImageLayerOptions extends BaseTileLayerOptions, Omit<Cesium.SingleTileImageryProvider.ConstructorOptions, 'rectangle'> {
}

/**
 * 图片材质转换处理类
 */
declare class ImageOptsConver extends BaseMaterialConver {
    get excludedKeys(): string[];
    /**
     * 转换为Cesium相关属性值
     * @param style - 样式配置
     * @param czmVal - Cesium属性值
     * @return Cesium属性值
     */
    static toCesiumVal(style: Record<string, any>, czmVal?: Record<string, any>): any;
    static toJSON(czmVal: Record<string, any>, style?: Record<string, any>): any;
    protected _toOneCesiumVal(key: string, value: any, style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toCesiumValEnd(style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toOneJson(key: string, value: any, style: Record<string, any>): void;
}

/**
 * 是否为数组
 * @group 功能: IS判断相关
 */
declare function isArray(val: any): val is Array<any>;

/**
 * 是否为boolean
 * @group 功能: IS判断相关
 */
declare function isBoolean(val: any): val is boolean;

/**
 * 是否为Center对象
 * @param options
 */
declare function isCenter(options: FlyToOptions): options is Center & Partial<Orientation> & Partial<FlyToControl>;

/**
 * 是否浏览器系统的主题色是否被设置为暗色
 * @group 功能: IS判断相关
 */
declare function isDark(): boolean;

/**
 * 是否为日期对象
 * @group 功能: IS判断相关
 */
declare function isDate(val: any): val is Date;

/**
 * 是否已声明
 * @group 功能: IS判断相关
 */
declare function isDef<T = any>(val?: T): val is T;

/**
 * 是否为dom节点
 * @group 功能: IS判断相关
 */
declare function isElement(val: any): val is Element;

/**
 * 是否为空对象或数组或Map或Set或字符串
 * @group 功能: IS判断相关
 */
declare function isEmpty<T = any>(val: T): val is T;

/**
 * 是否为Extent对象
 * @param options
 */
declare function isExtent(options: FlyToOptions): options is Extent & Partial<Orientation> & Partial<FlyToControl>;

/**
 * 是否为方法函数
 * @group 功能: IS判断相关
 */
declare function isFunction(val: any): val is Function;

/**
 * 是否为guid
 * @group 功能: 随机ID相关
 */
declare function isGuid(guid: string, blocks?: number): string | true;

/**
 * 是否为以http或https开头，以png/jpg/jpeg/gif/svg/webp/ico等结尾的图片链接
 * @group 功能: IS判断相关
 */
declare function isImgPath(path: string): boolean;

/**
 * 是否为Map对象
 * @group 功能: IS判断相关
 */
declare function isMap(val: any): val is Map<any, any>;

/**
 * 是否为可合并的对象
 * @group 功能: IS判断相关
 */
declare function isMergeableObject(val: any): any;

/**
 * 是否为number
 * @group 功能: IS判断相关
 */
declare function isNumber(val: any): val is number;

/**
 * 是否为Object
 * @group 功能: IS判断相关
 */
declare function isObject(val: any): val is Record<any, any>;

/**
 * 是否为Promise
 * @group 功能: IS判断相关
 */
declare function isPromise<T = any>(val: any): val is Promise<T>;

/**
 * 是否为正则对象
 * @group 功能: IS判断相关
 */
declare function isRegExp(val: any): val is RegExp;

/**
 * 是否为短的guid
 * @group 功能: 随机ID相关
 */
declare function isShortGuid(value: string): string;

/**
 * 判断对象是否为简单类型（包括：String\Boolean\Number\Array）
 * @param value
 * @returns 是否为简单类型（包括：String\Boolean\Number\Array）
 * @group 功能: IS判断相关
 */
declare function isSimpleType(value: any): boolean;

/**
 * 是否为string
 * @group 功能: IS判断相关
 */
declare function isString(val: any): val is string;

/**
 * 是否未声明
 * @group 功能: IS判断相关
 */
declare function isUnDef<T = any>(val?: T): val is T;

/**
 * 是否为http或https开头的url
 * @group 功能: IS判断相关
 */
declare function isUrl(path: string): boolean;

/**
 * 是否为window对象
 * @group 功能: IS判断相关
 */
declare function isWindow(val: any): val is Window;

/**
 * 经纬度地理坐标 转 投影平面坐标
 * @param arrdata - 经纬度坐标数组，示例：[117.220101,31.834907]
 * @returns WebMercator投影平面坐标数组，示例：[13048882.06,3741659.72]
 * @group 功能: 坐标转换相关
 */
declare function jwd2mct(arrdata: number[]): number[];

/**
 * Label 矢量数据style转换处理类
 */
declare class LabelStyleConver extends BaseStyleConver {
    /**
     * 转换为Cesium相关属性值
     * @param style - 样式配置
     * @param czmVal - Cesium属性值
     * @return Cesium属性值
     */
    static toCesiumVal(style: Record<string, any>, czmVal?: Record<string, any>, attr?: Record<string, any>): Record<string, any>;
    /**
     * 转换Ceium对象为json简单对象，用于导出Cesium的样式对象到json可以保存的格式
     * @param czmVal - Cesium属性值
     * @param style - json简单对象
     * @returns json简单对象
     */
    static toJSON(czmVal: Record<string, any>, style?: Record<string, any>): Record<string, any>;
    protected _toCesiumValBefore(style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toCesiumValEnd(style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _getExcludedStyle(): string[];
    protected _toOneCesiumVal(key: string, value: any, style: Record<string, any>, czmVal: Record<string, any>): void;
    protected _toOneJson(key: string, value: any, style: Record<string, any>): void;
}

/**
 * 表示经纬度点数组的工具类
 */
declare class LatLngArray {
    /**
     * 将经纬度点数组转换为笛卡尔坐标数组。
     * @param value 要转换的值，可以是包含经纬度点或笛卡尔坐标的数组。
     * @param clone 是否克隆笛卡尔坐标。
     * @returns 转换后的笛卡尔坐标数组。
     * @group 静态方法
     */
    static toCartesians(value: ParserLatLngPointInput[], clone?: boolean): Cesium.Cartesian3[] | any[];
    /**
     * 将数组中的点转换为经纬度点对象。
     * @param value 要转换的值，可以是包含经纬度点或数组的数组。
     * @returns 转换后的经纬度点对象数组。
     * @group 静态方法
     */
    static toPoints(value: any[]): LatLngPoint[] | any[];
    /**
     * 将经纬度点或数组转换为数组形式。
     * @param value 要转换的值，可以是包含经纬度点或数组的数组。
     * @param noAlt 是否不包含高度信息。
     * @returns 转换后的数组形式。
     * @group 静态方法
     */
    static toArray(value: any[], noAlt?: boolean): number[][] | any[];
}

/**
 * 表示经纬度点的工具类
 */
declare class LatLngPoint {
    private _lng;
    private _lat;
    private _alt;
    /**
     * 经纬度的格式化小数位长度
     */
    static FormatLength: number;
    /**
     * 高度的格式化小数位长度
     */
    static FormatAltLength: number;
    /**
     * 将ParserLatLngPointInput定义的数据类型的position转换为LatLngPoint标准对象
     * @param input
     * @param time
     * @returns 返回一个LatLngPoint对象
     * @group 静态方法
     */
    static parse(input: ParserLatLngPointInput, time?: Cesium.JulianDate): LatLngPoint;
    /**
     * 将Array数据类型的position转换为LatLngPoint标准对象
     * @param array
     * @returns 返回一个LatLngPoint对象
     * @group 静态方法
     */
    static fromArray(array: number[]): LatLngPoint;
    /**
     * 将string数据类型的position转换为LatLngPoint标准对象
     * @param input
     * @returns 返回一个LatLngPoint对象
     * @group 静态方法
     */
    static fromString(input: string): LatLngPoint;
    /**
     * 将Cartesian3数据类型的position转换为LatLngPoint标准对象
     * @param cartesian
     * @returns 返回一个LatLngPoint对象
     * @group 静态方法
     */
    static fromCartesian(cartesian: Cesium.Cartesian3 | {
        _value?: Cesium.Cartesian3;
        getValue?: (...args: any[]) => Cesium.Cartesian3;
    } | (Cesium.SampledPositionProperty & {
        _value?: Cesium.Cartesian3;
    }), time?: Cesium.JulianDate): LatLngPoint;
    /**
     * 将Cartographic数据类型的position转换为LatLngPoint标准对象
     * @param cartographic
     * @returns 返回一个LatLngPoint对象
     * @group 静态方法
     */
    static fromCartographic(cartographic: Cesium.Cartographic): LatLngPoint;
    /**
     * 将LatLngPoint标准对象转换为Cesium.Cartesian3笛卡尔坐标
     * @param input
     * @param time
     * @returns 返回Cesium.Cartesian3笛卡尔坐标
     * @group 静态方法
     */
    static toCartesian(input: ParserLatLngPointInput, time?: Cesium.JulianDate): Cesium.Cartesian3;
    /**
     * 将LatLngPoint标准对象转换为Cesium内部标准的Cartographic坐标类
     * @param input
     * @param time
     * @returns 返回Cesium.Cartographic对象
     * @group 静态方法
     */
    static toCartographic(input: ParserLatLngPointInput, time?: Cesium.JulianDate): Cesium.Cartographic;
    constructor(lng?: number, lat?: number, alt?: number);
    get lng(): number;
    set lng(value: number);
    setLng(value: number): void;
    get lat(): number;
    set lat(value: number);
    setLat(value: number): void;
    get alt(): number;
    set alt(value: number);
    setAlt(value: number): void;
    clone(): LatLngPoint;
    format(): this;
    toArray(includeAlt?: boolean): [number, number] | [number, number, number];
    toString(): string;
    toCartesian(): Cesium.Cartesian3;
    toCartographic(): Cesium.Cartographic;
    equals(other: LatLngPoint): boolean;
    valid(): boolean;
}

declare namespace layer {
    export {
        createLayer,
        converTileLayerOptions,
        CreateLayerOptions,
        ClusteringOptions,
        CloudOptions
    }
}

declare namespace layers {
    export {
        BaseLayerClickEventFn,
        BaseLayerOptions,
        BaseLayer,
        BaseTileLayerOptions,
        BaseTileLayer,
        BaseGraphicLayerOptions,
        BaseGraphicLayer,
        GeojsonLayerLoadOptions,
        GeojsonLayerOptions,
        GeojsonLayer,
        GroupLayerOptions,
        GroupLayer,
        ImageLayerOptions,
        ImageLayer,
        TerrainLayerOptions,
        TerrainLayer,
        TilesetLayerOptions,
        TilesetLayerOptimizeOptions,
        TilesetLayer,
        WmsLayerOptions,
        WmsLayer,
        WmtsLayerOptions,
        WmtsLayer,
        XyzLayerOptions,
        XyzLayer,
        GraphicLayerOptions,
        GraphicLayer,
        ColorRamp,
        ColorPatternGridLayerOptions,
        ColorPatternGridLayer,
        ColorPatternGradientLayerUniformOptions,
        ColorPatternGradientLayerOptions,
        ColorPatternGradientLayer,
        HeatPoint,
        HeatStyleOptions,
        HeatLayerOptions,
        HeatLayer
    }
}
export { layers }

/**
 * 图层类型
 * @enum
 */
declare const LayerType: {
    /** terrain地形图层 */
    terrain: typeof TerrainLayer;
    /** wms服务图层 */
    wms: typeof WmsLayer;
    /** wmts服务图层 */
    wmts: typeof WmtsLayer;
    /** 单张image图片图层 */
    image: typeof ImageLayer;
    /** xyz标准金字塔瓦片服务图层 */
    xyz: typeof XyzLayer;
    /** tileset三维模型图层 */
    tileset: typeof TilesetLayer;
    /** geojson矢量图层 */
    geojson: typeof GeojsonLayer;
    /** group图层组类 */
    group: typeof GroupLayer;
    /** colorPatternGrid色斑网格图层类 */
    colorPatternGrid: typeof ColorPatternGridLayer;
    /** colorPatternGradient色斑晕染图层类 */
    colorPatternGradient: typeof ColorPatternGradientLayer;
    /** heat热力图层类 */
    heat: typeof HeatLayer;
    /** graphic矢量图层类 */
    graphic: typeof GraphicLayer;
};

/**
 * 图层类型key联合类型
 */
declare type LayerTypeKey = keyof typeof LayerType;

/**
 * 图层类型value联合类型
 */
declare type LayerTypeValue = (typeof LayerType)[keyof typeof LayerType];

/**
 * 地图生命周期枚举
 * @enum
 */
declare const LifeCycleState: {
    /**
     * 初始化
     */
    readonly INITED: "inited";
    /**
     * 已添加到地球上
     */
    readonly ADDED: "added";
    /**
     * 已移除地图
     */
    readonly REMOVED: "removed";
    /**
     * 已销毁对象
     */
    readonly DESTROYED: "destroyed";
};

/**
 * 地图生命周期key联合类型
 */
declare type LifeCycleStateKey = keyof typeof LifeCycleState;

/**
 * 地图生命周期value联合类型
 */
declare type LifeCycleStateValue = (typeof LifeCycleState)[keyof typeof LifeCycleState];

/**
 * 闪电特效类
 */
declare class LightningEffect extends BaseEffect {
    protected _type: EffectTypeKey;
    protected _postProcessStage?: Cesium.PostProcessStage;
    /**
     * 闪电特效类构造参数
     */
    options: LightningEffectOptions;
    constructor(options?: LightningEffectOptions);
    /**
     * 下降间隔
     */
    get fallGap(): any;
    /**
     * 设置下降间隔
     */
    set fallGap(value: any);
    /**
     * 混合系数
     */
    get mixFactor(): any;
    /**
     * 设置混合系数
     */
    set mixFactor(value: any);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _enableHooks(val: boolean): void;
}

/**
 * 闪电特效类构造参数类型
 */
declare interface LightningEffectOptions extends BaseEffectOptions {
    /**
     * 闪电坠落间隔，取值范围为0~1，默认值为`1.0`，值越大频率越高
     */
    fallGap?: number;
    /**
     * 特效与cesium三维场景的混合系数，取值范围为0~1，默认值为`0.3`，值越大，闪电特效越强烈
     */
    mixFactor?: number;
}

/**
 * 线状: 闪烁线材质
 */
declare class LineFlickerMaterialProperty extends BaseMaterialProperty {
    constructor(options?: LineFlickerMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "LineFlicker";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 线状: 闪烁线材质构造器类型
 */
declare interface LineFlickerMaterialPropertyOptions {
    /**
     * 闪烁线的颜色
     * 默认为红色`new Cesium.Color(1.0, 0, 0, 1.0)`
     */
    color?: Cesium.Color;
    /**
     * 闪烁的速度
     * 值越大，闪烁得越快
     * 默认为`2`
     */
    speed?: number;
}

/**
 * 线状: 流动效果材质
 */
declare class LineFlowColorMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _percent: any;
    /**
     */
    protected _alpha: any;
    /**
     */
    protected _startTime: any;
    constructor(options?: LineFlowColorMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "LineFlowColor";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 线状: 流动效果材质构造器类型
 */
declare interface LineFlowColorMaterialPropertyOptions {
    /**
     * 流动效果的颜色。
     * 默认为红色（`new Cesium.Color(1, 0, 0, 1.0)`）。
     */
    color?: Cesium.Color;
    /**
     * 流动效果的速度。
     * 值越大，流动得越快。
     * 默认为`2`。
     */
    speed?: number;
    /**
     * 流动效果中颜色变化的比例或范围。
     * 具体含义可能取决于实现方式，但通常用于控制流动的视觉强度或变化量。
     * 默认为`0.04`。
     */
    percent?: number;
    /**
     * 流动效果的透明程度。
     * 范围从`0.0`（完全透明）到`1.0`（完全不透明）。
     * 默认为`0.1`。
     */
    alpha?: number;
    /**
     * 流动效果开始的时间系数。
     * 这个参数可能用于控制动画的开始点或同步多个动画。
     * 默认为`0`，表示立即开始。
     */
    startTime?: number;
}

/**
 * 线状: 流动效果材质
 */
declare class LineFlowMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _image: string;
    /**
     */
    protected _axisY: any;
    /**
     */
    protected _duration: number | undefined;
    /**
     */
    protected _repeat: any;
    /**
     */
    protected _image2: any;
    /**
     */
    protected _color2: Cesium.Color;
    /**
     */
    protected _hasImage2: boolean;
    /**
     */
    protected _time?: number;
    constructor(options: LineFlowMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "LineFlow";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 线状: 流动效果材质构造器类型
 */
declare interface LineFlowMaterialPropertyOptions {
    /**
     * 背景图片URL。
     */
    image: string;
    /**
     * 背景图片的颜色。
     * 默认为红色（`new Cesium.Color(1, 0, 0, 1.0)`）。
     */
    color?: Cesium.Color | string;
    /**
     * 图片在横纵方向上的重复次数。
     * 默认为`new Cesium.Cartesian2(1.0, 1.0)`，即不重复。
     */
    repeat?: Cesium.Cartesian2;
    /**
     * 是否将Y轴视为朝上。
     * 默认为`false`。
     */
    axisY?: boolean;
    /**
     * 流动效果的速度。
     * 建议取值范围1-100，默认为`10`。
     */
    speed?: number;
    /**
     * 播放总时长，单位：秒。
     * 如果提供此参数，它将覆盖`speed`参数。
     */
    duration?: number;
    /**
     * 是否有2张图片的混合模式。
     * 默认为`false`。
     */
    hasImage2?: boolean;
    /**
     * 第2张背景图片的URL地址。
     * 仅在`hasImage2`为`true`时有效。
     */
    image2?: string;
    /**
     * 第2张背景图片的颜色。
     * 默认为白色（`new Cesium.Color(1, 1, 1, 1.0)`，但此处去除了透明度以匹配常见用法）。
     * 注意：如果`color2`是一个字符串，则需要额外的逻辑来解析它。
     */
    color2?: Cesium.Color | string;
}

/**
 * 线状: 轨迹线材质
 */
declare class LineTrailMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _bgColor: any;
    constructor(options?: LineTrailMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "LineTrail";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 线状: 轨迹线材质构造器类型
 */
declare interface LineTrailMaterialPropertyOptions {
    /**
     * 线的颜色。
     * 默认为红色（`new Cesium.Color(1, 0, 0, 1.0)`）。
     */
    color?: Cesium.Color;
    /**
     * 线的背景颜色。
     * 可以是Cesium.Color实例或颜色字符串。
     */
    bgColor?: string | Cesium.Color;
    /**
     * 线的流动速度。
     * 值越大越快。
     * 默认为`5.0`。
     */
    speed?: number;
}

/**
 * 集合转成树结构数据
 * @param list - 目标集合
 * @param config - 配置项
 * @returns 树结构数据
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 id: 'id',
 children: 'children',
 pid: 'pid'
 }
 ```
 */
declare function listToTree<T = any>(list: any[], config?: Partial<TreeMappingConfig>): T[];

/**
 * 经纬度坐标 转 Cesium笛卡尔空间xyz坐标
 * @param coord - 经纬度坐标，示例：[123.123456, 32.654321, 198.7]
 * @param defHeight - 默认高度
 * @returns Cesium笛卡尔空间xyz坐标，如果输入无效则返回null
 * @group 功能: 坐标转换相关
 */
declare function lonlat2cartesian(coord: number[], defHeight?: number): Cesium.Cartesian3 | null;

/**
 * 经纬度地理坐标 转 投影平面坐标
 * @param lnglat - 经纬度坐标，示例：[123.123456,32.654321,20.1]
 * @return WebMercator投影平面坐标，示例：[13048882,3741659,20.1]
 * @group 功能: 坐标转换相关
 */
declare function lonlat2mercator(lnglat: number[]): number[];

/**
 * 经纬度坐标数组 转 Cesium笛卡尔空间xyz坐标数组
 * @param coords - 经纬度坐标数组，示例：[ [123.123456,32.654321,198.7], [111.123456,22.654321,50.7] ]
 * @param defHeight - 默认高度
 * @return Cesium笛卡尔空间xyz坐标数组
 * @group 功能: 坐标转换相关
 */
declare function lonlats2cartesians(coords: number[][], defHeight?: number): (Cesium.Cartesian3 | Cesium.Cartesian3[])[];

/**
 * 经纬度地理坐标数组 转 投影平面坐标数组
 * @param arr - 经纬度坐标数组，示例：[ [123.123456,32.654321,20.1], [111.123456,22.654321,21.2] ]
 * @return WebMercator投影平面坐标数组，示例：[[13048882,3741659,20.1],[13048882,3741659,21.2]]
 * @group 功能: 坐标转换相关
 */
declare function lonlats2mercators(arr: number[][]): number[][];

/**
 * 遍历数组或对象（实际上，对于对象，此方法仅调用一次回调函数），并对每个元素（或对象本身）执行回调函数。
 * 如果输入是数组，则收集回调函数的返回值到一个新数组中并返回该数组；如果输入是对象，则直接返回回调函数的返回值（注意：此行为可能需要根据实际需求调整）。
 *
 * @param arrOrObj - 要遍历的数组或对象。
 * @param callback - 对数组的每个元素或对象本身执行的回调函数。对于数组，回调函数接收当前元素作为参数；对于对象，回调函数接收整个对象作为参数。
 * @returns 当输入为数组时，返回一个新数组，包含回调函数对原数组每个元素的返回值；当输入为对象时，直接返回回调函数的返回值（注意：此行为可能需要根据实际需求调整）。
 */
declare function loopArrayCallback<T, R = T>(arrOrObj: T[] | T, callback: (entity: T) => R): R[] | R | undefined;

declare namespace map {
    export {
        setRenderErrorHandler,
        getSurfaceHeight,
        getZoomLevelByAltitude,
        get3DTilesetByPosition,
        getSurface3DTilesHeight,
        getSurfaceTerrainHeight,
        getCanvasCenterCoords,
        getCurrentMousePosition,
        getCanvasXY,
        getRectangle,
        getTransFun,
        getCesiumColor,
        getCesiumValue,
        getAttrVal,
        getColorByStyle,
        getTextImage,
        getPositionValue,
        getPolygonPositions,
        getMaxHeight,
        getCenterFromTwoCart3,
        getCenterFromParserArr,
        getParabolaCurve,
        getBezierCurve,
        formatRectangle,
        parseRectangle,
        addPositionsHeight,
        setPositionsHeight,
        mergeGeojson,
        astarElevationPathfinding,
        degree2dms,
        dms2degree,
        getCGCS2000EPSGByLng,
        getCGCS2000EPSGByX,
        cartesian2lonlat,
        cartesians2lonlats,
        cartesian2mercator,
        cartesians2mercators,
        lonlat2cartesian,
        lonlats2cartesians,
        lonlat2mercator,
        lonlats2mercators,
        mercator2cartesian,
        mercators2cartesians,
        mercator2lonlat,
        mercators2lonlats,
        getMercatorBounds,
        geLatLngBounds,
        bd2gcj,
        gcj2bd,
        wgs2gcj,
        gcj2wgs,
        bd2wgs,
        wgs2bd,
        jwd2mct,
        mct2jwd,
        proj4Trans,
        proj4TransArr,
        ParserRectangleInput,
        RenderErrorHandler,
        TextStyleOptions,
        HeightOptions,
        Token
    }
}

declare namespace material {
    export {
        registerMaterial,
        registerProperty,
        createMaterial,
        createMaterialProperty,
        toJSON
    }
}

declare namespace materials {
    export {
        ColorPatternGradientMaterialOptions,
        HeatMaterialOptions,
        CylinderWaveMaterialOptions,
        CylinderWaveMaterial,
        TextMaterialOptions,
        TextMaterial,
        BaseMaterialProperty,
        CircleScanMaterialPropertyOptions,
        CircleScanMaterialProperty,
        CircleWaveMaterialPropertyOptions,
        CircleWaveMaterialProperty,
        CylinderWaveMaterialPropertyOptions,
        CylinderWaveMaterialProperty,
        EllipsoidElectricMaterialPropertyOptions,
        EllipsoidElectricMaterialProperty,
        EllipsoidWaveMaterialPropertyOptions,
        EllipsoidWaveMaterialProperty,
        Image2MaterialPropertyOptions,
        Image2MaterialProperty,
        LineFlickerMaterialPropertyOptions,
        LineFlickerMaterialProperty,
        LineFlowColorMaterialPropertyOptions,
        LineFlowColorMaterialProperty,
        LineFlowMaterialPropertyOptions,
        LineFlowMaterialProperty,
        LineTrailMaterialPropertyOptions,
        LineTrailMaterialProperty,
        ODLineMaterialPropertyOptions,
        ODLineMaterialProperty,
        PolyAsphaltMaterialPropertyOptions,
        PolyAsphaltMaterialProperty,
        PolyBlobMaterialPropertyOptions,
        PolyBlobMaterialProperty,
        PolyFacetMaterialPropertyOptions,
        PolyFacetMaterialProperty,
        PolyGradientMaterialPropertyOptions,
        PolyGradientMaterialProperty,
        PolyGrassMaterialPropertyOptions,
        PolyGrassMaterialProperty,
        PolyWoodMaterialPropertyOptions,
        PolyWoodMaterialProperty,
        RadarLineMaterialPropertyOptions,
        RadarLineMaterialProperty,
        RadarWaveMaterialPropertyOptions,
        RadarWaveMaterialProperty,
        RectSlideMaterialPropertyOptions,
        RectSlideMaterialProperty,
        ScanLineMaterialPropertyOptions,
        ScanLineMaterialProperty,
        TextMaterialPropertyOptions,
        TextMaterialProperty,
        WallScrollMaterialPropertyOptions,
        WallScrollMaterialProperty,
        WaterMaterialPropertyOptions,
        WaterMaterialProperty
    }
}
export { materials }

/**
 * 材质类型枚举
 * @enum
 */
declare const MaterialType: {
    /**
     * 纯色颜色材质
     * @see {@link Cesium.ColorMaterialProperty}
     */
    readonly Color: string;
    /**
     * 图片材质
     * @see {@link Cesium.ImageMaterialProperty}
     */
    readonly Image: string;
    /**
     * 网格材质
     * @see {@link Cesium.GridMaterialProperty}
     */
    readonly Grid: string;
    /**
     * 棋盘材质
     * @see {@link Cesium.CheckerboardMaterialProperty}
     */
    readonly Checkerboard: string;
    /**
     * 条纹材质
     * @see {@link Cesium.StripeMaterialProperty}
     */
    readonly Stripe: string;
    /**
     * 通用：图片材质2 (没有加载完成前的白色闪烁，但也不支持纯白色的图片)
     * @see {@link Image2MaterialProperty}
     */
    readonly Image2: "Image2";
    /**
     * 水面材质
     * @see {@link WaterMaterialProperty}
     */
    readonly Water: string;
    /**
     * 线：虚线材质
     * @see {@link Cesium.PolylineDashMaterialProperty}
     */
    readonly PolylineDash: string;
    /**
     * 线：衬色线材质
     * @see {@link Cesium.PolylineOutlineMaterialProperty}
     */
    readonly PolylineOutline: string;
    /**
     * 线：箭头材质
     * @see {@link Cesium.PolylineArrowMaterialProperty}
     */
    readonly PolylineArrow: string;
    /**
     * 线：高亮线材质
     * @see {@link Cesium.PolylineGlowMaterialProperty}
     */
    readonly PolylineGlow: string;
    /**
     * 线: 流动图片效果材质（适用于线和墙）
     * @see {@link LineFlowMaterialProperty}
     */
    readonly LineFlow: "LineFlow";
    /**
     * 线: 流动颜色效果材质
     * @see {@link LineFlowColorMaterialProperty}
     */
    readonly LineFlowColor: "LineFlowColor";
    /**
     * 线: OD线效果材质
     * @see {@link ODLineMaterialProperty}
     */
    readonly ODLine: "ODLine";
    /**
     * 线: 闪烁线材质
     * @see {@link LineFlickerMaterialProperty}
     */
    readonly LineFlicker: "LineFlicker";
    /**
     * 线状: 轨迹线材质
     * @see {@link LineTrailMaterialProperty}
     */
    readonly LineTrail: "LineTrail";
    /**
     * 墙体:  走马灯围墙材质
     * @see {@link WallScrollMaterialProperty}
     */
    readonly WallScroll: "WallScroll";
    /**
     * 面状: 用于面状对象的扫描线放大效果材质
     * @see {@link ScanLineMaterialProperty}
     */
    readonly ScanLine: "ScanLine";
    /**
     * 圆形: 扫描效果材质
     * @see {@link CircleScanMaterialProperty}
     */
    readonly CircleScan: "CircleScan";
    /**
     * 圆形: 扩散波纹效果材质
     * @see {@link CircleWaveMaterialProperty}
     */
    readonly CircleWave: "CircleWave";
    /**
     * 圆形: 雷达线(圆+旋转半径线) 材质
     * @see {@link RadarLineMaterialProperty}
     */
    readonly RadarLine: "RadarLine";
    /**
     * 圆形: 波纹雷达扫描效果材质
     * @see {@link RadarWaveMaterialProperty}
     */
    readonly RadarWave: "RadarWave";
    /**
     * 面状: 文字贴图材质
     * @see {@link TextMaterialProperty}
     * @see {@link TextMaterial}
     */
    readonly Text: "Text";
    /**
     * 面状: 轮播图材质
     * @see {@link RectSlideMaterialProperty}
     */
    readonly RectSlide: "RectSlide";
    /**
     * 面状：渐变面材质
     * @see {@link PolyGradientMaterialProperty}
     */
    readonly PolyGradient: "PolyGradient";
    /**
     * 面状：柏油路面效果材质
     * @see {@link PolyAsphaltMaterialProperty}
     */
    readonly PolyAsphalt: "PolyAsphalt";
    /**
     * 面状：混合效果材质
     * @see {@link PolyBlobMaterialProperty}
     */
    readonly PolyBlob: "PolyBlob";
    /**
     * 面状：碎石面效果材质
     * @see {@link PolyFacetMaterialProperty}
     */
    readonly PolyFacet: "PolyFacet";
    /**
     * 面状：草地面效果材质
     * @see {@link PolyGrassMaterialProperty}
     */
    readonly PolyGrass: "PolyGrass";
    /**
     * 面状：木材面效果材质
     * @see {@link PolyWoodMaterialProperty}
     */
    readonly PolyWood: "PolyWood";
    /**
     * 球体: 电弧球体效果材质
     * @see {@link EllipsoidElectricMaterialProperty}
     */
    readonly EllipsoidElectric: "EllipsoidElectric";
    /**
     * 球体: 波纹球体效果材质
     * @see {@link EllipsoidWaveMaterialProperty}
     */
    readonly EllipsoidWave: "EllipsoidWave";
    /**
     * 圆锥: 条纹波纹扩散材质
     * @see {@link CylinderWaveMaterialProperty}
     * @see {@link CylinderWaveMaterial}
     */
    readonly CylinderWave: "CylinderWave";
    /**
     * 图片: 色斑晕染图片材质
     * @see {@link ColorPatternGradientMaterialOptions}
     */
    readonly ColorPatternGradient: "ColorPatternGradient";
    /**
     * 图片: 平面热力图片材质
     * @see {@link HeatMaterialOptions}
     */
    readonly Heat: "Heat";
};

/**
 * 材质类型key联合类型
 */
declare type MaterialTypeKey = keyof typeof MaterialType;

/**
 * 材质类型value联合类型
 */
declare type MaterialTypeValue = (typeof MaterialType)[keyof typeof MaterialType];

/**
 * 投影平面坐标 转 经纬度地理坐标
 * @param arrdata - WebMercator投影平面坐标数组，示例：[13048882.06,3741659.72]
 * @returns 经纬度坐标数组，示例：[117.220101,31.834907]
 * @group 功能: 坐标转换相关
 */
declare function mct2jwd(arrdata: number[]): number[];

/**
 * 投影平面坐标 转 Cesium笛卡尔空间xyz坐标
 * @param point - WebMercator投影平面坐标，示例：[13048882,3741659,20.1]
 * @param height - 赋值高度，可选
 * @return Cesium笛卡尔空间xyz坐标，如果输入坐标无效则返回null
 * @group 功能: 坐标转换相关
 */
declare function mercator2cartesian(point: number[], height?: number): Cesium.Cartesian3 | null;

/**
 * 投影平面坐标 转 经纬度地理坐标
 * @param point - WebMercator投影平面坐标，示例：[13048882,3741659,20.1]
 * @return 经纬度坐标，示例：[123.123456,32.654321,20.1]
 * @group 功能: 坐标转换相关
 */
declare function mercator2lonlat(point: number[]): number[];

/**
 * 投影平面坐标数组 转 Cesium笛卡尔空间xyz坐标数组
 * @param arr - WebMercator投影平面坐标数组，示例：[[13048882,3741659,20.1],[13048882,3741659,21.2]]
 * @param height - 赋值高度，可选
 * @return Cesium笛卡尔空间xyz坐标数组
 * @group 功能: 坐标转换相关
 */
declare function mercators2cartesians(arr: number[][], height?: number): Cesium.Cartesian3[];

/**
 * 投影平面坐标数组 转 经纬度地理坐标数组
 * @param arr - WebMercator投影平面坐标数组，示例：[[13048882,3741659,20.1],[13048882,3741659,21.2]]
 * @return 经纬度坐标数组，示例：[ [123.123456,32.654321,20.1], [111.123456,22.654321,21.2] ]
 * @group 功能: 坐标转换相关
 */
declare function mercators2lonlats(arr: number[][]): number[][];

/**
 * 将一系列GeoJSON对象合并为一个包含所有文件中所有要素的FeatureCollection。
 * 这些对象可以是任何有效的GeoJSON根对象，包括FeatureCollection、Feature和Geometry类型。
 * @param inputs a list of GeoJSON objects of any type
 * @returns a geojson FeatureCollection.
 * @example
 * ```ts
 * const mergedGeoJSON = merge([
 *   { type: 'Point', coordinates: [0, 1] },
 *   { type: 'Feature', geometry: { type: 'Point', coordinates: [0, 1] }, properties: {} }
 * ])
 * console.log(JSON.stringify(mergedGeoJSON))
 * ```
 */
declare function mergeGeojson(inputs: Array<AllGeoJSON>): turf.helpers.FeatureCollection<turf.helpers.Geometry | turf.helpers.GeometryCollection, turf.helpers.Properties>;

/**
 * 合并两张图片
 * @group 功能: image操作相关
 */
declare function mergeImage(base64First: string, base64Next: string, width: number, height: number): Promise<string>;

/* Excluded from this release type: MouseEvent_2 */

/** 鼠标拾取配置 */
export declare interface MouseMoveEventOptions {
    /** 是否禁用鼠标事件的拾取矢量数据，默认值为`false` */
    disableMouseEvent?: boolean;
    /** 鼠标移动事件的延迟毫秒数，默认值为`30` */
    moveDelay?: number;
    /** 拾取时所选矩形的宽度，默认值为`4`，单位：像素 */
    pickWidth?: number;
    /** 拾取时所选矩形的高度，默认值为`4`，单位：像素 */
    pickHeight?: number;
    /** 在允许allowDrillPick穿透拾取时，限制拾取的对象个数，默认值为`9` */
    pickLimit?: number;
}

/** 鼠标移动提示框类，一般用于鼠标操作的文字提示 */
declare class MouseTooltip extends Popup {
    /**
     * 屏幕空间事件处理器实例
     */
    protected _handler?: Cesium.ScreenSpaceEventHandler;
    /**
     鼠标移动提示框类构造参数类型
     */
    options: MouseTooltipOptions;
    /**
     * 是否启用鼠标移动监听
     */
    enable: boolean;
    /**
     * @param viewer - Cesium.Viewer实例
     * @param options - 鼠标移动提示框类构造参数
     */
    constructor(viewer: Cesium.Viewer, options?: MouseTooltipOptions);
    protected _render(): boolean;
    protected _initContainer(): void;
    /**
     * 打开popup
     * @param info - 信息数据
     * @param position - 弹出位置(地理空间坐标)，如果不传值，默认为曾经打开过的上次打开位置或Cesium.Cartesian3.ZERO零点
     */
    open(info?: Record<string, any> | string, position?: Cesium.Cartesian3 | Cesium.Cartesian2): void;
    /**
     * 关闭popup
     */
    close(): void;
    show(): void;
    hide(): void;
    /**
     * 销毁释放对象
     */
    destroy(): void;
}

/** 鼠标移动提示框类构造参数类型 */
declare interface MouseTooltipOptions extends Omit<PopupOptions, 'contentType' | 'htmlTemplate' | 'componentElement' | 'entity'> {
    /**
     * 是否启用鼠标移动监听，默认为`false`
     */
    enable?: boolean;
    /**
     * 方向，默认为'right'，代表右边
     */
    direction?: 'right' | 'left' | 'bottom' | 'top';
}

/**
 * 相机旋转方向枚举
 * @enum
 */
declare const MoveType: {
    /**
     * 向屏幕中心靠近
     */
    readonly ENLARGE: 0;
    /**
     * 向屏幕中心远离
     */
    readonly NARROW: 1;
    /**
     * 相机原地左旋转
     */
    readonly LEFT_ROTATE: 2;
    /**
     * 相机原地右旋转
     */
    readonly RIGHT_ROTATE: 3;
    /**
     * 相机原地上旋转
     */
    readonly TOP_ROTATE: 4;
    /**
     * 相机原地下旋转
     */
    readonly BOTTOM_ROTATE: 5;
};

/**
 * 相机旋转方向key联合类型
 */
declare type MoveTypeKey = keyof typeof MoveType;

/**
 * 相机旋转方向value联合类型
 */
declare type MoveTypeValue = (typeof MoveType)[keyof typeof MoveType];

/**
 * 线状: OD线效果材质
 */
declare class ODLineMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _bgColor: Cesium.Color;
    /**
     */
    protected _startTime: any;
    /**
     */
    protected _bidirectional: any;
    constructor(options?: ODLineMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "ODLine";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 线状: OD线效果材质构造器类型
 */
declare interface ODLineMaterialPropertyOptions {
    /**
     * 运动对象的颜色。
     * 可以是Cesium.Color实例或颜色字符串。
     * 默认为随机色（在实际应用中应在实例化时设置）。
     */
    color?: string | Cesium.Color;
    /**
     * 线的背景颜色。
     * 可以是Cesium.Color实例或颜色字符串。
     */
    bgColor?: string | Cesium.Color;
    /**
     * 速度。
     * 默认为`20 + 10 * Math.random()`（在实际应用中应在实例化时设置）。
     */
    speed?: number;
    /**
     * 开始的时间系数。
     * 默认为`Math.random()`（在实际应用中应在实例化时设置）。
     */
    startTime?: number;
    /**
     * 运行形式：
     * 0 - 正向运动
     * 1 - 反向运动
     * 2 - 双向运动
     * 默认为0。
     */
    bidirectional?: number;
}

/** 方向俯仰翻滚角 */
declare interface Orientation {
    /** 方向角度值，绕垂直于地心的轴旋转角度, 0 至 360 */
    heading: number;
    /** 俯仰角度值，绕纬度线旋转角度,-90 至 90 */
    pitch: number;
    /** 翻滚角度值，绕经度线旋转角度, -90 至 90 */
    roll: number;
}

/**
 * 将HTML字符串解析为DOM
 * @param domStr - HTML字符串
 * @param withWrapper - 是否返回DIV父节点，默认为false
 * @param className - 指定加上的样式名称
 * @returns 如果withWrapper为true，则返回HTMLDivElement；否则返回`NodeListOf<ChildNode>`
 * @group 功能: Dom操作相关
 */
declare function parseDom(domStr: string, withWrapper?: boolean, className?: string): HTMLDivElement | NodeListOf<ChildNode>;

/**
 * 将输入格式转换为Cesium.Rectangle格式
 * @param rect - 输入格式可以是字符串、数组、`{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`对象格式、或Cesium.Rectangle对象
 * @returns 返回Cesium.Rectangle格式对象
 */
declare function parseRectangle(rect?: ParserRectangleInput): Cesium.Rectangle | undefined;

/**
 * 解析器：可将如下类型转换为LatLngPoint对象
 * @example
 * ```ts
 * input = '120,30,0'
 * input = [120, 30, 0]
 * input = new LatLngPoint(120, 30, 0)
 * input = Cesium.Cartesian3.fromDegrees(120, 30, 0)
 * input = Cesium.Cartographic.fromDegrees(120, 30, 0)
 * input = { lng: 120, lat: 30, alt: 0 }
 * input = { x: 120, y: 30, z: 0 }
 * input = {..., _value: Cesium.Cartesian3.fromDegrees(120, 30, 0) }
 * input = {..., getValue: () => { return Cesium.Cartesian3.fromDegrees(120, 30, 0)} }
 * ```
 */
declare type ParserLatLngPointInput = string | number[] | LatLngPoint | Cesium.Cartesian3 | Cesium.Cartographic | {
    _value?: Cesium.Cartesian3;
    getValue?: (...args: any[]) => Cesium.Cartesian3;
} | {
    lat: number;
    lng: number;
    alt?: number;
} | {
    x: number;
    y: number;
    z?: number;
};

/**
 * 将输入格式转换为Cesium.Rectangle格式
 * 输入格式可以是英文逗号隔开的字符串: `xxx,xxx,xxx,xxx`、数组: `[xxx, xxx, xxx, xxx]`、对象: `{ xmin: xxx, xmax: xxx, ymin: xxx, ymax: xxx }`、或`Cesium.Rectangle`对象
 * 不管输入格式如何，都应遵循xmin,ymin,xmax,ymax的顺序
 */
declare type ParserRectangleInput = Extent | number[] | string | Cesium.Rectangle;

/**
 * 拾取对象类型
 */
export declare interface PickTargetInfo {
    /**
     * 返回一个具有primitive属性的对象
     * 该对象是含场景中特定窗口坐标下的第一个（最顶层）原始对象
     * 如果指定位置没有任何对象，则返回 `undefined`
     * 当选中3D Tiles图块集的某个特征时，选择操作会返回一个`Cesium3DTileFeature`对象。
     */
    scenePicked: any;
    /**
     * Cesium本身的Entity或Primitive对象
     */
    sourceTarget: any;
    /**
     * 拾取的3DTiles瓦片特征
     */
    picked3DTileFeature?: {
        attr: Record<string, any>;
        feature: Cesium.Cesium3DTileFeature;
    };
    /**
     * 点击拾取的瓦片图层要素
     */
    pickedImageryLayerFeatureInfo?: Cesium.ImageryLayerFeatureInfo;
    /**
     * 点击命中的所有的瓦片图层要素，`pickedImageryLayerFeatureInfo`为`pickedImageryLayerFeatureInfo[0]`
     */
    pickedImageryLayerFeatureInfos?: Cesium.ImageryLayerFeatureInfo[];
    /**
     * 拾取对象所属图层
     */
    layer: any;
    /**
     * 笛卡尔空间坐标
     */
    cartesian: Cesium.Cartesian3;
    /**
     * 屏幕坐标
     */
    windowPosition: Cesium.Cartesian2;
    /**
     * 屏幕坐标
     */
    position?: Cesium.Cartesian2;
    /**
     * 鼠标移动或拖动时结束的屏幕坐标
     */
    endPosition?: Cesium.Cartesian2;
    /**
     * 鼠标移动或拖动时开始的屏幕坐标
     */
    startPosition?: Cesium.Cartesian2;
}

/**
 * 面状：柏油路面效果材质
 */
declare class PolyAsphaltMaterialProperty extends BaseMaterialProperty {
    protected _bumpSize: number;
    protected _roughness: number;
    constructor(options?: PolyAsphaltMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "PolyAsphalt";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状：柏油路面效果材质构造器类型
 */
declare interface PolyAsphaltMaterialPropertyOptions {
    /**
     * 颜色，默认为`Cesium.Color.ORANGE`
     * 可以是字符串或Cesium.Color实例
     */
    asphaltColor?: string | Cesium.Color;
    /**
     * 块大小，默认为0.02
     */
    bumpSize?: number;
    /**
     * 粗糙度，默认为0.2
     */
    roughness?: number;
}

/**
 * 面状：混合材质
 */
declare class PolyBlobMaterialProperty extends BaseMaterialProperty {
    protected _lightColor: Cesium.Color;
    protected _darkColor: Cesium.Color;
    protected _frequency: number;
    constructor(options?: PolyBlobMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "PolyBlob";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状：混合材质构造器类型
 */
declare interface PolyBlobMaterialPropertyOptions {
    /**
     * 浅色颜色，默认为`new Cesium.Color(1.0, 1.0, 1.0, 0.5)`
     * 可以是字符串或Cesium.Color实例
     */
    lightColor?: string | Cesium.Color;
    /**
     * 深色颜色，默认为`new Cesium.Color(0.0, 0.0, 1.0, 0.5)`
     * 可以是字符串或Cesium.Color实例
     */
    darkColor?: string | Cesium.Color;
    /**
     * 频率，默认为10.0
     */
    frequency?: number;
}

/**
 * 面状：碎石面材质
 */
declare class PolyFacetMaterialProperty extends BaseMaterialProperty {
    protected _lightColor: Cesium.Color;
    protected _darkColor: Cesium.Color;
    protected _frequency: number;
    constructor(options?: PolyFacetMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "PolyFacet";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状：碎石面材质构造器类型
 */
declare interface PolyFacetMaterialPropertyOptions {
    /**
     * 浅色颜色，默认为`new Cesium.Color(0.25, 0.25, 0.25, 0.75)`
     * 可以是字符串或Cesium.Color实例
     */
    lightColor?: string | Cesium.Color;
    /**
     * 深色颜色，默认为`new Cesium.Color(0.25, 0.25, 0.25, 0.75)`
     * 可以是字符串或Cesium.Color实例
     */
    darkColor?: string | Cesium.Color;
    /**
     * 频率，默认为10.0
     */
    frequency?: number;
}

/**
 * 面状：渐变面材质
 */
declare class PolyGradientMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _diffusePower: any;
    constructor(options?: PolyGradientMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "PolyGradient";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状：渐变面材质构造器类型
 */
declare interface PolyGradientMaterialPropertyOptions {
    /**
     * 颜色，默认为半透明的黄色（Cesium.Color(1.0, 1.0, 0.0, 0.5)）
     * 可以是字符串或Cesium.Color实例
     */
    color?: string | Cesium.Color;
    /**
     * 透明度系数，默认为1.5
     */
    alphaPower?: number;
    /**
     * 漫射系数，默认为1.6
     */
    diffusePower?: number;
}

/**
 * 面状：草地面材质
 */
declare class PolyGrassMaterialProperty extends BaseMaterialProperty {
    protected _grassColor: Cesium.Color;
    protected _dirtColor: Cesium.Color;
    protected _frequency: number;
    constructor(options?: PolyGrassMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "PolyGrass";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状：草地面材质构造器类型
 */
declare interface PolyGrassMaterialPropertyOptions {
    /**
     * 草地颜色，默认为`new Cesium.Color(0.25, 0.4, 0.1, 1.0)`
     * 可以是字符串或Cesium.Color实例
     */
    grassColor?: string | Cesium.Color;
    /**
     * 泥土颜色，默认为`new Cesium.Color(0.1, 0.1, 0.1, 1.0)`
     * 可以是字符串或Cesium.Color实例
     */
    dirtColor?: string | Cesium.Color;
    /**
     * 频率，默认为1.5
     */
    frequency?: number;
}

/**
 * Polyline矢量数据style转换处理类
 */
declare class PolylineStyleConver extends BaseStyleConver {
    /**
     * 转换style到Cesium对象需要的格式
     * @param style - 样式配置
     * @param czmVal - Cesium属性值
     * @param isEntity - 是否为Entity对象
     * @returns Cesium属性值
     */
    static toCesiumVal(style: Record<string, any>, czmVal?: Record<string, any>, isEntity?: boolean): any;
    /**
     * 转换Ceium对象为json简单对象，用于导出Cesium的样式对象到json可以保存的格式
     * @param czmVal - Cesium属性值
     * @param style - json简单对象
     * @param isEntity - 是否为entity
     * @returns json简单对象
     */
    static toJSON(czmVal: Record<string, any>, style?: Record<string, any>, isEntity?: boolean): any;
    _toCesiumValBefore(style: Record<string, any>, czmVal: Record<string, any>): void;
    _toOneCesiumVal(key: string, value: any, style: Record<string, any>, czmVal: Record<string, any>): void;
    _toOneJson(key: string, value: any, style: Record<string, any>): void;
}

/**
 * 面状：木材面效果材质
 */
declare class PolyWoodMaterialProperty extends BaseMaterialProperty {
    protected _lightWoodColor: Cesium.Color;
    protected _darkWoodColor: Cesium.Color;
    protected _frequency: number;
    protected _noiseScale: number;
    protected _grainFrequency: number;
    constructor(options?: PolyWoodMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "PolyWood";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状：木材面效果材质构造器类型
 */
declare interface PolyWoodMaterialPropertyOptions {
    /**
     * 浅色颜色，默认为`new Cesium.Color(1.0, 1.0, 1.0, 0.5)`
     * 可以是字符串或Cesium.Color实例
     */
    lightWoodColor?: string | Cesium.Color;
    /**
     * 深色颜色，默认为`new Cesium.Color(0.0, 0.0, 1.0, 0.5)`
     * 可以是字符串或Cesium.Color实例
     */
    darkWoodColor?: string | Cesium.Color;
    /**
     * 频率，默认为3.0
     */
    frequency?: number;
    /**
     * 噪波比例，默认为`new Cesium.Cartesian2(0.7, 0.5)`
     */
    noiseScale?: Cesium.Cartesian2;
    /**
     * 颗粒频率，默认为27.0
     */
    grainFrequency?: number;
}

/**
 * 弹窗实例类
 */
declare class Popup extends BaseClass {
    /**
     * 支持的事件类型
     */
    static EventType: {
        openPopup: "openPopup";
        closePopup: "closePopup";
        destroyPopup: "destroyPopup";
        changePopupPosition: "changePopupPosition";
        showPopup: "showPopup";
        hidePopup: "hidePopup";
    };
    /**
     * Cesium.Viewer实例
     */
    protected _viewer: Cesium.Viewer;
    /**
     * 唯一id
     */
    protected _id: string;
    /**
     * 当`contentType`为'html'时，popup容器的dom节点
     */
    protected _container?: HTMLDivElement | undefined;
    /**
     * 当`contentType`为'html'时，popup容器中箭头方向的dom节点
     */
    protected _containerArrow?: HTMLDivElement | undefined;
    /**
     * 当`contentType`为'html'时，popup容器中消息内容的dom节点
     */
    protected _containerContent?: HTMLDivElement | undefined;
    /**
     * 当`contentType`为'html'时，popup容器中的关闭按钮
     */
    protected _containerCloseSvg?: SVGSVGElement | undefined;
    /**
     * 当前的窗口的所在位置
     */
    protected _currentWindowPosition?: Cesium.Cartesian2;
    /**
     * 当前所处的地理空间坐标
     */
    protected _currentCartesian?: Cesium.Cartesian3;
    /**
     * 当`contentType`为'html'时，html的模板字符串
     */
    protected _htmlTemplate?: string;
    /**
     * 当`contentType`为'component'时，组件的根dom元素
     */
    protected _componentElement?: HTMLElement;
    /**
     * 视角缓存对象，用于判断视角是否发生改变
     */
    protected _cameraCache?: Record<string, any>;
    /**
     * 方向，默认为'top'，代表上边
     */
    protected _direction: 'right' | 'left' | 'bottom' | 'top';
    /**
     * 内容类型，默认为'html'
     */
    protected _contentType: 'html' | 'component';
    /**
     * 是否通过close 或者 hidePopupElement方法设置了不可见
     */
    protected _hasHide: boolean;
    /**
     * 当没有数据时显示的文字，默认显示"暂无数据"
     */
    emptyText: string;
    /**
     * Cesium图标对象
     */
    _entity?: Cesium.Entity;
    /**
     * Popup构造参数
     */
    options: PopupOptions;
    /**
     * @param viewer - Cesium.Viewer实例
     * @param options -  Popup构造参数构造参数
     */
    constructor(viewer: Cesium.Viewer, options?: PopupOptions);
    /**
     * 对象的id标识
     * @readonly
     */
    get id(): string;
    /**
     * 当`contentType`为'html'时，popup的DOM对象
     * @readonly
     */
    get container(): HTMLDivElement | undefined;
    /**
     *  父容器DOM对象
     * @readonly
     */
    get viewerContainer(): Element;
    /**
     * 箭头方向
     */
    get direction(): "right" | "left" | "bottom" | "top";
    /**
     * 设置箭头方向
     */
    set direction(value: "right" | "left" | "bottom" | "top");
    /**
     * 获取当前所处的屏幕坐标
     */
    get currentWindowPosition(): Cesium.Cartesian2 | undefined;
    /**
     * 设置当前所处的屏幕坐标
     */
    set currentWindowPosition(value: Cesium.Cartesian2 | undefined);
    /**
     * 获取当前所处的地理空间坐标
     */
    get currentCartesian(): Cesium.Cartesian3 | undefined;
    /**
     * 设置当前所处的地理空间坐标
     */
    set currentCartesian(value: Cesium.Cartesian3 | undefined);
    /**
     * 获取popup图标点
     */
    get entity(): Cesium.Entity | Cesium.Entity.ConstructorOptions | boolean | undefined;
    /**
     * 设置popup图标点
     */
    set entity(entity: Cesium.Entity | Cesium.Entity.ConstructorOptions | boolean | undefined);
    /**
     * 初始化div容器
     */
    protected _initContainer(): void;
    /**
     * 绑定场景渲染后立即引发的事件
     */
    protected _bindPostRender(): void;
    /**
     * 解除绑定场景渲染后立即引发的事件
     */
    protected _unbindPostRender(): void;
    /**
     * 当三维场景视角变化时，更新点所对应的屏幕坐标位置
     */
    protected _render(): void;
    /**
     * 判断视角是否没有发生改变
     * @param clientWidth - 窗口宽度
     * @param clientHeight - 窗口高度
     * @returns 视角是否没有发生改变
     */
    protected _isUnchange(clientWidth: number, clientHeight: number): boolean;
    /**
     * 设置窗口位置
     */
    protected _setDivPosition(): void;
    /**
     * 设置图标对象位置
     */
    protected _setEntityPosition(): void;
    /**
     * 隐藏dom元素信息窗，不抛出事件
     */
    protected _hidePopup(): void;
    /**
     * 显示dom元素信息窗，不抛出事件
     */
    protected _showPopup(): void;
    /**
     * 打开popup
     * @param info - 信息数据
     * @param position - 弹出位置(地理空间坐标)，如果不传值，默认为曾经打开过的上次打开位置或Cesium.Cartesian3.ZERO零点
     */
    open(info?: Record<string, any> | string, position?: Cesium.Cartesian3 | Cesium.Cartesian2): void;
    /**
     * 关闭popup
     */
    close(): void;
    /**
     * 显示dom元素信息窗
     */
    show(): void;
    /**
     * 隐藏dom元素信息窗
     */
    hide(): void;
    /**
     * 销毁释放对象
     */
    destroy(): void;
    /**
     * 设置popup图标点
     * Cesium图标标注，可以是Cesium.Entity对象或Cesium.Entity的构造参数对象或布尔类型
     * 设置为Entity对象或构造参数对象，则使用用户自定义Entity
     * 设置为true则使用内置默认的billboard图标标注
     * 不传值或设置为false，则不创建图标标注
     * @param entity - popup图标点
     */
    setEntity(entity?: Cesium.Entity | Cesium.Entity.ConstructorOptions | boolean): void;
    /**
     * 触发指定类型的事件。
     * @param type - 事件类型
     * @param data - 传输的数据或对象，可在事件回调方法中event对象中获取进行使用
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    emit(type: (typeof Popup.EventType)[keyof typeof Popup.EventType], data: PopupEventData): this;
    /**
     * 绑定指定类型事件监听器，支持在监听中调用 event.stopPropagation() 组织事件冒泡
     * @param type - 事件类型
     * @param fn - 绑定的监听器回调方法
     * @param context - 侦听器的上下文(this关键字将指向的对象)。
     * @return 当前对象本身，可以链式调用
     * @group 方法: 事件相关
     */
    on(type: (typeof Popup.EventType)[keyof typeof Popup.EventType], fn: (event: BaseEvent<PopupEventData>) => any, context?: any): this;
    /**
     * 解除绑定指定类型事件监听器
     * @param type - 事件类型,未传值时解绑所有事件
     * @param fn - 绑定的监听器回调方法,未传值时解绑所有指定类型对应事件
     * @param context - 侦听器的上下文(this关键字将指向的对象)。
     * @return 当前对象本身,可以链式调用
     * @group 方法: 事件相关
     */
    off(type: (typeof Popup.EventType)[keyof typeof Popup.EventType], fn: (event: BaseEvent<PopupEventData>) => any, context?: any): this;
}

/**
 * 弹窗类事件数据类型
 */
declare interface PopupEventData {
    /**
     * popup的唯一id，所有事件都有
     */
    id: string;
    /**
     * popup实例，所有事件都有
     */
    popup: Popup;
    /**
     * popup信息，`openPopup`事件独有
     */
    info?: {
        /**
         * popup信息-要展示的数据
         */
        showData: Record<string, any> | string;
        /**
         * popup信息-对应的地理笛卡尔坐标
         */
        cartesian: Cesium.Cartesian3;
        /**
         * popup信息-对应的窗口xy坐标
         */
        windowPosition: Cesium.Cartesian2;
    };
    /**
     * 窗口位置，`changePopupPosition`事件独有
     */
    pos?: {
        /**
         * 方向，默认为'top'，代表上边
         */
        direction?: 'right' | 'left' | 'bottom' | 'top';
        left: string;
        right: string;
        top: string;
        bottom: string;
    };
}

/**
 * 弹窗实例类构造参数类型
 */
declare interface PopupOptions {
    /**
     * id标识，默认为随机uuid
     */
    id?: string;
    /**
     * 方向，默认为'top'，代表上边
     */
    direction?: 'right' | 'left' | 'bottom' | 'top';
    /**
     * 内容类型，默认为'html'
     * 当设置为'html'时，代表采用html模板或html字符串或普通字符串渲染popup窗口，如需使用模板字符串，请同时配置`htmlTemplate`参数
     * 当设置为'component'时，代表采用自定义组件渲染popup窗口，请务必同时配置`componentElement`参数，并在component组件中通过popup实例自行实现显隐控制和数据展示等功能
     */
    contentType?: 'html' | 'component';
    /**
     * 当`contentType`为'html'时，所需的html模板字符串
     * @example
     * 1. 模板示例
     * ```html
     * <div>
     *   <tr>
     *     <td>表头A</td>
     *     <td>表头B</td>
     *     <td>表头D</td>
     *   </tr>
     *   <tr>
     *     <td>内容：{{A}}</td>
     *     <td>内容：{{B}}</td>
     *     <td>内容：{{C.D}}</td>
     *   </tr>
     * </div>
     * ```
     * 2. 数据示例
     * ```ts
     * const data = {
     *   A: '这是A',
     *   B: '这是B',
     *   C: {
     *     D: '这是D'
     *   }
     * }
     * ```
     * 3. 执行：`popup.open(data)`
     * 渲染结果为：
     * ```html
     * <div>
     *   <tr>
     *     <td>表头A</td>
     *     <td>表头B</td>
     *     <td>表头D</td>
     *   </tr>
     *   <tr>
     *     <td>内容：这是A</td>
     *     <td>内容：这是B</td>
     *     <td>内容：这是D</td>
     *   </tr>
     * </div>
     * ```
     */
    htmlTemplate?: string;
    /**
     * 当`contentType`为'component'时，所需的组件的根dom元素
     */
    componentElement?: HTMLElement;
    /**
     * Cesium图标标注，可以是Cesium.Entity对象或Cesium.Entity的构造参数对象或布尔类型
     * 设置为Entity对象或构造参数对象，则使用用户自定义Entity
     * 设置为true则使用内置默认的billboard图标标注
     * 不传值或设置为false，则不创建图标标注
     */
    entity?: Cesium.Entity | Cesium.Entity.ConstructorOptions | boolean;
    /**
     * 当没有数据时显示的文字，默认显示"暂无数据"
     */
    emptyText?: string;
}

/**
 * 使用proj4库进行坐标转换（支持任意坐标系）。
 * 坐标系可以在 {@link http://epsg.io} 进行查询，已内置支持EPSG:4326、EPSG:3857等。
 * @param arrdata - 原始坐标，示例：[39396641, 3882123]
 * @param fromProjParams - 原始坐标的坐标系，如'EPSG:4527'
 * @param toProjParams - 目标坐标系，默认为'EPSG:4326'
 * @returns 转换后的坐标，如果转换失败或无需转换，则返回原始坐标
 * @group 功能: 坐标转换相关
 */
declare function proj4Trans(arrdata: number[], fromProjParams?: string | CRSValue, toProjParams?: string | CRSValue): number[];

/**
 * 使用proj4库转换坐标数组（支持任意坐标系）。
 * 坐标系可以在 {@link http://epsg.io} 进行查询，已内置支持多种EPSG代码。
 * @param coords - 原始坐标数组，每个元素是一个坐标对（如经纬度），或者是一个嵌套的坐标数组。示例：`[[39396641, 3882123], [39396623, 3882134]]` 或 `[[[39396641, 3882123], [39396623, 3882134]], ...]`
 * @param fromProjParams - 原始坐标的坐标系，如'EPSG:4527'
 * @param toProjParams - 目标坐标系，默认为'EPSG:4326'
 * @returns 转换后的坐标数组，每个元素是转换后的坐标对（如经纬度），或者是一个嵌套的坐标数组。示例：`[[115.866936, 35.062583], [115.866923, 35.062565]]` 或 `[[[115.866936, 35.062583], [115.866923, 35.062565]], ...]`
 * @group 功能: 坐标转换相关
 */
declare function proj4TransArr(coords: (number[] | number[][])[], fromProjParams?: string, toProjParams?: string): (number[] | number[][])[];

/**
 * 圆形: 雷达线(圆+旋转半径线) 材质
 */
declare class RadarLineMaterialProperty extends BaseMaterialProperty {
    constructor(options?: RadarLineMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "RadarLine";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 圆形: 雷达线(圆+旋转半径线) 材质构造器类型
 */
declare interface RadarLineMaterialPropertyOptions {
    /**
     * 颜色，默认为红色（Cesium.Color(1, 0, 0, 1.0)）
     */
    color?: Cesium.Color;
    /**
     * 旋转速度，值越大越快，默认为5.0
     */
    speed?: number;
}

/**
 * 圆形: 雷达线(圆+旋转半径线) 材质
 */
declare class RadarWaveMaterialProperty extends BaseMaterialProperty {
    constructor(options?: RadarWaveMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "RadarWave";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 圆形: 雷达线(圆+旋转半径线)材质构造器类型
 */
declare interface RadarWaveMaterialPropertyOptions {
    /**
     * 颜色，默认为红色（Cesium.Color(1, 0, 0, 1.0)）
     * 注意：虽然接口不能直接指定默认值，但这里的注释说明了默认值。
     * 在实际使用时，调用者需要明确提供这个值，或者在使用接口的函数/方法中设置默认值。
     */
    color?: Cesium.Color;
    /**
     * 旋转速度，值越大越快，默认为5.0
     * 同样，这里的注释说明了默认值，但接口本身不存储默认值。
     */
    speed?: number;
}

/**
 * 雨天气特效类
 */
declare class RainEffect extends BaseEffect {
    protected _type: EffectTypeKey;
    protected _postProcessStage?: Cesium.PostProcessStage;
    /**
     * 雨天气特效类构造参数
     */
    options: RainEffectOptions;
    constructor(options?: RainEffectOptions);
    /**
     * 下雨速度
     */
    get speed(): any;
    /**
     * 设置下雨速度
     */
    set speed(value: any);
    /**
     * 雨粒子大小
     */
    get size(): any;
    /**
     * 设置雨粒子大小
     */
    set size(value: any);
    /**
     * 雨的方向（度），0度垂直向下
     */
    get direction(): any;
    /**
     * 设置雨的方向（度），0度垂直向下
     */
    set direction(value: any);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _enableHooks(val: boolean): void;
}

/**
 * 雨天气特效类构造参数类型
 */
declare interface RainEffectOptions extends BaseEffectOptions {
    /**
     * 下雨速度，默认值为`10`
     */
    speed?: number;
    /**
     * 雨粒子大小，默认值为`20`
     */
    size?: number;
    /**
     * 雨的方向（度），0度垂直向下，默认值为`-30`
     */
    direction?: number;
}

/**
 * 面状：轮播图材质
 */
declare class RectSlideMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _image: any;
    /**
     */
    protected _pure: boolean;
    constructor(options: RectSlideMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "RectSlide";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状：轮播图材质构造器类型
 */
declare interface RectSlideMaterialPropertyOptions {
    /**
     * 图片的URL。
     */
    image: string;
    /**
     * 颜色和透明度，默认为Cesium.Color.WHITE。
     */
    color?: Cesium.Color;
    /**
     * 轮播速度，值越大越快，默认为1。
     */
    speed?: number;
    /**
     * 是否为纯色模式，默认为false。
     */
    pure?: boolean;
}

/**
 * 注册自定义的材质类
 * @param type
 * @param mClass
 */
declare function registerMaterial(type: MaterialTypeValue, mClass: Cesium.Material): void;

/* Excluded from this release type: registerOptsConver */

/**
 * 注册材质属性类
 * @param type
 * @param propertyClass
 */
declare function registerProperty(type: MaterialTypeValue, propertyClass: typeof Cesium.MaterialProperty | typeof BaseMaterialProperty): void;

/**
 * 从其父元素中移除元素
 * @param el - DOM元素或元素ID
 * @group 功能: Dom操作相关
 */
declare function remove(el: HTMLElement | string): void;

/**
 * 移除widget button控件
 * @param uuid - 唯一id
 */
declare function removeButton(uuid: string): void;

/**
 * 在元素上移除指定的name的class样式
 * @param el - DOM元素
 * @param name - class样式名称
 * @group 功能: Dom操作相关
 */
declare function removeClass(el: HTMLElement, name: string): void;

/**
 * Cesium渲染异常处理函数类型
 * @param title - 要显示在错误面板上的标题。此字符串被解释为文本。
 * @param message - 在详细的错误信息之前显示一条有用的、面向用户的消息。此字符串被解释为HTML。
 * @param error - 要显示在错误面板上的错误。此字符串使用`formatError`进行格式化，然后显示为文本。
 */
declare type RenderErrorHandler = (title: string, message: string, error: string) => any;

/** 旋转方向 */
declare interface Rotation {
    /** X方向，角度值0-360 */
    x: number;
    /** Y方向，角度值0-360 */
    y: number;
    /** Z方向，角度值0-360 */
    z: number;
}

/**
 * 面状: 用于面状对象的扫描线放大效果材质
 */
declare class ScanLineMaterialProperty extends BaseMaterialProperty {
    constructor(options?: ScanLineMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "ScanLine";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状: 用于面状对象的扫描线放大效果材质构造器类型
 */
declare interface ScanLineMaterialPropertyOptions {
    /**
     * 扫描线的颜色。
     * 默认为Cesium.Color.YELLOW。
     */
    color?: string | Cesium.Color;
    /**
     * 扫描线的速度。
     * 值越大，扫描越快。
     * 默认为10。
     */
    speed?: number;
}

/* Excluded from this release type: SceneEvent */

/**
 * 在元素上赋值设置指定的name的class样式
 * @param el - DOM元素
 * @param name - class样式名称
 * @group 功能: Dom操作相关
 */
declare function setClass(el: HTMLElement | SVGElement, name: string): void;

/**
 * 对坐标（或坐标数组）赋值修改为 指定的海拔高度值
 * @param positions 笛卡尔坐标数组
 * @param height - 增加的海拔高度值
 * @returns 增加高度后的坐标（或坐标数组）`Cesium.Cartesian3|Cesium.Cartesian3[]`
 */
declare function setPositionsHeight(positions: Cesium.Cartesian3 | Cesium.Cartesian3[], height?: number): Cesium.Cartesian3 | Cesium.Cartesian3[];

/**
 * 自定义Cesium渲染异常处理函数
 * @param viewer - Cesium.Viewer实例
 * @param handler - 处理函数
 */
declare function setRenderErrorHandler(viewer: Cesium.Viewer, handler: RenderErrorHandler): void;

/**
 * 获取一段短的guid
 * @group 功能: 随机ID相关
 */
declare function shortGuid(): string;

/**
 * 积雪特效类(仅支持三维模型上体现)
 */
declare class SnowCoverEffect extends BaseEffect {
    protected _type: EffectTypeKey;
    protected _postProcessStage?: Cesium.PostProcessStage;
    /**
     * 最高限定高度，超出该高度不显示积雪效果
     */
    maxHeight?: number;
    /**
     * 积雪特效类构造参数
     */
    options: SnowCoverEffectOptions;
    constructor(options?: SnowCoverEffectOptions);
    /**
     * 获取覆盖强度，0-1
     */
    get alpha(): any;
    /**
     * 设置覆盖强度，0-1
     */
    set alpha(alpha: any);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _enableHooks(val: boolean): void;
    /**
     * 加控制，只在相机高度低于一定高度时才开启本效果
     * @param event
     */
    protected _camera_changedHandler(event: any): void;
}

/**
 * 积雪特效类构造参数类型
 */
declare interface SnowCoverEffectOptions extends BaseEffectOptions {
    /**
     * 覆盖强度，默认值为`1.0`
     */
    alpha?: number;
    /**
     * 最高限定高度，超出该高度不显示积雪效果，默认值为`5000`
     */
    maxHeight?: number;
}

/**
 * 雪天气特效类
 */
declare class SnowEffect extends BaseEffect {
    protected _type: EffectTypeKey;
    protected _postProcessStage?: Cesium.PostProcessStage;
    /**
     * 雪天气特效类构造参数
     */
    options: SnowEffectOptions;
    constructor(options?: SnowEffectOptions);
    /**
     * 下雪速度
     */
    get speed(): any;
    /**
     * 设置下雪速度
     */
    set speed(value: any);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _enableHooks(val: boolean): void;
}

/**
 * 雪天气特效类构造参数类型
 */
declare interface SnowEffectOptions extends BaseEffectOptions {
    /**
     * 下雪速度，默认值为`10`
     */
    speed?: number;
}

/**
 * 高亮闪烁控制参数
 */
declare interface StartFlickerOptions {
    /**
     * css颜色值、Cesium.Color对象或函数，用于生成颜色，默认值为`Cesium.Color.YELLOW`
     */
    color?: string | Cesium.Color | ((eventParams?: any) => string | Cesium.Color | undefined);
    /**
     * 闪烁的最大透明度
     */
    maxAlpha?: number;
    /**
     * 闪烁的时长(秒)，未设置时不自动停止
     */
    time?: number;
    /**
     * 闪烁播放完成后的回调方法
     */
    onEnd?: (...args: any[]) => any;
}

/**
 * 状态枚举
 * @enum
 */
declare const State: {
    /**
     * 执行了构造函数
     */
    readonly CREATED: "created";
    /**
     * 完成了图层初始化
     */
    readonly INITED: "inited";
    /**
     * 已添加到地球上
     */
    readonly ADDED: "added";
    /**
     * 已从地球上移除
     */
    readonly REMOVED: "removed";
    /**
     * 已销毁对象
     */
    readonly DESTROYED: "destroyed";
};

/**
 * 状态key联合类型
 */
declare type StateKey = keyof typeof State;

/**
 * 状态value联合类型
 */
declare type StateValue = (typeof State)[keyof typeof State];

/**
 * 根据数据和格式化字符串模板，返回字符串
 * @param str - 格式化字符串模版，属性字段为大括号，如 {{name}}
 * @param data - 数据对象
 * @param toEmpty - 是否将模板中未匹配项转为空值
 * @returns 返回字符串
 * @example
 * ```ts
 *  const str = KBE3D.utils..template("<div>名称：{{name}}</div>", { name:"zh", date:"1949-10-1"} );
 *  // str结果为 : "<div>名称：zh</div>"
 * ```
 */
declare function template(str: string, data: Record<string, any>, toEmpty?: boolean): string;

/**
 * terrain地形图层类
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const terrainLayer = new KBE3D.layers.TerrainLayer(
 {
 id: 'test',
 name: 'test',
 flyTo: true,
 terrainType: 'ion',
 source: 1,
 },
 )
 earth.addLayer(terrainLayer)
 * ```
 */
declare class TerrainLayer extends BaseLayer {
    /**
     * 标准椭球体对象
     */
    static Ellipsoid: Cesium.EllipsoidTerrainProvider;
    /**
     * 创建用于图层的 CesiumTerrainProvider 对象
     * @param options - terrain图层类构造参数
     * @example
     * 默认值：
     * {
     *  type: 'ellipsoid',
     *  requestVertexNormals: true
     * }
     * @group 静态方法
     */
    static createTerrainProvider(options: TerrainLayerOptions): Promise<Cesium.TerrainProvider>;
    protected _type: LayerTypeKey;
    /** terrain地形图层类构造参数 */
    options: TerrainLayerOptions;
    /** 地形数据 */
    terrain: Cesium.Terrain | undefined;
    /**
     * @param options - terrain图层类构造参数
     */
    constructor(options: TerrainLayerOptions);
    get isTile(): boolean;
    /**
     * 地形图层的Cesium.TerrainProvider对象
     * @readonly
     */
    get layerSource(): any;
    /**
     * 创建地形数据
     */
    protected _createTerrainProvider(options: TerrainLayerOptions): Promise<Cesium.TerrainProvider>;
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _showHooks(val: boolean): void;
    protected _toJsonHooks(options: CreateLayerOptions): void;
    /**
     * @hidden
     */
    getRectangle(isFormat: true): Extent | undefined;
    /**
     * @hidden
     */
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
}

/**
 * terrain地形图层类构造参数类型
 */
declare interface TerrainLayerOptions extends BaseLayerOptions, Cesium.CesiumTerrainProvider.ConstructorOptions {
    /**
     * 地形的类型，默认为标准椭球体(无地形): 'ellipsoid'
     */
    terrainType?: TerrainTypeValue;
    /**
     * 地形服务的地址URL 或 Cesium.Resource对象 或 Cesium Ion 服务的 asset id（number）
     */
    source?: Cesium.Resource | string | number;
}

/**
 * 地形枚举
 * @enum
 */
declare const TerrainType: {
    /**
     * 标准椭球体(无地形)
     */
    readonly ELLIPSOID: "ellipsoid";
    /**
     * terrain格式标准xyz切片地形
     */
    readonly XYZ: "xyz";
    /**
     * Cesium ION 在线地形
     */
    readonly ION: "ion";
    /**
     * VR 地形
     */
    readonly VR: "vr";
    /**
     * ArcGIS 地形
     */
    readonly ARCGIS: "arcgis";
};

/**
 * 地形key联合类型
 */
declare type TerrainTypeKey = keyof typeof TerrainType;

/**
 * 地形value联合类型
 */
declare type TerrainTypeValue = (typeof TerrainType)[keyof typeof TerrainType];

/**
 * 面状: 文字贴图材质 - ^[Primitive使用]
 */
declare class TextMaterial extends Cesium.Material {
    constructor(options?: TextMaterialOptions);
}

/**
 * 面状: 文字贴图材质构造器类型 - ^[Primitive使用]
 */
declare interface TextMaterialOptions {
    /**
     * 文本内容。
     */
    text?: string;
    /**
     * 字体名称，默认值为 "楷体"。
     * 可选项：微软雅黑, 宋体, 楷体, 隶书, 黑体。
     */
    font_family?: '微软雅黑' | '宋体' | '楷体' | '隶书' | '黑体' | string;
    /**
     * 字体大小，默认值为 30。
     */
    font_size?: number;
    /**
     * 字体加粗设置，默认值为 "normal"。
     * 可选项："bold"（加粗）,"normal"（正常）。
     */
    font_weight?: 'bold' | 'normal';
    /**
     * 字体斜体设置，默认值为 "normal"。
     * 可选项："italic"（斜体）,"normal"（正常）。
     */
    font_style?: 'italic' | 'normal';
    /**
     * 一次性指定CSS字体的属性，包含font_size, font_weight, font_style, font_family。
     */
    font?: string;
    /**
     * 是否填充文本，默认值为 true。
     */
    fill?: boolean;
    /**
     * 填充颜色，默认值为黄色（Cesium.Color.YELLOW）。
     */
    fillColor?: Cesium.Color;
    /**
     * 是否描边文本，默认值为 true。
     */
    stroke?: boolean;
    /**
     * 描边颜色，默认值为白色（透明度0.8）。
     */
    strokeColor?: Cesium.Color;
    /**
     * 描边宽度，默认值为 2。
     */
    strokeWidth?: number;
    /**
     * 画布的背景色，默认值为白色（透明度0.1）。
     */
    backgroundColor?: Cesium.Color;
    /**
     * 边框的宽度。
     */
    outlineWidth?: number;
    /**
     * 矩形边框的颜色，默认值为 fillColor。
     */
    outlineColor?: Cesium.Color;
    /**
     * 要在文本周围添加的填充的像素大小，默认值为 10。
     */
    padding?: number;
    /**
     * 文本的基线，默认值为 'top'。
     */
    textBaseline?: string;
}

/**
 * 面状: 文字贴图entity材质
 */
declare class TextMaterialProperty extends Image2MaterialProperty {
    /**
     */
    protected transparent: boolean;
    /**
     */
    protected _textStyles: TextStyleOptions;
    /**
     */
    protected _canvas: any;
    constructor(options: TextMaterialPropertyOptions);
    /**
     * 文本内容
     */
    get text(): any;
    set text(val: any);
    /**
     * 文本样式
     */
    get textStyles(): TextStyleOptions;
    set textStyles(val: TextStyleOptions);
    _updateImage(): void;
}

/**
 * 面状: 文字贴图entity材质构造器类型
 */
declare interface TextMaterialPropertyOptions {
    /**
     * 文本内容。
     */
    text?: string;
    /**
     * 字体族，默认为"楷体"。
     * 可选项包括：微软雅黑,宋体,楷体,隶书,黑体。
     */
    font_family?: string;
    /**
     * 字体大小，默认为30。
     */
    font_size?: number;
    /**
     * 字体是否加粗，默认为"normal"。
     * 可选项包括：bold (是), normal (否)。
     */
    font_weight?: 'bold' | 'normal';
    /**
     * 字体是否斜体，默认为"normal"。
     * 可选项包括：italic (是), normal (否)。
     */
    font_style?: 'italic' | 'normal';
    /**
     * 一次性指定CSS字体的属性，将覆盖font_family, font_size, font_weight, font_style。
     */
    font?: string;
    /**
     * 是否填充文本，默认为true。
     */
    fill?: boolean;
    /**
     * 文本颜色，默认为"#ffff00"。
     */
    color?: string;
    /**
     * 是否描边文本，默认为true。
     */
    stroke?: boolean;
    /**
     * 描边的颜色，默认为Cesium.Color(1.0, 1.0, 1.0, 0.8)。
     */
    strokeColor?: Cesium.Color;
    /**
     * 描边的宽度，默认为2。
     */
    strokeWidth?: number;
    /**
     * 画布的背景色，默认为Cesium.Color(1.0, 1.0, 1.0, 0.1)。
     */
    backgroundColor?: Cesium.Color;
    /**
     * 边框的宽度。
     */
    outlineWidth?: number;
    /**
     * 矩形边框的颜色，默认为fillColor（如果提供），否则可能依赖于实现。
     */
    outlineColor?: Cesium.Color;
    /**
     * 在文本周围添加的填充的像素大小，默认为10。
     */
    padding?: number;
    /**
     * 文本的基线，默认为'top'。
     */
    textBaseline?: string;
    /**
     * 支持对生成后的Canvas做自定义处理的函数。
     */
    onCustomCanvas?: (canvas: HTMLCanvasElement) => void;
}

/**
 * 文本样式选项
 */
declare interface TextStyleOptions {
    /**
     * 使用的CSS字体。
     */
    font?: string;
    /**
     * 文本的基线。
     */
    textBaseline?: CanvasTextBaseline;
    /**
     * 是否填充文本。
     */
    fill?: boolean;
    /**
     * 填充颜色。
     */
    fillColor?: Cesium.Color;
    /**
     * 是否描边文本。
     */
    stroke?: boolean;
    /**
     * 文本描边的宽度。
     */
    strokeWidth?: number;
    /**
     * 文本描边的颜色。
     */
    strokeColor?: Cesium.Color;
    /**
     * 画布的背景色。
     */
    backgroundColor?: Cesium.Color;
    /**
     * 要在文本周围添加的填充的像素大小。
     */
    padding?: number;
    /**
     * 边框的宽度。
     */
    outlineWidth?: number;
    /**
     * 矩形边框的颜色。如果未设置，则默认为填充颜色。
     */
    outlineColor?: Cesium.Color;
}

/**
 * tileset三维模型图层类
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const tilesetLayer = new KBE3D.layers.TilesetLayer(
 // Cesium ION 服务
 {
 id: 'test',
 name: 'test',
 flyTo: true,
 source: 96188,
 homeVision: {
 lng: 116.360288,
 lat: 39.928658,
 alt: 1000,
 },
 highlight: {
 type: 'edge',
 selectedColor: Cesium.Color.CYAN,
 trigger: 'click',
 },
 },
 )
 if (tilesetLayer) {
 earth.addLayer(tilesetLayer)
 // 加载成功的Promise
 tilesetLayer.addedPromise<TilesetLayer>().then((layer) => {
 // 动态视距线型颜色变化的特效（常用于白膜）
 // layer.customShader = layer.createCustomShader('DistanceColorChange')
 // 动态渐变立体扫描特效的特效（常用于白膜）
 layer.customShader = layer.createCustomShader('DynamicHalo', {
 baseColor: '#FF69B4',
 baseHeight: -50,
 })
 })
 }
 * ```
 */
declare class TilesetLayer extends BaseLayer {
    /**
     * 支持的事件类型
     */
    static EventType: {
        tileVisible: "tileVisible";
        initialTilesLoaded: "initialTilesLoaded";
        allTilesLoaded: "allTilesLoaded";
        openPopup: "openPopup";
        closePopup: "closePopup";
        destroyPopup: "destroyPopup";
        changePopupPosition: "changePopupPosition";
        showPopup: "showPopup";
        hidePopup: "hidePopup";
        add: "add";
        remove: "remove";
        addLayer: "addLayer";
        removeLayer: "removeLayer";
        show: "show";
        hide: "hide";
        click: "click";
        leftDown: "leftDown";
        leftUp: "leftUp";
        rightClick: "rightClick";
        rightDown: "rightDown";
        rightUp: "rightUp";
        middleClick: "middleClick";
        middleDown: "middleDown";
        middleUp: "middleUp";
        mouseDown: "mouseDown";
        mouseUp: "mouseUp";
        mouseOver: "mouseOver";
        mouseOut: "mouseOut";
    };
    protected _type: LayerTypeKey;
    /**
     * tileset三维模型数据
     */
    protected _tileset: Cesium.Cesium3DTileset | undefined;
    /**
     * 模型原始的旋转角度，示例：`{ x: 0, y: 0, z: 0 }`
     */
    protected _originRotation: {
        x: number;
        y: number;
        z: number;
    };
    /**
     * 模型原始的中心点坐标
     */
    protected _originCenterPoint: LatLngPoint;
    /**
     * 模型原始的中心点坐标 （笛卡尔坐标）
     */
    protected _originCenterPosition: Cesium.Cartesian3;
    /**
     * 模型原始矩阵
     */
    protected _originMatrix: Cesium.Matrix4 | undefined;
    /**
     * 模型的中心点坐标
     */
    protected _center: LatLngPoint;
    /**
     * 透明度：0~1
     */
    protected _opacity: number;
    /**
     * 模型样式回调函数
     */
    protected _styleCallback: ((options: {
        feature: Cesium.Cesium3DTileFeature;
        properties: any;
    }) => Cesium.Color) | undefined;
    /**
     * 是否绑定了tileVisible事件 {@link Cesium.Cesium3DTileset#tileVisible}
     */
    protected _isBindTileVisible: boolean;
    /**
     * feature数据中唯一标识的属性字段名称
     */
    protected _primaryKey: string;
    /**
     * setProperties方法在tile上绑定的属性缓存
     */
    protected _propertiesCache: Record<string, any>;
    /**
     * 是否处于整体高亮的状态
     */
    protected _highlightAll: boolean;
    /**
     * tileset的样式缓存，用于高亮复原时重新赋值tileset.style
     */
    protected _styleCache: Cesium.Cesium3DTileStyle | undefined;
    /** tileset三维模型图层类构造参数 */
    options: TilesetLayerOptions;
    /** 3dtiles模型高亮特效 */
    highlight: HighlightTileset | undefined;
    /**
     * @param options - tileset三维模型图层类构造参数
     */
    constructor(options: TilesetLayerOptions);
    get isTile(): boolean;
    /**
     * 三维模型图层的Cesium.Cesium3DTileset对象
     * @readonly
     */
    get layerSource(): any;
    /**
     * 默认优化选项
     * @readonly
     */
    get defaultTilesetOptimizeOptions(): TilesetLayerOptimizeOptions;
    /**
     * 模型对应的 Cesium3DTileset对象
     * @readonly
     */
    get tileset(): Cesium.Cesium3DTileset | undefined;
    /**
     * 是否存在世界矩阵
     * @readonly
     */
    get hasTransform(): Cesium.Matrix4 | undefined;
    /**
     * 模型的边界球体
     * @readonly
     */
    get boundingSphere(): Cesium.BoundingSphere | undefined;
    /**
     * 获取瓦片集的资产对象属性，其中包含有关瓦片集的元数据。
     * @readonly
     */
    get asset(): any;
    /**
     * 获取瓦片集的属性字典对象，其中包含有关每个特征属性的元数据。
     * @readonly
     */
    get properties(): any;
    /**
     * 瓦片集使用的 GPU 内存总量（以字节为单位）。这个值是根据几何、纹理、批处理表纹理和加载的切片的二进制元数据估计的。
     * @readonly
     */
    get totalMemoryUsageInBytes(): number | undefined;
    /**
     * 模型原始的中心点坐标
     * @readonly
     */
    get originCenterPoint(): LatLngPoint;
    /**
     * 模型原始的中心点坐标 （笛卡尔坐标）
     * @readonly
     */
    get originCenterPosition(): Cesium.Cartesian3;
    /**
     * 模型当前中心点坐标 （笛卡尔坐标）
     * @readonly
     */
    get position(): Cesium.Cartesian3;
    /**
     * 模型当前中心点坐标
     */
    get center(): LatLngPoint;
    /**
     * 获取模型高度
     */
    get height(): number;
    /**
     * 设置模型高度
     */
    set height(value: number);
    /**
     * 旋转方向，示例：`{ x: 0, y: 0, z: 0 }`
     */
    get rotation(): Rotation;
    /**
     * 设置旋转方向，示例：`{ x: 0, y: 0, z: 0 }`
     */
    set rotation(value: Rotation);
    /**
     * X轴上的旋转方向
     */
    get rotation_x(): number;
    /**
     * 设置X轴上的旋转方向
     */
    set rotation_x(value: number);
    /**
     * Y轴上的旋转方向
     */
    get rotation_y(): number;
    /**
     * 设置Y轴上的旋转方向
     */
    set rotation_y(value: number);
    /**
     * Z轴上的旋转方向
     */
    get rotation_z(): number;
    /**
     * 设置Z轴上的旋转方向
     */
    set rotation_z(value: number);
    /**
     * 轴方向
     */
    get axis(): "Y_UP_TO_Z_UP" | "Z_UP_TO_Y_UP" | "X_UP_TO_Z_UP" | "Z_UP_TO_X_UP" | "X_UP_TO_Y_UP" | "Y_UP_TO_X_UP" | undefined;
    /**
     * 设置轴方向
     */
    set axis(value: "Y_UP_TO_Z_UP" | "Z_UP_TO_Y_UP" | "X_UP_TO_Z_UP" | "Z_UP_TO_X_UP" | "X_UP_TO_Y_UP" | "Y_UP_TO_X_UP" | undefined);
    /**
     * 获取缩放比例
     */
    get scale(): number;
    /**
     * 设置获取缩放比例
     */
    set scale(value: number);
    /**
     * 透明度，取值范围：0.0-1.0
     */
    get opacity(): number;
    /**
     * 设置透明度，取值范围：0.0-1.0
     */
    set opacity(val: number);
    /**
     * 模型样式
     */
    get style(): Record<string, any> | Cesium.Cesium3DTileStyle | ((options: {
        feature: Cesium.Cesium3DTileFeature;
        properties: any;
    }) => Cesium.Color) | undefined;
    /**
     * 设置模型样式
     */
    set style(value: Record<string, any> | Cesium.Cesium3DTileStyle | ((options: {
        feature: Cesium.Cesium3DTileFeature;
        properties: any;
    }) => Cesium.Color) | undefined);
    /**
     * 一个自定义着色器，用于应用到瓦片集中的所有瓦片上。仅用于使用Model模型的内容。使用 Cesium3DTileStyle 的自定义着色器可能会导致未定义的行为。
     */
    get customShader(): Cesium.CustomShader | undefined;
    /**
     * 设置自定义着色器，用于应用到瓦片集中的所有瓦片上。仅用于使用Model模型的内容。使用 Cesium3DTileStyle 的自定义着色器可能会导致未定义的行为。
     */
    set customShader(value: Cesium.CustomShader | undefined);
    /**
     * 设置模型当前中心点坐标
     */
    set center(value: ParserLatLngPointInput);
    /**
     * 是否允许鼠标穿透拾取
     */
    get allowDrillPick(): boolean | ((event: PickTargetInfo) => boolean) | undefined;
    /**
     * 是否允许鼠标穿透拾取
     */
    set allowDrillPick(value: boolean | ((event: PickTargetInfo) => boolean) | undefined);
    protected _initHooks(): Promise<void>;
    protected _addHooks(): Promise<void>;
    protected _removeHooks(): void;
    protected _destroyHooks(): void;
    protected _showHooks(val: boolean): void;
    protected _toJsonHooks(options: CreateLayerOptions): void;
    /**
     * 创建Cesium3DTileset
     */
    protected _createCesium3DTileset(): Promise<Cesium.Cesium3DTileset>;
    /**
     * 绑定tilevisible事件
     */
    protected _bindTileVisibleEvent(): void;
    /**
     * 更新切片
     */
    protected _updateTile(tile: Cesium.Cesium3DTile): void;
    /**
     * 设置新的中心点
     * @param configCenter
     */
    protected _mergePostion(configCenter: Partial<Center>): void;
    /**
     * 初始化高亮特效
     */
    protected _initHighlight(): void;
    /**
     * 销毁highlight高亮特效
     */
    protected _destroyHighlight(): void;
    /**
     * 初始化
     */
    protected _init(): void;
    /**
     * 根据map及图层坐标系 转换中心点
     * @param center
     * @returns Center对象
     */
    protected _transformCenter(center: LatLngPoint): Center | undefined;
    /**
     * 是否需要更新矩阵
     */
    protected _hasUpdateMater(): boolean;
    /**
     * 重新计算当前矩阵，普通方式, 此种方式[x，y不能多次更改]
     */
    protected _updateMatrix2(): Cesium.Matrix4 | undefined;
    /**
     * 设置透明度，取值范围：0.0-1.0
     */
    setOpacity(val: number): void;
    /**
     * 设置模型当前中心点坐标
     */
    setCenter(value: ParserLatLngPointInput): void;
    /**
     * 设置模型高度
     */
    setHeight(value: number): void;
    /**
     * 设置旋转方向，示例：`{ x: 0, y: 0, z: 0 }`
     */
    setRotation(value: Rotation): void;
    /**
     * 设置X轴上的旋转方向
     */
    setRotationX(value: number): void;
    /**
     * 设置Y轴上的旋转方向
     */
    setRotationY(value: number): void;
    /**
     * 设置Z轴上的旋转方向
     */
    setRotationZ(value: number): void;
    /**
     * 设置轴方向
     */
    setAxis(value?: 'Y_UP_TO_Z_UP' | 'Z_UP_TO_Y_UP' | 'X_UP_TO_Z_UP' | 'Z_UP_TO_X_UP' | 'X_UP_TO_Y_UP' | 'Y_UP_TO_X_UP'): void;
    /**
     * 设置获取缩放比例
     */
    setScale(value: number): void;
    /**
     * 设置模型样式
     */
    setStyle(value?: Record<string, any> | Cesium.Cesium3DTileStyle | ((options: {
        feature: Cesium.Cesium3DTileFeature;
        properties: any;
    }) => Cesium.Color)): void;
    /**
     * 设置自定义着色器，用于应用到瓦片集中的所有瓦片上。仅用于使用Model模型的内容。使用 Cesium3DTileStyle 的自定义着色器可能会导致未定义的行为。
     */
    setCustomShader(value: Cesium.CustomShader | undefined): void;
    /**
     * 模型自动贴地计算及处理，因为模型在设计或生产时，模型的视角中心位置不一定在0,0,0点，此方法不是唯一准确的
     * @param addHeight - 计算完成的贴地高度基础上增加的高度值，默认值 1
     */
    clampToGround(addHeight?: number): void;
    /**
     * 设置属性信息到Feature上，通过primaryKey判断，如果在feature上的属性中，该primaryKey并没有找到对应值，将不做更新处理
     * @param properties - 属性值数组，其中每个对象都包含由`primaryKey`指定的唯一标识符
     * @param primaryKey - 数据中唯一标识的属性字段名称，默认值为id
     */
    setProperties(properties: Record<string, any>[], primaryKey?: string): void;
    /**
     * 获取feature的属性对象
     * @param feature
     * @returns 属性对象
     */
    getFeatureProperties(feature: Cesium.Cesium3DTileFeature): Record<string, any>;
    /**
     * 直接设置feature属性
     * @param feature
     * @param properties
     */
    setFeatureProperties(feature: Cesium.Cesium3DTileFeature, properties: Record<string, any>): void;
    /**
     * 重新计算当前矩阵
     * @returns 计算完成的矩阵
     */
    updateMatrix(): Cesium.Matrix4 | undefined;
    /**
     * 瓦片加载性能调优
     * @param options - 调优参数
     * @param mergeOptions - 是否与默认调优参数合并
     */
    optimize(options?: TilesetLayerOptimizeOptions, mergeOptions?: boolean): void;
    /**
     * 根据内置shader类型及相关自定义参数创建内置的shader效果
     * @param type - 内置的shader类型
     * @param options - 内置的shader类型所对应的入参
     * @returns Cesium.CustomShader对象，可直接赋值给layer.customShader
     */
    createCustomShader(type: CustomShaderTypeValue, options?: CustomShaderTypeOptions[keyof CustomShaderTypeOptions]): Cesium.CustomShader | undefined;
    getRectangle(isFormat: true): Extent | undefined;
    getRectangle(isFormat?: false): Cesium.Rectangle | undefined;
    /**
     * 设置shader的外部控制变量，并调整图层渲染
     */
    setUniforms(val: Record<string, any>): void;
}

/**
 * tileset三维模型图层类常用的三维模型优化选项
 */
declare interface TilesetLayerOptimizeOptions {
    /**
     * maximumScreenSpaceError 是一个数字参数，用于指定瓦片在屏幕上显示时可以容忍的最大屏幕空间误差。
     * maximumScreenSpaceError 决定了瓦片何时需要细化到其子代。当瓦片在屏幕上的投影误差超过这个值时，Cesium 会加载并显示更高分辨率的子代瓦片，以提供更精细的视觉效果。
     * 通过调整 maximumScreenSpaceError 的值，可以在保持一定视觉质量的前提下，减少加载的瓦片数量，从而降低内存和计算资源的使用，提高渲染性能。
     * CesiumJS 中 maximumScreenSpaceError 的默认值为 16。这个值表示 1 米的几何体在屏幕上投影为 16 个像素时被认为是可接受的误差范围。然而，这个默认值可能并不适用于所有情况，需要根据实际的应用场景进行调整。
     * 如果应用场景对性能有较高要求，可以尝试增大 maximumScreenSpaceError 的值。这将减少加载的瓦片数量，但可能会牺牲一定的视觉质量。如果更注重视觉效果，可以减小 maximumScreenSpaceError 的值。这将加载更多的瓦片以提供更精细的显示效果，但可能会增加加载时间和计算资源的使用。
     * 在实际应用中，需要根据具体需求进行平衡调整。通过多次测试和调整，找到最适合当前应用场景的 maximumScreenSpaceError 值。
     * @remarks
     * 该配置的初始默认值为`16`，在此优化选项中，默认值调整到`64`
     */
    maximumScreenSpaceError?: number;
    /**
     * cacheBytes 是一个可选的数字参数，用于指定缓存的最大额定显存大小（以字节为单位）。这个值代表了Cesium在尝试维持缓存大小时的目标值。
     * 当缓存中的瓦片数据占用的显存超过cacheBytes指定的值时，Cesium会尝试通过卸载一些不再需要的瓦片来减少缓存的大小，以便为新的瓦片腾出空间。
     * 这个参数有助于防止缓存过大而导致的内存溢出问题，同时也能够优化系统的内存使用效率。
     * @remarks
     * 该配置的初始默认值为`536870912`(512MB)，在此优化选项中，默认值调整到`2147483648`(2GB)
     */
    cacheBytes?: number;
    /**
     * maximumCacheOverflowBytes是另一个可选的数字参数，用于指定在缓存超过cacheBytes时允许的最大额外显存大小（以字节为单位）。这个值表示了缓存可以超出额定显存大小的最大范围。
     * 当缓存中的瓦片数据占用的显存超过cacheBytes但仍在cacheBytes + maximumCacheOverflowBytes的范围内时，Cesium仍然会尝试保持这些瓦片在缓存中，以便在需要时能够快速访问它们。
     * 这个参数为缓存提供了一定的灵活性，允许在特定情况下暂时超出额定显存大小，以应对突发性的数据加载需求。
     * 与cacheBytes类似，maximumCacheOverflowBytes的默认值也可能因Cesium版本的不同而有所差异。但一般而言，它会被设置为一个相对较小的值（如几百MB或更小），以确保缓存不会无限制地增长。
     * @remarks
     * 该配置的初始默认值为`536870912`(512MB)，在此优化选项中，默认值调整到`1073741824`(1GB)
     */
    maximumCacheOverflowBytes?: number;
    /**
     * cullRequestsWhileMovingMultiplier 是一个数字参数，当相机移动时，许多之前请求的瓦片可能会因为相机的快速移动而变得不再可见或重要性降低。为了避免加载这些可能不会被使用的瓦片，Cesium会尝试剔除这些请求。cullRequestsWhileMovingMultiplier参数通过调整剔除请求的乘数来影响剔除的积极性。
     * 这个参数的值越大，剔除请求的积极性就越高，即更多的瓦片请求会被取消。相反，值越小，剔除的积极性就越低，更多的瓦片请求会被保留。
     * 在实际应用中，需要根据具体需求进行平衡调整。较高的值可能会减少内存使用和渲染负载，但可能会牺牲一些场景的细节或增加加载延迟。较低的值可能会保留更多的瓦片请求，从而提供更丰富的场景细节，但可能会增加内存使用和渲染负载。
     * @remarks
     * 该配置的初始默认值为`60`，在此优化选项中，默认值调整到`100`
     */
    cullRequestsWhileMovingMultiplier?: number;
    /**
     * skipLevelOfDetail 是 CesiumJS 中 Cesium3DTileset 类的一个重要参数，它用于控制是否在遍历 3D 瓦片树时跳过某些详细级别（Level of Detail, LOD）的瓦片
     * 当 skipLevelOfDetail 设置为 true 时，CesiumJS 会在遍历 3D 瓦片树时自动跳过一些不重要的详细级别。这意味着，对于远离相机或位于视野边缘的瓦片，Cesium 可能会选择加载较低分辨率的版本，而不是高分辨率的版本。这样做可以减少需要加载和渲染的瓦片数量，从而降低内存使用和渲染负载。
     * 相反，当 skipLevelOfDetail 设置为 false 时，Cesium 会尝试加载所有可用的详细级别的瓦片，以提供最高的视觉质量。然而，这可能会增加加载时间和渲染负担，特别是对于大规模数据集。
     * 在需要处理大规模 3D 数据集时，如城市模型、地形数据等，skipLevelOfDetail 可以帮助提高性能和响应速度。
     * 当用户对场景的视觉质量要求不是特别高，或者可以接受在一定距离外使用较低分辨率的瓦片时，可以启用 skipLevelOfDetail。
     * 启用 skipLevelOfDetail 可能会影响场景的视觉质量，因为远处的瓦片可能会以较低的分辨率渲染。因此，在需要高精度视觉效果的场景中，可能需要谨慎使用。
     * skipLevelOfDetail 可以与其他参数（如 baseScreenSpaceError、skipScreenSpaceErrorFactor、immediatelyLoadDesiredLevelOfDetail 和 skipLevels）结合使用，以更精细地控制瓦片的加载和渲染行为。
     * @remarks
     * 该配置的初始默认值为`false`，在此优化选项中，默认值调整到`true`
     */
    skipLevelOfDetail?: boolean;
    /**
     * 当 skipLevelOfDetail 参数为 true 时，Cesium 会在遍历 3D 瓦片树时跳过一些不重要的瓦片，以提高加载速度和性能。然而，这个跳过过程可能会受到多个因素的影响，如 skipScreenSpaceErrorFactor 和 skipLevels 等。
     * immediatelyLoadDesiredLevelOfDetail 参数则提供了一种更直接的方式来控制加载行为。如果将其设置为 true，Cesium 会忽略这些跳过因素，只加载满足最大屏幕空间误差（maximumScreenSpaceError）的瓦片。这意味着，在相机视角下最重要的瓦片会被优先加载，而不管它们是否位于跳过的详细级别内。
     * 当你需要确保相机视角下最重要的瓦片能够立即加载时，可以将 immediatelyLoadDesiredLevelOfDetail 设置为 true。这对于需要快速响应用户操作或提供流畅视觉体验的应用场景特别有用。然而，需要注意的是，将这个参数设置为 true 可能会导致加载更多的瓦片，从而增加内存使用和渲染负载。因此，在资源受限或性能敏感的应用场景中，需要谨慎使用。
     * @remarks
     * 该配置的初始默认值为`false`，在此优化选项中，默认值调整到`true`
     */
    immediatelyLoadDesiredLevelOfDetail?: boolean;
    /**
     * progressiveResolutionHeightFraction 是一个介于 0 和 1 之间的浮点数，主要用于控制瓦片集在初始加载时的分辨率，以实现从低分辨率到高分辨率的渐进式加载，从而提升用户体验
     * 该参数影响瓦片集在初始加载时的分辨率。当设置为较小的值时，初始加载的瓦片将以较低的分辨率显示，使得加载速度更快，但视觉效果较模糊。随着用户的进一步交互（如缩放、平移等），瓦片的分辨率会逐渐提高，直到达到最高分辨率。
     * 如果你的应用场景对初始加载速度有较高要求，可以尝试将 progressiveResolutionHeightFraction 设置为一个较小的值（如 0.1 或 0.2），以加快初始加载速度。
     * 如果你的用户更注重视觉效果，并且不介意稍微长一些的加载时间，可以将该参数设置为一个较大的值（接近 1），以获得更清晰的初始显示效果。
     * @remarks
     * 该配置的初始默认值为`0.3`，在此优化选项中，默认值调整到`0.1`
     */
    progressiveResolutionHeightFraction?: number;
}

/**
 * tileset三维模型图层类构造参数类型
 * @property [modelMatrix = Matrix4.IDENTITY] - 模型的矩阵位置，内部无坐标位置的模型使用，此时position和rotation等参数均无效.
 * @property [modelUpAxis = Axis.Y] - 加载瓦片内容时，哪个轴被认为是向上的。
 * @property [modelForwardAxis = Axis.X] - 加载瓦片内容时，哪个轴被认为是向前的。
 * @property [shadows = ShadowMode.ENABLED] - 确定瓦片集是否投射或接收来自光源的阴影。
 * @property @property [maximumScreenSpaceError = 16] - 用于驱动细节层次细化的最大屏幕空间误差。
 * @property [cacheBytes = 536870912] - 如果缓存包含当前视图不需要的瓦片，则瓦片缓存将被修剪到的大小（以字节为单位）。
 * @property [maximumCacheOverflowBytes = 536870912] - 如果当前视图需要超过 {@link Cesium.Cesium3DTileset.cacheBytes} 的缓存空间，则允许的最大额外内存（以字节为单位）作为缓存头部空间。
 * @property [cullWithChildrenBounds = true] - 优化选项。是否使用其子边界体积的并集来剔除瓦片。
 * @property [cullRequestsWhileMoving = true] - 优化选项。不要请求在相机移动后可能不会被使用的瓦片。此优化仅适用于静态瓦片集。
 * @property [cullRequestsWhileMovingMultiplier = 60.0] - 优化选项。在移动时剔除请求时使用的乘数。数值越大剔除越积极，数值越小剔除越不积极。
 * @property [preloadWhenHidden = false] - 当 <code>tileset.show</code> 为 <code>false</code> 时，是否预加载瓦片。即使瓦片集不可见，也会加载瓦片但不渲染它们。
 * @property [preloadFlightDestinations = true] - 优化选项。在相机飞行过程中，预加载相机飞行目的地的瓦片。
 * @property [preferLeaves = false] - 优化选项。优先加载叶子节点。
 * @property [dynamicScreenSpaceError = true] - 优化选项。对于街道级别的地平线视图，使用远离相机的较低分辨率瓦片。这减少了加载的数据量，并提高了瓦片集的加载时间，同时稍微降低了远处的视觉质量。
 * @property [dynamicScreenSpaceErrorDensity = 2.0e-4] - 类似于 {@link Cesium.Fog#density}，此选项控制相机距离，在该距离下 {@link Cesium.Cesium3DTileset.dynamicScreenSpaceError} 优化生效。较大的值会使更靠近相机的瓦片受到影响。
 * @property [dynamicScreenSpaceErrorFactor = 24.0] - 控制地平线处瓦片 {@link Cesium.Cesium3DTileset.dynamicScreenSpaceError} 优化强度的参数。较大的值会导致加载更低分辨率的瓦片，从而在稍微降低视觉质量的情况下提高运行时性能。
 * @property [dynamicScreenSpaceErrorHeightFalloff = 0.25] - 确定“街道级别”相机视图发生位置的瓦片集高度的比率。当相机低于此高度时，{@link Cesium.Cesium3DTileset.dynamicScreenSpaceError} 优化将具有最大效果，并且在此值之上将逐渐减弱。
 * @property [progressiveResolutionHeightFraction = 0.3] - 优化选项。如果值在 (0.0, 0.5] 范围内，则会优先加载或首先处理屏幕空间误差低于 <code>progressiveResolutionHeightFraction*screenHeight</code> 减小屏幕分辨率的瓦片。这有助于在完全分辨率瓦片继续加载的同时，快速获得一层瓦片。
 * @property [foveatedScreenSpaceError = true] - 优化选项。通过暂时提高屏幕边缘瓦片的屏幕空间误差，来优先加载屏幕中心的瓦片。一旦根据 {@link Cesium.Cesium3DTileset.foveatedConeSize} 确定的屏幕中心的所有瓦片都加载完成，屏幕空间误差将恢复正常。
 * @property [foveatedConeSize = 0.1] - 优化选项。当 {@link Cesium.Cesium3DTileset.foveatedScreenSpaceError} 为真时，用于控制确定哪些瓦片被延迟加载的锥体大小。锥体内的瓦片会立即加载。锥体外的瓦片可能会根据它们距离锥体的远近和它们的屏幕空间误差被延迟加载。这由 {@link Cesium.Cesium3DTileset.foveatedInterpolationCallback} 和 {@link Cesium.Cesium3DTileset.foveatedMinimumScreenSpaceErrorRelaxation} 控制。将此值设置为 0.0 表示锥体将是相机位置和观察方向形成的线。将此值设置为 1.0 表示锥体包含相机的整个视野，从而禁用此效果。
 * @property [foveatedMinimumScreenSpaceErrorRelaxation = 0.0] - 优化选项。当 {@link Cesium.Cesium3DTileset.foveatedScreenSpaceError} 为真时，用于控制锥体外瓦片的起始屏幕空间误差放松量。屏幕空间误差将根据提供的 {@link Cesium.Cesium3DTileset.foveatedInterpolationCallback} 从瓦片集的初始值增加到 {@link Cesium.Cesium3DTileset.maximumScreenSpaceError}。
 * @property [foveatedInterpolationCallback = Math.lerp] - 优化选项。当 {@link Cesium.Cesium3DTileset#foveatedScreenSpaceError} 为真时，用于控制锥体外瓦片的屏幕空间误差应提高多少，通过插值在 {@link Cesium.Cesium3DTileset#foveatedMinimumScreenSpaceErrorRelaxation} 和 {@link Cesium.Cesium3DTileset#maximumScreenSpaceError} 之间计算。
 * @property [foveatedTimeDelay = 0.2] - 优化选项。当 {@link Cesium.Cesium3DTileset#foveatedScreenSpaceError} 为真时，用于控制在相机停止移动后，延迟多少秒才开始加载被延迟的瓦片。这个时间延迟可以防止在相机移动时请求屏幕边缘附近的瓦片。将此值设置为 0.0 将立即请求给定视图中的所有瓦片。
 * @property [skipLevelOfDetail = false] - 优化选项。确定在遍历过程中是否应用细节级别跳过。
 * @property [baseScreenSpaceError = 1024] - 当 <code>skipLevelOfDetail</code> 为 <code>true</code> 时，必须达到的屏幕空间误差值，以决定是否跳过细节级别。
 * @property [skipScreenSpaceErrorFactor = 16] - 当 <code>skipLevelOfDetail</code> 为 <code>true</code> 时，一个乘数，定义了跳过瓦片所需的最小屏幕空间误差。与 <code>skipLevels</code> 结合使用，以确定加载哪些瓦片。
 * @property [skipLevels = 1] - 当 <code>skipLevelOfDetail</code> 为 <code>true</code> 时，一个常量，定义了加载瓦片时要跳过的最小层数。当此值为 0 时，不跳过任何层。与 <code>skipScreenSpaceErrorFactor</code> 结合使用，以确定加载哪些瓦片。
 * @property [immediatelyLoadDesiredLevelOfDetail = false] - 当 <code>skipLevelOfDetail</code> 为 <code>true</code> 时，仅下载满足最大屏幕空间误差的瓦片。忽略跳过因素，只加载所需的瓦片。
 * @property [loadSiblings = false] - 当 <code>skipLevelOfDetail</code> 为 <code>true</code> 时，确定在遍历过程中是否总是下载可见瓦片的同级瓦片。
 * @property [clippingPlanes] - 用于选择性地禁用瓦片集渲染的 {@link Cesium.ClippingPlaneCollection}。这允许您定义一组裁剪平面，瓦片集中的几何体在这些平面外部时将不会被渲染。
 * @property [clippingPolygons] - 类似于 clippingPlanes，但使用多边形而非平面进行裁剪。这是通过 {@link Cesium.ClippingPolygonCollection} 来实现的，允许更复杂的裁剪形状。
 * @property [classificationType] - 确定此瓦片集是否对三维模型、3D 瓦片或两者进行分类。这对于在复杂场景中管理渲染顺序和深度测试非常重要。有关限制和限制的详细信息，请参阅 {@link Cesium.Cesium3DTileset#classificationType}。
 * @property [ellipsoid = Ellipsoid.WGS84] - 确定地球大小和形状的椭球体。默认是 WGS84 椭球体，但可以根据需要进行更改以匹配不同的地理模型。
 * @property [pointCloudShading] - 用于构建 {@link Cesium.PointCloudShading} 对象的选项，该对象根据几何误差和光照控制点衰减。这对于优化点云数据的渲染非常有用。
 * @property [lightColor] - 模型着色时使用的光颜色。如果未定义，则使用场景的光颜色。这允许您为瓦片集中的模型指定自定义光照颜色。
 * @property [imageBasedLighting] - 管理此瓦片集图像基光照的属性。图像基光照（IBL）是一种基于环境光贴图来模拟全局光照效果的技术，可以显著提高场景的逼真度。
 * @property [backFaceCulling = true] - 是否剔除背面几何体。当设置为 true 时，背面剔除由 glTF 材料的 doubleSided 属性决定；当设置为 false 时，禁用背面剔除。这可以影响渲染性能和视觉效果。
 * @property [enableShowOutline = true] - 是否为使用 {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline | CESIUM_primitive_outline} 扩展的模型启用轮廓线。设置为 false 可以避免加载时额外的几何体处理。当设置为 false 时，showOutlines 和 outlineColor 选项将被忽略。
 * @property [showOutline = true] - 是否显示使用 {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline | CESIUM_primitive_outline} 扩展的模型的轮廓线。当设置为 true 时，将显示轮廓线；当设置为 false 时，则不显示。
 * @property [outlineColor = Color.BLACK] - 渲染轮廓线时使用的颜色。默认情况下，轮廓线颜色为黑色，但您可以根据需要更改为其他颜色。
 * @property [vectorClassificationOnly = false] - 指示是否仅应使用瓦片集的矢量瓦片进行分类。在某些情况下，您可能只想根据矢量数据（如道路、建筑物轮廓等）进行渲染和分类，而忽略其他类型的瓦片数据。
 * @property [vectorKeepDecodedPositions = false] - 是否在内存中保留矢量瓦片的解码位置。这对于使用 {@link Cesium.Cesium3DTileFeature.getPolylinePositions} 等方法检索多段线位置时非常有用。如果设置为 true，则可以避免在每次需要时都重新解码数据，从而提高性能。
 * @property [featureIdLabel = "featureId_0"] - 用于拾取和样式化的特征ID集的标签。对于支持 EXT_mesh_features 扩展的瓦片，这可以是特征ID的标签属性，或者当未指定时，使用 "featureId_N"（其中 N 是特征ID数组中的索引）作为默认标签。对于不支持标签字段的 EXT_feature_metadata，特征ID集总是使用 "featureId_N" 作为标签，其中 N 是所有特征ID列表中的索引，特征ID属性在特征ID纹理之前列出。如果 featureIdLabel 是一个整数 N，它会自动转换为字符串 "featureId_N"。如果同时存在按基元和按实例的特征ID，则按实例的特征ID具有优先权。
 * @property [instanceFeatureIdLabel = "instanceFeatureId_0"] - 用于拾取和样式化的实例特征ID集的标签。与 featureIdLabel 类似，但专门用于实例特征ID。如果 instanceFeatureIdLabel 设置为整数 N，它会自动转换为字符串 "instanceFeatureId_N"。如果同时存在按基元和按实例的特征ID，则按实例的特征ID具有优先权。
 * @property [showCreditsOnScreen = false] - 是否在屏幕上显示此瓦片集的版权信息。这有助于遵守数据提供者的版权要求，并向用户展示数据的来源。
 * @property [splitDirection = SplitDirection.NONE] - 应用于此瓦片集的 {@link Cesium.SplitDirection} 分割方向。这可以用于在渲染过程中优化瓦片的加载和渲染顺序，特别是在处理大规模数据集时。SplitDirection 枚举提供了不同的分割选项，如水平、垂直或两者都不分割。
 * @property [enableCollision = false] - 当设置为 true 时，启用相机或 CPU 拾取时的碰撞检测。如果 {@link Cesium.ScreenSpaceCameraController#enableCollisionDetection} 也设置为 true，则相机将被阻止低于瓦片集表面。这对于创建更加沉浸式和逼真的用户体验非常有用，特别是在处理具有复杂三维模型或建筑物模型的瓦片集时。
 * @property [projectTo2D = false] - 是否将瓦片集准确投影到2D。如果设置为 true，瓦片集将被准确投影到2D，但会消耗更多内存。如果设置为 false，瓦片集将使用较少的内存，并且仍然可以在2D/CV模式下渲染，但其投影位置可能不准确。这个属性必须在瓦片集创建之前设置，一旦瓦片集被创建，就不能再更改。
 * @property [enablePick = false] - 在使用WebGL 1时，是否允许通过pick操作进行碰撞检测和CPU拾取。如果使用WebGL 2或更高版本，此选项将被忽略。如果使用WebGL 1且此选项为 true，则pick操作将正常工作，但会消耗更多内存。如果使用WebGL 1且此选项为 false，则模型将使用较少的内存，但pick操作将始终返回undefined。这个属性必须在瓦片集加载之后才能设置。
 * @property [debugHeatmapTilePropertyName] - 用于将瓦片变量着色为热图的变量名。所有渲染的瓦片都将根据其指定的变量值相对于彼此进行着色。这主要用于调试和可视化目的。
 * @property [debugFreezeFrame = false] - 仅用于调试。确定是否仅使用上一帧的瓦片进行渲染。这有助于检查渲染过程中的静态状态。
 * @property [debugColorizeTiles = false] - 仅用于调试。当设置为 true 时，会为每个瓦片分配一个随机颜色，以帮助可视化瓦片的布局和加载情况。
 * @property [enableDebugWireframe = false] - 仅用于调试。在WebGL 1中，要使debugWireframe正常工作，此选项必须为 true。这个属性必须在瓦片集创建之前设置，一旦瓦片集被创建，就不能再更改。
 * @property [debugWireframe = false] - 仅用于调试。当设置为 true 时，将每个瓦片的内容渲染为线框图，以便查看其内部结构。
 * @property [debugShowBoundingVolume = false] - 仅用于调试。当设置为 true 时，渲染每个瓦片的边界体，有助于理解瓦片的空间位置和范围。
 * @property [debugShowContentBoundingVolume = false] - 仅用于调试。当设置为 true 时，渲染每个瓦片内容的边界体，进一步细化显示瓦片内部内容的位置和范围。
 * @property [debugShowViewerRequestVolume = false] - 仅用于调试。当设置为 true 时，渲染每个瓦片的观察者请求体积，这有助于理解在渲染过程中哪些瓦片被请求和加载。
 * @property [debugShowGeometricError = false] - 仅用于调试。如果为 true，则绘制标签以指示每个图块的几何误差。
 * @property [debugShowRenderingStatistics = false] - 仅用于调试。如果为 true，则绘制标签以指示每个图块的命令、点、三角形和特征的数量。
 * @property [debugShowMemoryUsage = false] - 仅用于调试。如果为 true，则绘制标签以指示每个图块使用的纹理和几何内存（以兆字节为单位）。
 * @property [debugShowUrl = false] - 仅用于调试。如果为 true，则绘制标签以指示每个图块的 url。
 */
declare interface TilesetLayerOptions extends BaseLayerOptions, Cesium.Cesium3DTileset.ConstructorOptions {
    /**
     * 一个 3DTiles 瓦片集（Tileset）JSON文件的URL 或 Cesium.Resource对象 或 Cesium Ion 服务的 asset id（number）
     */
    source: Cesium.Resource | string | number;
    /**
     * 自定义的新的中心点位置
     */
    position?: Partial<Center>;
    /**
     * 自定义旋转方向（旋转模型）
     */
    rotation?: Rotation;
    /**
     * 自定义缩放比例
     */
    scale?: number;
    /**
     * 自定义轴方向
     */
    axis?: 'Y_UP_TO_Z_UP' | 'Z_UP_TO_Y_UP' | 'X_UP_TO_Z_UP' | 'Z_UP_TO_X_UP' | 'X_UP_TO_Y_UP' | 'Y_UP_TO_X_UP';
    /**
     * 模型样式
     */
    style?: Record<string, any> | Cesium.Cesium3DTileStyle | ((options: {
        feature: Cesium.Cesium3DTileFeature;
        properties: any;
    }) => Cesium.Color);
    /**
     * 是否贴地，true时自动调用贴地计算，但此属性只适合标准的与地形数据匹配的模型，并不精确，建议通过模型编辑页面调试给具体高度值。
     */
    clampToGround?: boolean;
    /**
     * 标识模型的国内坐标系（用于自动纠偏或加偏）
     */
    chinaCRS?: ChinaCRSValue;
    /**
     * 自定义shader效果
     */
    customShader?: Cesium.CustomShader;
    /**
     * 自定义选中的highlight效果
     */
    highlight?: Omit<HighlightTilesetSchema, 'id'> & {
        /** 触发类型，默认为`click` */
        trigger?: 'click' | 'hover';
        /** 是否禁用高亮效果，默认为false */
        disable?: boolean;
        /** 是否展示多个高亮，不自动清除已经高亮的feature，默认为false */
        multi?: boolean;
        /** 是否高亮模型整体而非单个feature，默认为false - ^[仅当`type`为`full`时适用] */
        all?: boolean;
        /** 可以设置筛选排除一些构件, 排除的构件在filter方法内返回false */
        filter?: (event: PickTargetInfo) => boolean;
    };
    /**
     * 图层透明度， 0~1
     */
    opacity?: number;
    /**
     * 是否允许鼠标穿透拾取
     */
    allowDrillPick?: boolean | ((event: PickTargetInfo) => boolean);
}

/**
 * 将材质对象转为Josn简单对象，用于保存。
 * @param material - 材质对象
 * @param style - 附加到的目标对象
 * @return json简单对象
 */
declare function toJSON(material: Cesium.Material | BaseMaterialProperty, style?: Record<string, any>): Record<string, any>;

/**
 * 第三方token
 */
declare interface Token {
    /**
     * Cesium官方的Ion服务key - {@link https://cesium.com/ion/signin/}
     */
    ion: string;
}

/**
 * 回调函数类型 - ^[类型]
 * @group 功能: 树结构相关
 */
declare type TreeCallbackFn<T = any, U = T> = (...arg: T[]) => U;

/**
 * 对树结构中每个数据进行指定函数的变换，并返回新的树
 * @param treeData - 目标树结构数据
 * @param options - 配置项
 * @param options.children - children属性的映射
 * @param options.conversion - 转换函数
 * @returns 新的树结构
 * @group 功能: 树结构相关
 */
declare function treeMap<T extends Record<string, any>, U = T>(treeData: T[], options: {
    children?: string;
    conversion: TreeCallbackFn<T, U>;
}): U[];

/**
 * 配置项类型 - ^[类型]
 * @group 功能: 树结构相关
 */
declare interface TreeMappingConfig {
    id: string;
    children: string;
    pid: string;
}

/**
 * 树结构数据转成集合
 * @param tree - 目标树结构
 * @param config - 配置项
 * @returns 集合
 * @group 功能: 树结构相关
 * @remarks
 ```ts
 DEFAULT_CONFIG: TreeMappingConfig = {
 children: 'children',
 }
 ```
 */
declare function treeToList<T = any>(tree: any, config?: Partial<TreeMappingConfig>): T[];

export { turf }

declare namespace utils {
    export {
        camera,
        effects_2 as effects,
        layer,
        map,
        material,
        widget,
        StartFlickerOptions,
        FlickerEntity,
        BaseListener,
        BaseEvent,
        BaseClass,
        ParserLatLngPointInput,
        LatLngPoint,
        LatLngArray,
        PopupEventData,
        PopupOptions,
        Popup,
        MouseTooltipOptions,
        MouseTooltip,
        HighlightTilesetSchema,
        HighlightTilesetOptions,
        HighlightTileset,
        loopArrayCallback,
        deepClone,
        createDom,
        createSvg,
        createVideo,
        get,
        parseDom,
        remove,
        empty,
        getStyle,
        hasClass,
        addClass,
        removeClass,
        setClass,
        getClass,
        enterFullscreen,
        exitFullscreen,
        formatNum,
        template,
        guid,
        isGuid,
        shortGuid,
        isShortGuid,
        isDef,
        isUnDef,
        isObject,
        isEmpty,
        isDate,
        isNumber,
        isPromise,
        isString,
        isFunction,
        isBoolean,
        isRegExp,
        isArray,
        isWindow,
        isElement,
        isMap,
        isUrl,
        isDark,
        isImgPath,
        isMergeableObject,
        isSimpleType,
        deepMerge,
        deepMergeAll,
        listToTree,
        treeToList,
        findNode,
        findNodeAll,
        findPath,
        findPathAll,
        filterTree,
        forEachTree,
        treeMap,
        TreeCallbackFn,
        TreeMappingConfig,
        dom2Base64,
        image2Base64,
        getImgBase64,
        mergeImage,
        Dom2Base64Option,
        getColorRampLegend,
        getRampValueColor,
        ColorRamp_2 as ColorRamp
    }
}
export { utils }

/**
 * viewer构造参数
 * @property [animation = true] - 如果设置为 false，则不会创建动画控件。
 * @property [baseLayerPicker = true] - 如果设置为 false，则不会创建基础图层选择器控件。
 * @property [fullscreenButton = true] - 如果设置为 false，则不会创建全屏按钮控件。
 * @property [vrButton = false] - 如果设置为 true，则会创建虚拟现实按钮控件。
 * @property [geocoder = true] - 如果设置为 false，则不会创建地理编码器控件。
 * @property [homeButton = true] - 如果设置为 false，则不会创建主页按钮控件。
 * @property [infoBox = true] - 如果设置为 false，则不会创建信息框控件。
 * @property [sceneModePicker = true] - 如果设置为 false，则不会创建场景模式选择器控件。
 * @property [selectionIndicator = true] - 如果设置为 false，则不会创建选择指示器控件。
 * @property [timeline = true] - 如果设置为 false，则不会创建时间线控件。
 * @property [navigationHelpButton = true] - 如果设置为 false，则不会创建导航帮助按钮。
 * @property [navigationInstructionsInitiallyVisible = true] - 如果为 true，则导航说明应初始时即可见；如果为 false，则直到用户明确点击按钮时才会显示。
 * @property [scene3DOnly = false] - 当为 <code>true</code> 时，每个几何体实例将仅以 3D 形式渲染，以节省 GPU 内存。
 * @property [shouldAnimate = false] - 如果为 <code>true</code>，则时钟将尝试默认前进模拟时间；如果为 <code>false</code>，则不前进。此选项优先于设置 {@link Cesium.Viewer#clockViewModel}。
 * @property [clockViewModel = new ClockViewModel(clock)] - 用于控制当前时间的时钟视图模型。
 * @property [selectedImageryProviderViewModel] - 当前基础影像图层的视图模型，如果未提供，则使用第一个可用的基础图层。此值仅在 baseLayerPicker 设置为 true 时有效。
 * @property [imageryProviderViewModels = createDefaultImageryProviderViewModels()] - 可从基础图层选择器中选择的 ProviderViewModels 数组。此值仅在 baseLayerPicker 设置为 true 时有效。
 * @property [selectedTerrainProviderViewModel] - 当前基础地形图层的视图模型，如果未提供，则使用第一个可用的基础图层。此值仅在 baseLayerPicker 设置为 true 时有效。
 * @property [terrainProviderViewModels = createDefaultTerrainProviderViewModels()] - 可从基础图层选择器中选择的 ProviderViewModels 数组（针对地形图层）。此值仅在 baseLayerPicker 设置为 true 时有效。
 * @property [baseLayer = ImageryLayer.fromWorldImagery()] - 应用到地球的最底部影像图层。如果设置为 <code>false</code>，则不会添加任何影像图层提供器。此值仅在 baseLayerPicker 设置为 false 时有效。
 * @property [terrainProvider = new EllipsoidTerrainProvider()] - 要使用的地形提供器。
 * @property [terrain] - 一个处理异步地形提供器的地形对象。仅当 options.terrainProvider 未定义时可以指定。
 * @property [skyBox] - 用于渲染星星的天空盒。当为 <code>undefined</code> 时，将使用默认的星星。如果设置为 <code>false</code>，则不会添加天空盒、太阳或月亮。
 * @property [skyAtmosphere] - 蓝天以及地球边缘周围的光晕。设置为 <code>false</code> 以关闭它。
 * @property [fullscreenElement = document.body] - 当按下全屏按钮时，要进入全屏模式的元素或元素ID。
 * @property [useDefaultRenderLoop = true] - 如果此小部件应控制渲染循环，则为 true，否则为 false。
 * @property [targetFrameRate] - 在使用默认渲染循环时的目标帧率。
 * @property [showRenderLoopErrors = true] - 如果为 true，则在渲染循环发生错误时，此小部件将自动向用户显示一个包含错误的HTML面板。
 * @property [useBrowserRecommendedResolution = true] - 如果为 true，则以浏览器推荐的分辨率渲染，并忽略 <code>window.devicePixelRatio</code>。
 * @property [automaticallyTrackDataSourceClocks = true] - 如果为 true，则此小部件将自动跟踪新添加的数据源（DataSource）的时钟设置，并在数据源的时钟更改时进行更新。如果希望独立配置时钟，请将此属性设置为 false。
 * @property [contextOptions] - 传递给 {@link Cesium.Scene} 的上下文和 WebGL 创建属性。
 * @property [sceneMode = SceneMode.SCENE3D] - 初始场景模式。默认为三维场景模式。
 * @property [mapProjection = new GeographicProjection()] - 在二维和哥伦布视图模式中要使用的地图投影。默认为地理投影。
 * @property [globe = new Globe(mapProjection.ellipsoid)] - 场景中使用的地球仪。如果设置为 <code>false</code>，则不会添加地球仪，并且默认情况下会隐藏天空大气层。
 * @property [orderIndependentTranslucency = true] - 如果为 true 并且配置支持，则使用顺序无关透明性。这有助于减少透明对象渲染时的排序问题。
 * @property [creditContainer] - 包含 {@link Cesium.CreditDisplay} 的 DOM 元素或元素ID。如果不指定，则版权信息将添加到小部件本身的底部。
 * @property [creditViewport] - 包含由 {@link Cesium.CreditDisplay} 创建的版权弹出窗口的 DOM 元素或元素ID。如果不指定，则弹出窗口将出现在小部件上方。
 * @property [dataSources = new DataSourceCollection()] - 由小部件可视化的数据源集合。如果提供了此参数，则假定其实例由调用者拥有，并且在销毁查看器时不会销毁该实例。这允许您跨多个查看器共享相同的数据源集合。
 * @property [shadows = false] - 确定光源是否投射阴影。设置为 true 以启用阴影，否则为 false。
 * @property [terrainShadows = ShadowMode.RECEIVE_ONLY] - 确定地形是否投射或接收来自光源的阴影。ShadowMode.RECEIVE_ONLY 表示地形仅接收阴影，不投射阴影；其他选项可能包括 ShadowMode.CAST_ONLY（仅投射阴影）和 ShadowMode.CAST_AND_RECEIVE（既投射也接收阴影）。
 * @property [mapMode2D = MapMode2D.INFINITE_SCROLL] - 确定二维地图是否可旋转或是否可以在水平方向上无限滚动。MapMode2D.INFINITE_SCROLL 允许无限滚动，而 MapMode2D.ROTATE 允许旋转但不支持无限滚动。
 * @property [projectionPicker = false] - 如果设置为 true，将创建 ProjectionPicker 小部件，允许用户在不同的地图投影之间切换。
 * @property [blurActiveElementOnCanvasFocus = true] - 如果为 true，则在点击查看器的画布时，当前活动的元素将失去焦点。将此设置为 false 在某些情况下很有用，例如，当点击画布仅用于获取位置或实体数据，而不希望将画布设置为活动元素时。
 * @property [requestRenderMode = false] - 如果为 true，则仅当场景中的更改确定需要时才会渲染帧。启用此模式可以减少应用程序的 CPU/GPU 使用量，并在移动设备上节省电池电量，但要求使用 {@link Cesium.Scene#requestRender} 来显式渲染新帧。在此模式下，在 API 的其他部分对场景进行更改后，在许多情况下都需要这样做。有关更多信息，请参阅 {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/ | 使用显式渲染提高性能}。
 * @property [maximumRenderTimeChange = 0.0] - 当 requestRenderMode 设置为 true 时，此属性定义了在请求渲染之前允许的最大模拟时间变化量。这有助于控制渲染频率，以避免在模拟时间变化较小时频繁渲染，从而提高性能。更多关于如何使用显式渲染来提高性能的信息，请参考 {@link https://cesium.com/blog/2018/01/24/cesium-scene-rendering-performance/ | 使用显式渲染提高性能}。
 * @property [depthPlaneEllipsoidOffset = 0.0] - 此属性用于调整深度平面（DepthPlane），以解决位于椭球体零高程以下的渲染伪影问题。通过调整偏移量，可以改善这些区域的渲染质量。
 * @property [msaaSamples = 1] - 如果提供，此属性控制多重采样抗锯齿（Multisample Antialiasing, MSAA）的采样率。典型的 MSAA 采样率包括每像素 2、4 个样本，有时也使用 8 个样本。更高的 MSAA 采样率可能会以牺牲性能为代价来提高视觉质量。然而，这个值仅适用于支持多重采样渲染目标的 WebGL2 上下文。如果不支持多重采样或未设置此属性，则默认为每像素 1 个样本（即无 MSAA）。
 */
export declare interface ViewerOptions extends Cesium.Viewer.ConstructorOptions {
}

/**
 * 相机视角参数，Center(相机位置)和Extent(要观察的视域范围)都有的情况下，Center优先
 */
declare interface Vision extends Partial<Center>, Partial<Extent>, Partial<Orientation> {
}

/**
 * 墙体: 走马灯围墙材质
 */
declare class WallScrollMaterialProperty extends BaseMaterialProperty {
    /**
     */
    protected _image: any;
    /**
     */
    protected _count: any;
    constructor(options: WallScrollMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): "WallScroll";
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 墙体: 走马灯围墙材质构造器类型
 */
declare interface WallScrollMaterialPropertyOptions {
    /**
     * 背景图片URL。
     */
    image: string;
    /**
     * 背景图片颜色。默认为红色（Cesium.Color.RED）。
     */
    color?: string | Cesium.Color;
    /**
     * 数量。默认为1。
     */
    count?: number;
    /**
     * 速度。值越大，速度越快。默认为5.0。
     */
    speed?: number;
}

/**
 * 面状: 水面效果材质
 */
declare class WaterMaterialProperty extends BaseMaterialProperty {
    baseWaterColor: Cesium.Color;
    blendColor: Cesium.Color;
    specularMap: string;
    normalMap: string;
    frequency: number;
    animationSpeed: number;
    amplitude: number;
    specularIntensity: number;
    fadeFactor: number;
    constructor(options?: WaterMaterialPropertyOptions);
    getType(time?: Cesium.JulianDate): string;
    getValue(time?: Cesium.JulianDate, result?: any): any;
    equals(other?: Cesium.Property): any;
}

/**
 * 面状: 水面效果材质构造器类型
 */
declare interface WaterMaterialPropertyOptions {
    /**
     * 基础颜色，默认为Cesium的深蓝色。
     * 可以是字符串（颜色名称或十六进制）或Cesium.Color对象。
     * @default new Cesium.Color(0.2, 0.3, 0.6, 1.0)
     */
    baseWaterColor?: string | Cesium.Color;
    /**
     * 从水中混合到非水域时使用的rgba颜色对象。
     * 可以是字符串（颜色名称或十六进制）或Cesium.Color对象。
     * @default new Cesium.Color(0.0, 1.0, 0.699, 1.0)
     */
    blendColor?: string | Cesium.Color;
    /**
     * 单一通道纹理，用来指示水域的面积。
     */
    specularMap?: string;
    /**
     * 水正常扰动的法线图。
     */
    normalMap?: string;
    /**
     * 控制波数的数字。
     * @default 100
     */
    frequency?: number;
    /**
     * 控制水的动画速度的数字。
     * @default 0.01
     */
    animationSpeed?: number;
    /**
     * 控制水波振幅的数字。
     * @default 10
     */
    amplitude?: number;
    /**
     * 控制镜面反射强度的数字。
     * @default 0.5
     */
    specularIntensity?: number;
    /**
     * fadeFactor的值。
     * @default 1.0
     */
    fadeFactor?: number;
}

/**
 * 标准无偏坐标（WGS84）  转 百度坐标 (BD09)
 * @param arrdata - 标准无偏坐标（WGS84）坐标数据，示例：[117.220102, 31.834912]
 * @returns 百度坐标 (BD09)坐标数据，示例：[117.232039,31.839177]
 * @group 功能: 坐标转换相关
 */
declare function wgs2bd(arrdata: number[]): number[];

/**
 * 经纬度坐标转换，
 * 标准无偏坐标（WGS84） 转为 国测局坐标 (GCJ02)
 * @param arrdata - 标准无偏坐标（WGS84）坐标数据，示例：[117.220102, 31.834912]
 * @returns 国测局坐标 (GCJ02)坐标数据，示例：[117.225590,31.832916]
 * @group 功能: 坐标转换相关
 */
declare function wgs2gcj(arrdata: number[]): number[];

declare namespace widget {
    export {
        addButton,
        removeButton,
        WidgetButtonOptions
    }
}

/**
 * 按钮小组件构造参数
 */
declare interface WidgetButtonOptions {
    /**
     * 唯一id
     */
    uuid: string;
    /**
     * dom的title属性
     */
    title: string;
    /**
     * 图标， 如: `<svg xmlns="http://www.w3.org/2000/svg" width="28" height="28" viewBox="0 0 24 24"><path d="M19 13H5v-2h14z"/></svg>`
     */
    icon: string;
    /**
     * 点击事件
     */
    onClick?: (earth: Earth) => void;
}

/**
 * wms服务图层类
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const wmsLayer = new KBE3D.layers.WmsLayer({
 id: 'test',
 name: 'test',
 url: 'http://101.201.56.243/geoserver/gtweb/wms',
 layers: 'gtweb:pre24hour',
 srs: KBE3D.enums.CRS.EPSG4326,
 parameters: {
 version: '1.1.0',
 format: 'image/png',
 transparent: true,
 cql_filter: `product_category='MDRMFLD-CMPA3S' and product_element='PRCPV' and geo_height='L88' and coverage_area='CHN' and publish_time='20240924090000' and valid_time='02400-00000'`,
 },
 })
 earth.addLayer(wmsLayer)
 * ```
 */
declare class WmsLayer extends BaseTileLayer {
    /**
     * 支持的事件类型
     */
    static EventType: {
        loadMetadata: "loadMetadata";
        openPopup: "openPopup";
        closePopup: "closePopup";
        destroyPopup: "destroyPopup";
        changePopupPosition: "changePopupPosition";
        showPopup: "showPopup";
        hidePopup: "hidePopup";
        add: "add";
        remove: "remove";
        addLayer: "addLayer";
        removeLayer: "removeLayer";
        show: "show";
        hide: "hide";
        click: "click";
        leftDown: "leftDown";
        leftUp: "leftUp";
        rightClick: "rightClick";
        rightDown: "rightDown";
        rightUp: "rightUp";
        middleClick: "middleClick";
        middleDown: "middleDown";
        middleUp: "middleUp";
        mouseDown: "mouseDown";
        mouseUp: "mouseUp";
        mouseOver: "mouseOver";
        mouseOut: "mouseOut";
    };
    /**
     * 创建用于图层的 ImageryProvider对象
     * @param options -  wms服务图层类构造参数
     * @group 静态方法
     */
    static createImageryProvider(options: WmsLayerOptions): Cesium.WebMapServiceImageryProvider;
    protected _type: LayerTypeKey;
    /** wms服务图层类构造参数 */
    options: WmsLayerOptions;
    /** 图层服务原始配置信息 */
    capabilities?: XMLDocument;
    /**
     * @param options - wms服务图层类构造参数
     */
    constructor(options: WmsLayerOptions);
    protected _createImageryProvider(options: WmsLayerOptions): Cesium.ImageryProvider;
    protected _addHooks(): Promise<void>;
    /**
     * 根据服务配置信息，加一些处理
     */
    protected _initByMetaData(data: XMLDocument): void;
    /**
     * 读取子节点
     */
    protected _readChildNode(node?: XMLDocument | Element, tagName?: string): Element | null;
    /**
     * 读取子节点数据
     */
    protected _readChildNodeVal(node?: XMLDocument | Element, tagName?: string): any;
    /**
     * 读取图层服务原始配置信息
     */
    getMetadata(): Promise<XMLDocument | undefined>;
}

/**
 * wms服务图层类构造参数类型
 * @property url - WMS服务的URL。该URL支持与{@link Cesium.UrlTemplateImageryProvider}相同的关键字。
 * @property layers - 要包含的层，用逗号分隔。
 * @property [getFeatureInfoParameters = WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters] - 在GetFeatureInfo URL中传递给WMS服务器的附加参数。
 * @property [enablePickFeatures = true] - 如果为true，则{@link Cesium.WebMapServiceImageryProvider#pickFeatures}将调用WMS服务器上的GetFeatureInfo操作，并返回响应中包含的特性。如果为false，则{@link Cesium.WebMapServiceImageryProvider#pickFeatures}将立即返回undefined（表示无可选特性），而不与服务器通信。如果您知道您的WMS服务器不支持GetFeatureInfo，或者不希望此提供程序的特性可选，请将此属性设置为false。请注意，这可以通过修改WebMapServiceImageryProvider#enablePickFeatures属性来动态覆盖。
 * @property [getFeatureInfoFormats = WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats] - 尝试进行WMS GetFeatureInfo请求的格式。
 * @property [rectangle = Rectangle.MAX_VALUE] - 层的矩形范围边界。这里Rectangle.MAX_VALUE可能表示一个非常大的矩形，覆盖整个可能的空间或屏幕，但通常应根据WMS服务提供的实际层范围来设置此值。
 * @property [tilingScheme = new GeographicTilingScheme()] - 用于将世界划分为瓦片的瓦片方案。如果不指定，则默认使用地理瓦片方案（GeographicTilingScheme）。
 * @property [ellipsoid] - 椭球体。如果指定了瓦片方案（tilingScheme），则忽略此参数，并使用瓦片方案的椭球体。如果两者都未指定，则使用WGS84椭球体。
 * @property [tileWidth = 256] - 每个瓦片的宽度（以像素为单位）。
 * @property [tileHeight = 256] - 每个瓦片的高度（以像素为单位）。
 * @property [minimumLevel = 0] - 影像提供程序支持的最小细节层次。请注意，在指定此参数时，要确保最小层次上的瓦片数量较少，如四个或更少。较大的数量可能会导致渲染问题。
 * @property [maximumLevel] - 影像提供程序支持的最大细节层次，如果没有限制则为undefined。如果不指定，则没有限制。
 * @property [crs] - CRS规范，用于WMS规范>=1.3.0。
 * @property [srs] - SRS规范，用于WMS规范1.1.0或1.1.1。
 * @property [credit] - 数据源的归属信息，会显示在画布上。
 * @property [subdomains = 'abc'] - 用于URL模板中<code>{s}</code>占位符的子域。如果此参数是单个字符串，则字符串中的每个字符都是一个子域。如果它是一个数组，则数组中的每个元素都是一个子域。
 * @property [clock] - Clock实例，用于确定时间维度的值。当指定了times参数时，此参数是必需的。
 * @property [times] - TimeIntervalCollection，其数据属性是一个包含时间动态维度及其值的对象。
 * @property [getFeatureInfoUrl] - WMS服务的getFeatureInfo URL。如果未定义此属性，则使用url属性的值。
 */
declare interface WmsLayerOptions extends BaseTileLayerOptions, Omit<Cesium.WebMapServiceImageryProvider.ConstructorOptions, 'crs' | 'rectangle'> {
    /**
     * 是否通过服务本身的GetCapabilities来读取一些参数，减少options配置项，默认为`true`
     */
    getCapabilities?: boolean;
    /**
     * 在GetMap URL中传递给WMS服务器的其他参数
     * @example
     * 默认值：
     {
     service: "WMS",
     version: "1.1.1",
     request: "GetMap",
     format: "image/jpeg",
     }
     */
    parameters?: {
        /** 服务类型 */
        service?: string;
        /** 服务版本 */
        version?: string;
        /** 请求方法 */
        request?: string;
        /** 样式 */
        styles?: string;
        format?: string;
        /** 筛选服务数据的SQL语句 */
        cql_filter?: string;
        /** 是否透明 */
        transparent?: boolean;
    };
}

/**
 * wmts服务图层类
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const wmtsLayer = new KBE3D.layers.WmtsLayer({
 id: 'test',
 name: 'test',
 url: 'http://175.27.229.68:8081/geoserver/cc_workspace/gwc/service/wmts',
 layer: 'tianzhushan-new_215',
 style: '',
 format: 'image/png',
 tilingScheme: new Cesium.GeographicTilingScheme(),
 tileMatrixSetID: 'EPSG:900913',
 flyTo: true,
 // 自定义默认相机视角
 // homeVision: {
 //   alt: 11593.9,
 //   heading: 360,
 //   lat: 31.053232,
 //   lng: 118.101674,
 //   pitch: -89.9,
 //   roll: 0,
 // },
 })
 earth.addLayer(wmtsLayer)
 * ```
 */
declare class WmtsLayer extends BaseTileLayer {
    /**
     * 支持的事件类型
     */
    static EventType: {
        loadMetadata: "loadMetadata";
        openPopup: "openPopup";
        closePopup: "closePopup";
        destroyPopup: "destroyPopup";
        changePopupPosition: "changePopupPosition";
        showPopup: "showPopup";
        hidePopup: "hidePopup";
        add: "add";
        remove: "remove";
        addLayer: "addLayer";
        removeLayer: "removeLayer";
        show: "show";
        hide: "hide";
        click: "click";
        leftDown: "leftDown";
        leftUp: "leftUp";
        rightClick: "rightClick";
        rightDown: "rightDown";
        rightUp: "rightUp";
        middleClick: "middleClick";
        middleDown: "middleDown";
        middleUp: "middleUp";
        mouseDown: "mouseDown";
        mouseUp: "mouseUp";
        mouseOver: "mouseOver";
        mouseOut: "mouseOut";
    };
    /**
     * 创建用于图层的 ImageryProvider对象
     * @param options -  wmts服务图层类构造参数
     * @group 静态方法
     */
    static createImageryProvider(options: WmtsLayerOptions): Cesium.WebMapTileServiceImageryProvider;
    protected _type: LayerTypeKey;
    /** wmts服务图层类构造参数 */
    options: WmtsLayerOptions;
    /** 图层服务原始配置信息 */
    capabilities?: XMLDocument;
    /**
     * @param options - wmts服务图层类构造参数
     */
    constructor(options: WmtsLayerOptions);
    protected _createImageryProvider(options: WmtsLayerOptions): Cesium.ImageryProvider;
    protected _addHooks(): Promise<void>;
    /**
     * 根据服务配置信息，加一些处理
     */
    protected _initByMetaData(data: XMLDocument): void;
    /**
     * 读取子节点
     */
    protected _readChildNode(node?: XMLDocument | Element, tagName?: string): Element | undefined;
    /**
     * 读取子节点数据
     */
    protected _readChildNodeVal(node?: XMLDocument | Element, tagName?: string): any;
    /**
     * 读取图层服务原始配置信息
     */
    getMetadata(): Promise<XMLDocument | undefined>;
}

/**
 * wmts服务图层类构造参数类型
 * @property url - WMTS GetTile操作的基URL（对于KVP编码的请求）或瓦片URL模板（对于RESTful请求）。瓦片URL模板应包含以下变量：{style}、{TileMatrixSet}、{TileMatrix}、{TileRow}、{TileCol}。如果实际值是硬编码的或服务器不要求，则前两个变量是可选的。{s}关键字可用于指定子域。
 * @property [format = 'image/jpeg'] - 从服务器检索图像时要使用的MIME类型。默认为'image/jpeg'。
 * @property layer - WMTS请求中的图层名称。
 * @property style - WMTS请求中的样式名称。
 * @property tileMatrixSetID - 用于WMTS请求的TileMatrixSet的标识符。
 * @property [tileMatrixLabels] - 用于WMTS请求的TileMatrix中的标识符列表，每个TileMatrix级别一个。
 * @property [clock] - Clock实例，用于确定时间维度的值。当指定了times属性时，此属性是必需的。
 * @property [times] - TimeIntervalCollection，其data属性是一个包含时间动态维度及其值的对象。
 * @property [dimensions] - 一个包含静态维度及其值的对象。这些维度将被添加到WMTS请求中。
 * @property [tileWidth = 256] - 瓦片的宽度（以像素为单位）。默认为256。
 * @property [tileHeight = 256] - 瓦片的高度（以像素为单位）。默认为256。
 * @property [tilingScheme] - 对应的瓦片组织方案，与TileMatrixSet中的瓦片组织相匹配。
 * @property [rectangle = Rectangle.MAX_VALUE] - 图层覆盖的矩形区域，默认为Rectangle.MAX_VALUE，即最大矩形范围边界。
 * @property [minimumLevel = 0] - 图像提供者支持的最小细节级别，默认为0。
 * @property [maximumLevel] - 图像提供者支持的最大细节级别，如果没有限制则为undefined。
 * @property [ellipsoid] - 椭球体。如果未指定，则使用WGS84椭球体。
 * @property [credit] - 数据源的版权信息，将显示在画布上。
 * @property [subdomains = 'abc'] - 用于URL模板中<code>{s}</code>占位符的子域。如果该参数是单个字符串，则字符串中的每个字符都是一个子域。如果该参数是数组，则数组中的每个元素都是一个子域。
 */
declare interface WmtsLayerOptions extends BaseTileLayerOptions, Omit<Cesium.WebMapTileServiceImageryProvider.ConstructorOptions, 'rectangle'> {
    /**
     * 是否通过服务本身的GetCapabilities来读取一些参数，减少options配置项
     */
    getCapabilities?: boolean;
}

/**
 * xyz标准金字塔瓦片服务图层类
 * @example
 * ```ts
 // 创建earth
 const earth = new KBE3D.Earth('cesiumContainer', {
 fullscreenElement: 'cesiumContainer',
 })
 const xyzLayer = new KBE3D.layers.XyzLayer({
 id: 'test',
 name: 'test',
 url: 'http://t3.tianditu.gov.cn/img_c/wmts?service=WMTS&version=1.0.0&request=GetTile&tilematrix={z}&layer=img&style=default&tilerow={y}&tilecol={x}&tilematrixset=c&format=tiles&tk=6c99c7793f41fccc4bd595b03711913e',
 flyTo: true,
 crs: KBE3D.enums.CRS.EPSG4490, // 标识坐标系
 })
 earth.addLayer(xyzLayer)
 * ```
 */
declare class XyzLayer extends BaseTileLayer {
    /**
     * 创建用于图层的 ImageryProvider对象
     * @param options -  xyz图层类构造参数
     * @group 静态方法
     */
    static createImageryProvider(options: XyzLayerOptions): Cesium.UrlTemplateImageryProvider;
    protected _type: LayerTypeKey;
    /** xyz标准金字塔瓦片服务图层类构造参数 */
    options: XyzLayerOptions;
    /**
     * @param options - xyz图层类构造参数
     */
    constructor(options: XyzLayerOptions);
    protected _createImageryProvider(options: XyzLayerOptions): Cesium.ImageryProvider;
}

/**
 * xyz标准金字塔瓦片服务图层类构造参数类型
 * @property url - 用于请求瓦片的URL模板。它包含以下关键字：
 * <ul>
 * <li><code>{z}</code>：瓦片在瓦片方案中的层级。层级0是四叉树金字塔的根。</li>
 * <li><code>{x}</code>：瓦片在瓦片方案中的X坐标，其中0表示最西侧的瓦片。</li>
 * <li><code>{y}</code>：瓦片在瓦片方案中的Y坐标，其中0表示最北侧的瓦片。</li>
 * <li><code>{s}</code>：可用的子域之一，用于克服浏览器对每个主机同时请求数量的限制。</li>
 * <li><code>{reverseX}</code>：瓦片在瓦片方案中的X坐标，但在这里0表示最东侧的瓦片。</li>
 * <li><code>{reverseY}</code>：瓦片在瓦片方案中的Y坐标，但在这里0表示最南侧的瓦片。</li>
 * <li><code>{reverseZ}</code>：瓦片在瓦片方案中的层级，但在这里层级0表示四叉树金字塔的最大层级。为了使用reverseZ，必须定义maximumLevel。</li>
 * <li><code>{westDegrees}</code>：瓦片在地理坐标系中的西边缘的度数。</li>
 * <li><code>{southDegrees}</code>：瓦片在地理坐标系中的南边缘的度数。</li>
 * <li><code>{eastDegrees}</code>：瓦片在地理坐标系中的东边缘的度数。</li>
 * <li><code>{northDegrees}</code>：瓦片在地理坐标系中的北边缘的度数。</li>
 * <li><code>{westProjected}</code>：瓦片在瓦片方案的投影坐标系中的西边缘。</li>
 * <li><code>{southProjected}</code>：瓦片在瓦片方案的投影坐标系中的南边缘。</li>
 * <li><code>{eastProjected}</code>：瓦片在瓦片方案的投影坐标系中的东边缘。</li>
 * <li><code>{northProjected}</code>：瓦片在瓦片方案的投影坐标系中的北边缘。</li>
 * <li><code>{width}</code>：每个瓦片的像素宽度。</li> <li><code>{height}</code>：每个瓦片的像素高度。</li>
 * </ul>
 * @property [pickFeaturesUrl] - 用于选择要素的URL模板。如果未指定此属性，则 {@link Cesium.UrlTemplateImageryProvider#pickFeatures} 将立即返回未定义（undefined），表示未选择任何要素。该URL模板支持<code>url</code>参数支持的所有关键字，并加上以下关键字：
 * <ul>
 * <li><code>{i}</code>：所选位置的像素列（水平坐标），其中最西侧的像素为0。</li>
 * <li><code>{j}</code>：所选位置的像素行（垂直坐标），其中最北侧的像素为0。</li>
 * <li><code>{reverseI}</code>：所选位置的像素列（水平坐标），但在这里最东侧的像素为0。</li>
 * <li><code>{reverseJ}</code>：所选位置的像素行（垂直坐标），但在这里最南侧的像素为0。</li>
 * <li><code>{longitudeDegrees}</code>：所选位置的经度（度）。</li>
 * <li><code>{latitudeDegrees}</code>：所选位置的纬度（度）。</li>
 * <li><code>{longitudeProjected}</code>：所选位置在瓦片方案的投影坐标系中的经度。</li>
 * <li><code>{latitudeProjected}</code>：所选位置在瓦片方案的投影坐标系中的纬度。</li>
 * <li><code>{format}</code>：获取要素信息的格式，如 {@link Cesium.GetFeatureInfoFormat} 中所指定。</li>
 * </ul>
 * @property [urlSchemeZeroPadding] - 获取每个瓦片坐标的URL方案零填充。格式是'000'，其中每个坐标将在左侧用零填充以匹配传递的零字符串的宽度。
 * 例如，设置：urlSchemeZeroPadding: { '{x}': '0000'}，将导致在生成的URL中，'x'值为12时，对于{x}将返回字符串'0012'。
 * 如果传递的对象包含以下关键字：
 * <ul>
 * <li> <code>{z}</code>：瓦片方案中层级的零填充。</li>
 * <li> <code>{x}</code>：瓦片方案中X坐标的零填充。</li>
 * <li> <code>{y}</code>：瓦片方案中Y坐标的零填充。</li>
 * <li> <code>{reverseX}</code>：瓦片方案中反向X坐标的零填充（某些瓦片系统可能使用）。</li>
 * <li> <code>{reverseY}</code>：瓦片方案中反向Y坐标的零填充（某些瓦片系统可能使用）。</li>
 * <li> <code>{reverseZ}</code>：瓦片方案中反向Z坐标的零填充（较少见，因为瓦片系统通常只处理二维或三维中的层级和XY坐标）。</li>
 * </ul>
 * @property [subdomains = 'abc'] - 用于URL模板中<code>{s}</code>占位符的子域。如果此参数是单个字符串，则字符串中的每个字符都是一个子域。如果它是一个数组，则数组中的每个元素都是一个子域。
 * @property [credit = ''] - 数据源的版权信息，将显示在画布上。
 * @property [minimumLevel = 0] - 影像提供者支持的最小细节级别。在指定此参数时，请注意最小级别上的瓦片数量应该很小，如四个或更少。较大的数量可能会导致渲染问题。
 * @property [maximumLevel] - 影像提供者支持的最大细节级别，如果没有限制则为undefined。
 * @property [rectangle = Rectangle.MAX_VALUE] - 图像覆盖的矩形区域，以弧度为单位。
 * @property [tilingScheme = WebMercatorTilingScheme] - 指定如何将椭球面分割成瓦片的瓦片方案。如果未提供此参数，则使用{@link Cesium.WebMercatorTilingScheme}。
 * @property [ellipsoid] - 椭球体。如果指定了tilingScheme，则忽略此参数并使用瓦片方案的椭球体。如果两者都未指定，则使用WGS84椭球体。
 * @property [tileWidth = 256] - 图像瓦片的像素宽度。
 * @property [tileHeight = 256] - 图像瓦片的像素高度。
 * @property [hasAlphaChannel = true] - 如果此影像提供者提供的图像包含alpha通道，则为true；否则为false。如果此属性为false，则将忽略任何存在的alpha通道。如果此属性为true，则将任何没有alpha通道的图像视为其alpha值在整个图像上都为1.0。当此属性为false时，可能会减少内存使用量和纹理上传时间。
 * @property [getFeatureInfoFormats] - 当调用{@link Cesium.UrlTemplateImageryProvider#pickFeatures}以在特定位置获取要素信息时，应使用的格式。如果未指定此参数，则禁用要素拾取。
 * @property [enablePickFeatures = true] - 如果为true，则{@link Cesium.UrlTemplateImageryProvider#pickFeatures}将请求<code>pickFeaturesUrl</code>并尝试解释响应中包含的要素。如果为false，则{@link Cesium.UrlTemplateImageryProvider#pickFeatures}将立即返回undefined（表示没有可拾取的要素），而不会与服务器通信。如果你知道你的数据源不支持拾取要素，或者不希望此提供者的要素被拾取，请将此属性设置为false。请注意，这可以通过修改{@link Cesium.UriTemplateImageryProvider#enablePickFeatures}属性来动态覆盖。
 * @property [tileDiscardPolicy] - 根据某些标准丢弃瓦片图像的策略。
 * @property [customTags] - 允许在URL模板中替换自定义关键字。该对象必须以字符串作为键，以函数作为值。这些函数将在请求URL之前被调用，并允许根据需要进行动态替换。
 */
declare interface XyzLayerOptions extends BaseTileLayerOptions, Omit<Cesium.UrlTemplateImageryProvider.ConstructorOptions, 'rectangle'> {
}

/**
 * 放大地图
 * @param viewer - Cesium.Viewer实例
 * @param relativeAmount - 相对量
 * @returns 是否有移动位置
 */
declare function zoomIn(viewer: Cesium.Viewer, relativeAmount?: number): boolean;

/**
 * 缩小地图
 * @param viewer - Cesium.Viewer实例
 * @param relativeAmount - 相对量
 * @returns 是否有移动位置
 */
declare function zoomOut(viewer: Cesium.Viewer, relativeAmount?: number): boolean;

export { }
