import { AnimationMixer, Box3, BoxGeometry, BufferGeometry, CameraHelper, CanvasTexture, Color, DataTexture, DepthTexture, EventDispatcher, Group, Matrix3, Matrix4, Mesh, MeshBasicMaterial, Object3D, OrthographicCamera, PlaneGeometry, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from 'three';
import { FullScreenQuad, Pass } from 'three/examples/jsm/postprocessing/Pass';
import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass';
import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass';

declare class EventThrottle {
	restart(): void;
	putEvent(event: any, trigger: any): void;
	triggerEvents(callback: any): Promise<void>;
	get isEmpty(): boolean;
	get isBusy(): boolean;
}
declare class FlowEvent {
	isFlowEvent: boolean;
	execute(): void;
}
declare class MultipleToggleEvent extends FlowEvent {
	constructor(callbacks: any, startIndex?: number);
}
/**
 * 引擎事件系统。<br/>
 * 该类会随{@link Engine}的初始化自动实例化，不需要开发者手动执行初始化，通过`engine.event`访问。<br/>
 * 该类负责处理引擎中的事件调度和触发逻辑。开发者一般不需要直接操作该类，而是通过`object.addEventListener/object.removeEventListener`对物体进行事件绑定和解绑。
 *
 * @category Internal
 * @example
 * ```javascript
 * engine.map.addEventListener('click', e => {
 *     console.log(e);
 * });
 * engine.map.removeEventListener('click', e => {
 *     console.log(e);
 * });
 * const mesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshBasicMaterial({color: 0x00ff00}));
 * engine.add(mesh);
 * mesh.addEventListener('click', e => {
 *     console.log(e);
 * });
 * ```
 */
export class EngineEvent {
	static EVENT_NAME_CLICK: string;
	static EVENT_NAME_DOUBLE_CLICK: string;
	static EVENT_NAME_RIGHT_CLICK: string;
	static EVENT_NAME_RIGHT_DOUBLE_CLICK: string;
	static EVENT_NAME_MOUSE_MOVE: string;
	static EVENT_NAME_MOUSE_ENTER: string;
	static EVENT_NAME_MOUSE_LEAVE: string;
	static EVENT_NAME_POINTER_DOWN: string;
	static EVENT_NAME_POINTER_UP: string;
	/**
	 * @param {Engine} engine
	 */
	constructor(engine: Engine);
	beginFrame(): void;
	endFrame(): void;
	/**
	 * 创建一个多事件切换事件。
	 * @param {Function[]} callbacks 回调函数数组
	 * @param {number} startIndex 开始索引
	 * @returns {MultipleToggleEvent}
	 * @example
	 * ```javascript
	 *  object.addEventListener('click', engine.event.createMultipleToggleEvent([() => {
	 *      console.log('111');
	 *   }, () => {
	 *      console.log('222');
	*  }, () => {
	 *      console.log('333');
	*  }]));
	 * ```
	 */
	createMultipleToggleEvent(callbacks: Function[], startIndex?: number): MultipleToggleEvent;
	dispose(): void;
}
/**
 * 地图管理器，主要负责地图视野控制相关功能<br/>
 * 该类会随{@link Engine}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.map`访问
 *
 * @category Internal
 * @example
 * ```javascript
 * engine.map.setCenter(center);
 * engine.map.setZoom(14);
 * ```
 */
export class EngineMap extends EventDispatcher<any> {
	/**
	 * @param {Engine} engine 引擎实例
	 * @param {object} options 参数选项，默认为空对象
	 * @param {TileProvider} options.provider 初始状态的底图Provider，该Provider决定初始化时显示什么样的地图。当不设置时，默认初始化百度矢量地图。
	 * 初始化时，引擎默认根据`provider`自动创建一层底图，当需要进行复杂设置（如加载地形、实现多底图层叠等）时，可设置为`null`禁用初始化行为，通过{@link MapView}稍后设置。
	 * @param {string} options.projection 目标投影。默认为EPSG:3857,即Web墨卡托投影。
	 * 可选投影包括：
	 * - `EPSG:4326`：WGS84坐标系，经纬度形式。
	 * - `EPSG:3857`：Web墨卡托投影，单位为米。别名包括`EPSG:900913`。
	 * - `EPSG:4978`：ECEF坐标系，单位为米。别名包括`ECEF`、`GLOBE`。
	 * @param {number[]|Vector2} options.center 初始视野中心点，经纬度形式。
	 * @param {number} options.heading 初始视野旋转角度，以正北向为起始，逆时针方向递增。单位为角度。
	 * @param {number} options.pitch 初始视野俯仰角，俯视为0，平时地平线为90。单位为角度。
	 * @param {number} options.range 初始视野相机相对屏幕中心点对应的地面坐标的距离。单位为米。
	 */
	constructor(engine: Engine, options?: {
		provider: TileProvider;
		projection: string;
		center: number[] | Vector2;
		heading: number;
		pitch: number;
		range: number;
	});
	isGlobe: boolean;
	/**
	 * 设置地图中心点
	 * @param {Array<number>} center 中心点坐标
	 */
	setCenter(center: Array<number>): void;
	/**
	 * 设置地图缩放级别
	 * @param {number} zoom 缩放级别
	 */
	setZoom(zoom: number): void;
	/**
	 * 设置地图选转角度
	 * @param {number} heading 选转角度
	 */
	setHeading(heading: number): void;
	/**
	 * 设置地图倾斜角度
	 * @param {number} pitch 倾斜角度
	 */
	setPitch(pitch: number): void;
	/**
	 * 设置地图视野距离地面的距离
	 * @param {number} range 距离
	 */
	setRange(range: number): void;
	/**
	 * 设置地图可拖动视野区域
	 * @param {Array} bounds 区域的坐标，左下、右上的做标数组[sw, ne]
	 */
	setBounds(bounds: any[]): void;
	/**
	 * 设置3d地图最远视距
	 * @param {number} range 距离
	 */
	setMaxRange(range: number): void;
	/**
	 * 设置3d地图最近视距
	 * @param {number} range 距离
	 */
	setMinRange(range: number): void;
	/**
	 * 设置地图视野
	 * @param {Array | Vector3} target 目标视野中心点, 经纬度和海拔高度
	 * @param {Object} offset 视野角度，包括 heading、pitch，其中3d支持range、2d支持zoom
	 * @param {number} offset.heading 视野旋转角度，以正北向为起始，逆时针方向递增。单位为角度。
	 * @param {number} offset.pitch 视野俯仰角，俯视为0，平时地平线为90。单位为角度。
	 * @param {number} offset.range 视野距离地面的距离。单位为米。
	 */
	lookAt(target: any[] | Vector3, offset?: {
		heading: number;
		pitch: number;
		range: number;
	}): void;
	/**
	 * 获取地图当前中心点
	 * @returns {number[]}
	 */
	getCenter(): number[];
	/**
	 * 获取地图当前视线方向距离地面的距离
	 * @returns {number}
	 */
	getRange(): number;
	/**
	 * 获取地图当前旋转角度
	 * @returns {number}
	 */
	getHeading(): number;
	/**
	 * 视野通过动画过渡的方式飞到目标位置
	 * @param {Array | Vector3} target 目标视野中心点
	 * @param {Object} options 目标视野与动画参数
	 * @param {number} options.heading 视野旋转角度，以正北向为起始，逆时针方向递增。单位为角度。
	 * @param {number} options.pitch 视野俯仰角，俯视为0，平时地平线为90。单位为角度。
	 * @param {number} options.range 视野距离地面的距离。单位为米。
	 * @param {number} options.duration 动画持续时间。单位为毫秒。
	 * @param {Function} options.complete 动画完成回调。
	 * @param {Function} options.cancel 动画取消回调。
	 */
	flyTo(target: any[] | Vector3, options?: {
		heading: number;
		pitch: number;
		range: number;
		duration: number;
		complete: Function;
		cancel: Function;
	}): any;
	/**
	 * 获取地图当前倾斜角度
	 * @returns {number}
	 */
	getPitch(): number;
	/**
	 * 获取地图当前中心点的投影坐标
	 * @returns {number[]}
	 */
	getProjectionCenter(): number[];
	/**
	 * 获取地图当前可视范围边界坐标，返回Box3对象，坐标为投影坐标格式
	 * @returns {Box3}
	 */
	getBounds(): Box3;
	getProjectionBounds(): any;
	/**
	 * 获取地图当前容器的长度和宽度
	 * @returns {Vector2}
	 */
	getResolution(): Vector2;
	/**
	 * 按照当前投影方式，将输入坐标转为投影坐标
	 * @param {Array<number>} input 输入坐标
	 * @param {Array<number>} output 输出坐标
	 * @returns {number[]}
	 */
	projectArrayCoordinate(input: Array<number>, output: Array<number>): number[];
	/**
	 * 按照当前投影方式，将输入坐标转为地理坐标
	 * @param {Array<number>} input
	 * @param {Array<number>} output
	 * @returns {number[]}
	 */
	unprojectArrayCoordinate(input: Array<number>, output: Array<number>): number[];
	/**
	 * 将地理坐标转换为投影坐标
	 * @param {Vector3} input
	 * @param {Vector3} output
	 * @returns {Vector3}
	 */
	projectCoordinate(input: Vector3, output: Vector3): Vector3;
	/**
	 * 将投影坐标转换为地理坐标
	 * @param {Vector3} input
	 * @param {Vector3} output
	 * @returns {Vector3}
	 */
	unprojectCoordinate(input: Vector3, output: Vector3): Vector3;
	/**
	 * 转换坐标数组
	 * @param {*} coordinates
	 * @returns {number[]}
	 */
	projectArrayCoordinates(coordinates: any): number[];
	/**
	 * 视野推进放大
	 */
	zoomIn(): void;
	/**
	 * 视野拉远缩小
	 */
	zoomOut(): void;
	/**
	 * 将地图缩放至object范围
	 * @param {Object3D} object
	 * @param {Object} options
	 * @param {number} options.range 视野距离地面的距离。单位为米。
	 */
	zoomTo(object: Object3D, options?: {
		range: number;
	}): void;
	/**
	 * 获取地图当前视图高度
	 * @returns {number}
	 */
	getViewHeight(): number;
	/**
	 * 获取地图当前相机位置,经纬度坐标和高度
	 * @param {Object3D} target
	 * @returns {Vector3}
	 */
	getCameraLocation(target: Object3D): Vector3;
	/**
	 * 根据传入的坐标数组，设置地图视野
	 * @param {Array} points 坐标数组
	 * @param {Object} options 偏移参数
	 * @param {number} options.range 视野距离地面的距离。单位为米。
	 */
	setViewport(points: any[], options?: {
		range: number;
	}): void;
	set onResolutionChanged(value: any);
	get projectionName(): any;
	get map(): any;
	get mapType(): string;
	get container(): HTMLElement;
	set fov(fov: any);
	/**
	 * 获取地图视野开角
	 */
	get fov(): any;
	/**
	 * 获取地图近裁面距离
	 */
	get near(): any;
	/**
	 * 获取地图远裁面距离
	 */
	get far(): any;
	set projection(value: any);
	/**
	 * 获取投影方式
	 */
	get projection(): any;
	/**
	 * 获取初始化时创建的默认地图视图
	 */
	get mapView(): any;
	get coordType(): any;
}
declare class TimeStatsItem {
	constructor(name: any);
	end(time: any): void;
	add(value: any): void;
	get total(): number;
	get count(): number;
	get average(): number;
	get lastValue(): number;
	get name(): any;
	get beginTime(): number;
}
/**
 * 渲染统计类，用于统计渲染时间<br/>
 * 该类会随{@link EngineRendering}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.rendering.stats`访问<br/>
 * 该类会统计引擎内部各个阶段的时间，并提供打印方法，供开发者调试<br/>
 *
 * @category Internal
 * @example
 * ```javascript
 * console.log(engine.rendering.stats.printString());
 * ```
 */
declare class Stats {
	removeTimeStatsItem(name: any): void;
	beginTimeStatsItem(name: any, time: any): void;
	endTimeStatsItem(name: any, time: any): void;
	addTimeStatsItemValue(name: any, value: any): void;
	/**
	 * 获取排序后的时间统计项
	 * @returns {TimeStatsItem[]} 排序后的时间统计项
	 */
	getSortedTimeStatsItems(): TimeStatsItem[];
	/**
	 * 打印时间统计项
	 * @returns {string} 时间统计项
	 */
	printString(): string;
}
/**
 * 场景拾取，用于拾取场景中的物体和坐标<br/>
 * 需要了解有三种坐标系背景：
 * - 1. pixel 屏幕像素坐标，左上角为原点，x轴向右，y轴向下，单位为像素
 * - 2. ndc 归一化设备坐标系，以中心为原点，x轴向右，y轴向上，xy范围[-1, 1]
 * - 3. readPixel 左下角为原点，x轴向右，y轴向上，单位为像素，调用 depthPicking.pickDepth 时注意转换成该坐标系
 *
 * @category Internal
 */
export class Picking {
	static PICK_INTERSECTION_TYPE_ALL: number;
	static PICK_INTERSECTION_TYPE_VISIBLE: number;
	static PICK_INTERSECTION_TYPE_EVENT: number;
	constructor(rendering: any);
	init(): void;
	dispose(): void;
	beginFrame(): void;
	endFrame(): void;
	/**
	 * 获取世界坐标，优先获取场景物体的世界坐标，若未找到则获取地图上的海平面交点
	 * @param {*} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
	 * @returns 返回对应的世界坐标
	 */
	pickWorldPosition(pixel: any): Promise<Vector3>;
	/**
	 * 从归一化设备坐标(NDC)中选取世界坐标
	 * @param {Vector2} ndc 归一化设备坐标(NDC)
	 * @returns 返回对应的世界坐标
	 */
	pickWorldPositionFromNdc(ndc: Vector2): Promise<Vector3>;
	/**
	 * 拾取场景物体像素点的世界坐标，每帧缓存，同屏幕位置只计算一次
	 * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
	 * @returns {Vector3} 拾取坐标
	 */
	pickSceneWorldPosition(pixel: Vector2): Vector3;
	/**
	 * 从归一化设备坐标(NDC)中选取世界坐标
	 * @param {Vector2} ndc 归一化设备坐标(NDC)
	 * @returns 返回对应的世界坐标
	 */
	pickSceneWorldPositionFromNdc(ndc: Vector2): Promise<Vector3>;
	/**
	 * 拾取地形交点
	 * @param {Ray} ray 射线
	 * @returns {Vector3} 交点坐标
	 */
	pickTerrainWorldPosition(ray: Ray): Vector3;
	pickSeaLevelWorldPositionFromNdc(ndc: any): Vector3;
	/**
	 * 拾取海平面交点
	 * @param {Vector2} pixel 屏幕像素坐标，左上角为原点，向右向下为正方向
	 * @returns {Vector3} 交点坐标
	 */
	pickSeaLevelWorldPosition(pixel: Vector2): Vector3;
	/**
	 * @param {boolean} value 是否使用深度拾取
	 */
	set useDepthPicking(value: boolean);
	/**
	 * 获取是否使用深度拾取
	 * 使用深度图拾取世界坐标，性能表现受GPU、屏幕分辨率影响。
	 * 小分辨率，大场景的情况下性能表现较好。
	 * 注意该api是同步的，主线程发起请求后会等GPU处理完返回通信后才响应，所以性能差的时候会导致IO阻塞。
	 * @returns {boolean} 是否使用深度拾取
	 */
	get useDepthPicking(): boolean;
}
declare class ThreeObject extends Object3D<import("three").Object3DEventMap> {
	constructor(options: any);
	defineGeometryUpdateProxyProperties(properties?: any[]): void;
	raycast(raycaster: any, intersects: any): void;
}
declare class GeoObject extends ThreeObject {
	/**
	 * @readonly
	 * 类型为GeoObject的标识
	 */
	readonly isGeoObject: true;
	/** @protected */ protected engine: any;
	_attributeRenameMap: {};
	/** @protected */
	set parameters(value: any);
	/**
	 * object的传入参数
	 */
	get parameters(): any;
	/**
	 * 设置object的数据源
	 * @param {DataSource} dataSource 数据源
	 */
	set dataSource(dataSource: DataSource);
	/** object连接的数据源[[DataSource]]类 */
	get dataSource(): DataSource;
	_proxyDataSource: any;
	_proxyDataSourceNeedsUpdate: boolean;
	/**
	 * 设置object是否在下一帧更新
	 * @param {boolean} value 设置为true，则下一帧渲染前更新该object
	 */
	set needsUpdate(value: boolean);
	/**
	 * 是否需要更新
	 */
	get needsUpdate(): boolean;
	set zooms(value: any[]);
	get zooms(): any[];
	get inZoomsRange(): boolean;
	/**
	 * 添加属性重命名
	 * @param {string} key 原始属性名，该组件的属性名
	 * @param {string} value 重命名后的属性名，数据源的属性名
	 */
	addAttributeRename(key: string, value: string): void;
	/**
	 * 移除属性重命名
	 * @param {string} key 原始属性名
	 */
	removeAttributeRename(key: string): void;
	/**
	 * 清空属性重命名
	 */
	clearAttributeRename(): void;
	/**
	 * @protected
	 */
	protected initObject(): void;
	/** @protected */
	protected getDefaultParams(): {};
	/**
	 * @protected
	 * 通过index获取该index对应的数据源的实体信息entity，entity中包括数据索引、
	 * 索引对应的原始数据和经过解析之后的数据
	 * @param {number} index
	 * @returns {object}
	 */
	protected getEntityByIndex(index: number): object;
	/**
	 * object元素碰撞检测时计算自身尺寸的方法
	 * @protected
	 */
	protected collisionTest(data: any): {};
	/**
	 * 销毁object上的geometry和material实例，释放资源, 调用`engine.remove(object)`会自动销毁资源，不需要手动调用
	 */
	dispose(): void;
	bindTerrain(terrain: any): void;
}
/**
 * 全局碰撞检测
 * @category Internal
 * @example
 * ```javascript
 * const icon = engine.add(new mapvthree.Icon({
 *     icon: 'icon.png',
 *     width: 40,
 *     height: 40,
 * }));
 * icon.dataSource = dataSource;
 * // 为icon添加碰撞检测
 * engine.rendering.collision.add(icon, {margin: [10, 10]} 'poi');
 * ```
 */
export class RenderingCollision {
	constructor(rendering: any);
	/**
	 * 添加一个对象到碰撞检测系统
	 * @param {GeoObject} object 需要进行碰撞检测的对象
	 * @param {Object} [options={}] 碰撞检测选项
	 * @param {Array<number>|number} [options.margin] 碰撞边距
	 * @param {string} [group='_default'] 碰撞检测分组
	 * @example
	 * ```javascript
	 * // 添加一个标签到指定分组，并设置碰撞边距
	 * engine.rendering.collision.add(labelObject, {
	 *     margin: [2, 2]
	 * }, 'poi-labels');
	 * ```
	 */
	add(object: GeoObject, options?: {
		margin?: Array<number> | number;
	}, group?: string): void;
	setGroupOption(groupName: any, groupOptions: any): void;
	/**
	 * 从碰撞检测系统中移除一个对象
	 * @param {GeoObject} object 要移除的对象
	 * @param {string} [group='_default'] 对象所在的分组
	 * @example
	 * ```javascript
	 * // 从默认分组移除对象
	 * engine.rendering.collision.remove(labelObject);
	 *
	 * // 从指定分组移除对象
	 * engine.rendering.collision.remove(labelObject, 'poi-labels');
	 * ```
	*/
	remove(object: GeoObject, group?: string): void;
	sortBucket(bucket: any): void;
	sortBuckets(buckets: any, groupKey: any): any[];
	/**
	 * 碰撞方块的外边距，主要影响碰撞体积
	 * @param {Array<number> | number} value x轴与y轴的边距
	 */
	set margin(value: Array<number> | number);
	/**
	 * 获取碰撞方块外边距
	 * @returns {Array<number>} 碰撞方块外边距
	 */
	get margin(): Array<number>;
	/**
	 * 最大渲染深度, 超过此深度的元素将不参与碰撞检测, 范围[0, 1], 默认1, 即不限制
	 * @default 1
	 * @param {number} value 最大渲染深度
	 */
	set maxRenderDepth(value: number);
	/**
	 * 参与碰撞检测计算的最大数据量，用于性能优化
	 * @type {number}
	 * @default 10000
	 * @example
	* ```javascript
	* // 限制参与碰撞检测的数据量
	* engine.rendering.collision.restrictCount = 5000;
	* ```
	*/
	set restrictCount(value: number);
	/**
	 * 获取参与碰撞检测计算的最大数据量
	 * @returns {number} 参与碰撞检测计算的最大数据量
	 */
	get restrictCount(): number;
	/**
	 * 设置是否需要更新碰撞检测
	 * @param {boolean} value 是否需要更新碰撞检测
	 */
	set needsUpdate(value: boolean);
	/**
	 * 获取是否需要更新碰撞检测
	 * @returns {boolean} 是否需要更新碰撞检测
	 */
	get needsUpdate(): boolean;
}
/**
 * 动画管理类 <br>
 * 该类会随{@link EngineRendering}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.rendering.animation`访问<br/>
 * 该类默认创建了一个全局动画混合器，开发者可以通过`engine.rendering.animation.mixer`访问，
 * 也可以通过`engine.rendering.animation.addMixer`添加自定义动画混合器<br/>
 *
 * @category Internal
 * @example
 * ```javascript
 * engine.rendering.animation.addMixer(mixer);
 * ```
 * @example
 * ```javascript
 * const action1 = engine.rendering.animation.mixer.clipAction(clip);
 * action1.play();
 * ```
 */
export class RenderingAnimation {
	constructor(rendering: any);
	/**
	 * 添加自定义动画混合器
	 * @param {AnimationMixer} mixer - 自定义动画混合器
	 */
	addMixer(mixer: AnimationMixer): void;
	/**
	 * 移除自定义动画混合器
	 * @param {AnimationMixer} mixer - 自定义动画混合器
	 */
	removeMixer(mixer: AnimationMixer): void;
	/**
	 * 获取默认动画混合器
	 * @returns {AnimationMixer} 默认动画混合器
	 */
	get mixer(): AnimationMixer;
}
declare class RenderingXr {
	constructor(rendering: any);
	init(): void;
	camera: any;
	xrCamera: Group<import("three").Object3DEventMap>;
	dispose(): void;
	onSessionStart: () => void;
	onSessionEnd: () => void;
}
declare class RenderingMicroTaskScheduler {
	constructor(rendering: any);
	/**
	 * 最大任务数量，
	 * 超过这个数量的任务将直接执行
	 */
	/**
	 * 存储任务队列
	 * @type {Array<{task: Function, priority: number}>}
	 */
	beginFrame(): void;
	endFrame(): void;
	executeAllTasks(): void;
	/**
	 * 添加一个微任务
	 * @param {Function} task - 返回 Promise 的任务函数
	 * @param {number} priority - 任务优先级（默认为 0，值越大优先级越高）
	 * @returns {MicroTask} 返回任务对象，可用于取消任务或获取执行结果
	 */
	addTask(taskFunc: any, priority?: number): MicroTask;
	set maxTaskCount(value: number);
	get maxTaskCount(): number;
	get taskCount(): number;
}
declare class MicroTask {
	constructor(task: any, priority?: number);
	taskFunc: any;
	priority: number;
	execute(): void;
	cancel(): void;
	isCancelled(): boolean;
	isStart(): boolean;
	get promise(): Promise<any>;
}
declare class SharedFullScreenRenderTargets {
	constructor(rendering: any);
	beginFrame(): void;
	getAvailableRenderTarget(): RenderTarget;
	/**
	 * 获取可用的 stencil render target
	 * 用于需要深度和模板缓冲区的渲染场景（如 TileMask）
	 * @returns {WebGLRenderTarget} stencil render target
	 */
	getAvailableStencilRenderTarget(): WebGLRenderTarget;
	releaseRenderTarget(renderTarget: any): void;
	releaseRenderTargetByIndex(index: any): void;
	lockRenderTarget(renderTarget: any): void;
	setSize(width: any, height: any): void;
	endFrame(): void;
}
declare class RenderingRequirements {
	constructor(rendering: any);
	needsEmissiveTexture: boolean;
	needsNormalTexture: boolean;
	needsNormalTextureWhenMRT: boolean;
	needsDepthTexture: boolean;
	needsMetallicRoughTexture: boolean;
	enableStencilBuffer: boolean;
	enableRenderingJitter: boolean;
	needsFloatRenderTarget: boolean;
	/**
	 * 重置状态
	 * 重新计算需求
	 */
	beginFrame(): void;
	isTextureRequirementsChanged(): boolean;
	isRenderTargetTypeChanged(): boolean;
	getRenderTargetType(): 1009 | 1016;
	endFrame(): void;
	get currentTextureRequirementsKey(): number;
	get currentShaderKey(): string;
}
declare class Feature {
	constructor(rendering: any, options?: {});
	needsShaderKey: boolean;
	beginFrame(): void;
	render(): void;
	endFrame(): void;
	getCurrentShaderKey(): string;
	set enabled(value: boolean);
	get enabled(): boolean;
}
declare class FeatureBloom extends Feature {
	afterRender(): void;
	getCurrentUsedTextures(): import("three").Texture[];
	dispose(): void;
	set strength(strength: number);
	get strength(): number;
	set radius(radius: number);
	get radius(): number;
	set threshold(threshold: number);
	get threshold(): number;
}
declare class TAAPass extends Pass {
	enableRenderingJitter: boolean;
	uniforms: {
		tDiffuse: {
			value: any;
		};
		opacity: {
			value: number;
		};
	};
	material: ShaderMaterial;
	fsQuad: FullScreenQuad;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
	getCurrentUsedTextures: () => import("three").Texture[];
}
declare class FeatureAntialias extends Feature {
	constructor(rendering: any, options: any);
	afterRender(): void;
	dispose(): void;
	set method(value: string);
	get method(): string;
	get samples(): number;
}
declare class SSAOPass extends Pass {
	constructor(width: any, height: any);
	width: any;
	height: any;
	kernelRadius: number;
	kernelSize: number;
	kernel: any[];
	noiseTexture: DataTexture;
	intensity: number;
	minDistance: number;
	maxDistance: number;
	ssaoMaterial: ShaderMaterial;
	blurMaterial: ShaderMaterial;
	copyMaterial: ShaderMaterial;
	fsQuad: FullScreenQuad;
	originalClearColor: Color;
	needsNormalTexture: boolean;
	needsDepthTexture: boolean;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
	ssaoRenderTarget: WebGLRenderTarget<import("three").Texture>;
	blurRenderTarget: WebGLRenderTarget<import("three").Texture>;
	renderPass(renderer: any, passMaterial: any, renderTarget: any, clearColor: any, clearAlpha: any): void;
	setSize(width: any, height: any): void;
	generateSampleKernel(): void;
	generateRandomKernelRotations(): void;
}
declare class FeatureAo extends Feature {
	constructor(rendering: any, options: any);
	afterRender(): void;
	dispose(): void;
	set method(value: string);
	get method(): string;
	set ssaoKernelRadius(value: number);
	get ssaoKernelRadius(): number;
	set ssaoMinDistance(value: number);
	get ssaoMinDistance(): number;
	set ssaoMaxDistance(value: number);
	get ssaoMaxDistance(): number;
	set ssaoIntensity(value: number);
	get ssaoIntensity(): number;
}
declare class SsrMaterial extends ShaderMaterial {
	constructor(parameters: any);
	vertexShader: any;
	fragmentShader: any;
	uniforms: {
		tDiffuse: {
			value: any;
		};
		tNormal: {
			value: any;
		};
		tMetalness: {
			value: any;
		};
		tEnhancement: {
			value: any;
		};
		tEnhancementScale: {
			value: Vector2;
		};
		tDepth: {
			value: any;
		};
		cameraNear: {
			value: any;
		};
		cameraFar: {
			value: any;
		};
		resolution: {
			value: Vector2;
		};
		cameraProjectionMatrix: {
			value: Matrix4;
		};
		cameraInverseProjectionMatrix: {
			value: Matrix4;
		};
		mvt_viewInverseMatrix: {
			value: Matrix4;
		};
		mvt_normalInverseMatrix: {
			value: Matrix3;
		};
		opacity: {
			value: number;
		};
		maxDistance: {
			value: number;
		};
		cameraRange: {
			value: number;
		};
		thickness: {
			value: number;
		};
		logDepthBufFC: {
			value: number;
		};
		threshold: {
			value: number;
		};
	};
	defines: {
		MAX_STEP: number;
		PERSPECTIVE_CAMERA: boolean;
		DISTANCE_ATTENUATION: boolean;
		FRESNEL: boolean;
		INFINITE_THICK: boolean;
		SELECTIVE: boolean;
	};
}
declare class SSRPass extends Pass {
	material: SsrMaterial;
	fsQuad: FullScreenQuad;
	needsMetallicRoughTexture: boolean;
	needsNormalTexture: boolean;
	needsDepthTexture: boolean;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
}
declare class FeatureReflection extends Feature {
	constructor(rendering: any, options: any);
	afterRender(): void;
	dispose(): void;
	set method(value: string);
	get method(): string;
}
declare class AddTexturePass extends Pass {
	uniforms: {
		tDiffuse: {
			value: any;
		};
		textureInfos: {
			value: any;
		};
		maps: {
			value: any;
		};
	};
	material: ShaderMaterial;
	fsQuad: FullScreenQuad;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
	updateTextures(textures: any, infos: any): void;
}
declare class FeatureBufferView extends Feature {
	afterRender(): void;
	addCurrentFrameTexture(texture: any): void;
	dispose(): void;
	set offset(offset: number);
	get offset(): number;
}
declare class FeatureStats extends Feature {
	afterRender(): void;
	dispose(): void;
}
declare class ShadowFrustum {
	maxFar: number;
	lightMargin: number;
	vertices: {
		near: Vector3[];
		far: Vector3[];
	};
	updateFromCameraProjectionMatrix(camera: any): void;
	updateShadowBounds(light: any, camera: any): void;
	updateLightPosition(light: any, lightDirection: any, camera: any, shadowMapSize?: number): void;
}
declare class DefaultShadow {
	constructor(shadowFeature: any, rendering: any);
	update(light: any, direction: any): void;
	getCurrentUsedTextures(): any[];
	showCurrentShadowCamera(): void;
	hideCurrentShadowCamera(): void;
	dispose(): void;
}
declare class CSMShadow {
	constructor(shadowFeature: any, rendering: any);
	init(): void;
	update(light: any, direction: any, parent: any): void;
	updateFrame(mainLight: any, direction: any): void;
	getBreaks(): void;
	initCascades(): void;
	updateShadowBounds(): void;
	updateUniforms(): void;
	getExtendedBreaks(target: any): void;
	updateFrustums(): void;
	updateCSMShadow(material: any, shader: any): void;
	dispose(): void;
	getCurrentUsedTextures(): any[];
	set shadowBias(value: number);
	get shadowBias(): number;
	set showHelper(value: boolean);
	get showHelper(): boolean;
}
declare class FeatureShadow extends Feature {
	constructor(rendering: any, options: any);
	enabled: any;
	updateShadow: (light: any, direction: any, parent: any) => void;
	getCurrentUsedTextures: () => any[];
	updateCSMShadow: (material: any, shader: any) => void;
	set method(value: string);
	get method(): string;
	set shadowMapSize(size: number);
	get shadowMapSize(): number;
	set maxDistance(distance: number);
	get maxDistance(): number;
}
declare class FeatureDepthPicking extends Feature {
	pickDepth(pixelX: any, pixelY: any): Promise<number>;
	afterRender(): void;
	dispose(): void;
	get viewTextures(): import("three").Texture[];
}
declare class ColorAdjustmentPass extends Pass {
	uniforms: {
		tDiffuse: {
			value: any;
		};
		saturation: {
			value: number;
		};
		brightness: {
			value: number;
		};
		contrast: {
			value: number;
		};
	};
	material: ShaderMaterial;
	fsQuad: FullScreenQuad;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
	set saturation(value: number);
	get saturation(): number;
	set brightness(value: number);
	get brightness(): number;
	set contrast(value: number);
	get contrast(): number;
}
declare class FeatureColorAdjustment extends Feature {
	constructor(rendering: any, options: any);
	afterRender(): void;
	dispose(): void;
	set saturation(value: number);
	get saturation(): number;
	set brightness(value: number);
	get brightness(): number;
	set contrast(value: number);
	get contrast(): number;
}
declare class CameraFusionPass extends Pass {
	constructor(texture: any, camera: any);
	name: string;
	uniforms: {
		[uniform: string]: import("three").IUniform<any>;
	};
	material: ShaderMaterial;
	fsQuad: FullScreenQuad;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
	set camera(camera: any);
	get camera(): any;
	set texture(texture: any);
	get texture(): any;
	set opacity(value: any);
	get opacity(): any;
}
declare class FeatureCameraFusion extends Feature {
	afterRender(): void;
	dispose(): void;
	set camera(camera: any);
	get camera(): any;
	set texture(texture: any);
	get texture(): any;
	set opacity(opacity: number);
	get opacity(): number;
}
declare class FeatureHDR extends Feature {
	set exposure(value: number);
	get exposure(): number;
}
declare class Features {
	constructor(rendering: any, options: any);
	beginFrame(): void;
	afterRender(): void;
	endFrame(): void;
	updateReqirements(requirements: any): void;
	isInStableRenderState(): boolean;
	get ao(): FeatureAo;
	get bloom(): FeatureBloom;
	get stats(): FeatureStats;
	get bufferView(): FeatureBufferView;
	get antialias(): FeatureAntialias;
	get reflection(): FeatureReflection;
	get features(): any[];
	get shadow(): FeatureShadow;
	get depthPicking(): FeatureDepthPicking;
	get colorAdjustment(): FeatureColorAdjustment;
	get cameraFusion(): FeatureCameraFusion;
	get hdr(): FeatureHDR;
}
declare class UIPass extends Pass {
	constructor(rendering: any);
	name: string;
	rendering: any;
	camera: any;
	material: ShaderMaterial;
	fsQuad: FullScreenQuad;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
}
/**
 * 后处理类，用于管理后处理<br/>
 * 该类会随{@link EngineRendering}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.rendering.postprocessings`访问<br/>
 * 引擎内部渲染特性需要的后处理，会自动添加到该类中，开发者不需要手动添加<br/>
 * 开发者可以调用`add`方法添加自定义后处理，也可以调用`remove`方法移除后处理<br/>
 * 后处理会根据`renderOrder`属性进行排序，`renderOrder`值越小，渲染顺序越靠前<br/>
 *
 * @category Internal
 * @example
 * ```javascript
 * engine.rendering.postprocessings.add(new ExamplePostprocessing());
 * ```
 */
export class Postprocessings {
	constructor(rendering: any);
	setSize(width: any, height: any): void;
	beginFrame(): void;
	/**
	 * 添加后处理
	 * @param {Postprocessing} postprocessing - 后处理
	 */
	add(postprocessing: Postprocessing): void;
	/**
	 * 移除后处理
	 * @param {Postprocessing} postprocessing - 后处理
	 */
	remove(postprocessing: Postprocessing): void;
	render(): void;
	isInStableRenderState(): boolean;
	updateReqirements(requirements: any): void;
	endFrame(): void;
	dispose(): void;
	get renderTarget1(): any;
	get validCount(): number;
	get postprocessings(): any[];
}
declare class OpaqueCopyPass extends Pass {
	constructor(width: any, height: any);
	material: ShaderMaterial;
	needsDepthTexture: boolean;
	outputTarget: WebGLRenderTarget<import("three").Texture>;
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
	get texture(): import("three").Texture;
	get depthTexture(): DepthTexture;
	setSize(width: any, height: any): void;
}
declare class OpaquePostprocessings extends Postprocessings {
	add(postprocessing: any): void;
	show(): void;
	hide(): void;
	set enableOpaqueCopy(value: boolean);
	get enableOpaqueCopy(): boolean;
	get texture(): import("three").Texture;
	get depthTexture(): import("three").DepthTexture;
}
declare class RenderingMainNew {
	constructor(rendering: any, options: any);
	beginFrame(): void;
	render(renderPassChangedObjects: any): void;
	isInStableRenderState(): boolean;
	endFrame(): void;
	setSize(width: any, height: any): void;
	get sceneRendering(): any;
	set useFastEmissiveMethod(value: any);
	get useFastEmissiveMethod(): any;
	get antialias(): boolean;
	get rendering(): any;
	get requirements(): RenderingRequirements;
	get features(): Features;
	get postprocessings(): Postprocessings;
	get opaquePostprocessings(): OpaquePostprocessings;
}
declare class DataItem {
	/**
	 * 创建数据元素实例
	 * @param {Object|Array<number>|Vector3} feature 几何信息
	 *   - Object: GeoJSON格式的Feature数据
	 *   - Array<number>: 点坐标数组，如[lng, lat]或[lng, lat, alt]
	 *   - Vector3: Three.js的三维向量
	 * @param {object} [extraAttributes={}] 附加属性对象
	 *   - 特殊属性'id'：用于标识数据元素
	 *   - 特殊属性'crs'：源投影信息
	 * @param {boolean} [forceProjected=false] 是否强制视为已投影坐标
	 * @example
	 * ```javascript
	 * // 从GeoJSON特征创建
	 * const item = new DataItem({
	 *   type: 'Feature',
	 *   geometry: {
	 *     type: 'Point',
	 *     coordinates: [116.39, 39.9]
	 *   },
	 *   properties: { name: '北京' }
	 * });
	 *
	 * // 从坐标数组创建点
	 * const point = new DataItem([116.39, 39.9]);
	 *
	 * // 从Three.js向量创建
	 * const vector = new THREE.Vector3(116.39, 39.9, 0);
	 * const vectorPoint = new DataItem(vector);
	 * ```
	 */
	constructor(feature: any | Array<number> | Vector3, extraAttributes?: object, forceProjected?: boolean);
	/**
	 * 获取指定投影下的坐标
	 * @param {object} projection 投影对象
	 * @param {number} [index=0] 多要素时的索引
	 * @returns {Array} 投影后的坐标
	 * @example
	 * ```javascript
	 * // 获取Web墨卡托投影下的坐标
	 * const projection = getProjection('EPSG:3857');
	 * const coords = dataItem.getProjectedCoordinates(projection);
	 *
	 * // 对于MultiLineString，获取第2条线的坐标
	 * const lineCoords = dataItem.getProjectedCoordinates(projection, 1);
	 * ```
	 */
	getProjectedCoordinates(projection: object, index?: number, sourceCoordType: any, targetCoordType: any): any[];
	/**
	 * 将数据转换为GeoJSON格式
	 * @returns {object} GeoJSON Feature对象
	 * @example
	 * ```javascript
	 * const geojson = dataItem.toGeoJSON();
	 * console.log(geojson.geometry.type); // 'Point'等
	 * console.log(geojson.properties); // 属性对象
	 * ```
	 */
	toGeoJSON(): object;
	/**
	 * 设置数据项的坐标
	 * @param {Array} coordinates 新的坐标数组
	 * @param {object} [projection] 坐标所属的投影
	 * @example
	 * ```javascript
	 * // 更新点的位置
	 * dataItem.setCoordinates([118.28, 40.22]);
	 *
	 * // 设置已投影的坐标
	 * const projection = getProjection('EPSG:3857');
	 * dataItem.setCoordinates([12620000, 4830000], projection);
	 * ```
	 */
	setCoordinates(coordinates: any[], projection?: object): void;
	/**
	 * 设置数据项的单个属性
	 * @param {string} key 属性名
	 * @param {*} value 属性值
	 * @example
	 * ```javascript
	 * dataItem.setAttribute('name', '北京');
	 * dataItem.setAttribute('value', 100);
	 * ```
	 */
	setAttribute(key: string, value: any): void;
	/**
	 * 设置数据项的多个属性
	 * @param {object} attributes 属性对象
	 * @example
	 * ```javascript
	 * dataItem.setAttributes({
	 *   name: '北京',
	 *   value: 100,
	 *   color: [255, 0, 0]
	 * });
	 * ```
	 */
	setAttributes(attributes: object): void;
	/**
	 * 获取数据项的所有属性
	 * @type {object}
	 */
	get attributes(): object;
	/**
	 * 设置数据项的ID，只能设置一次
	 * @param {string|number} value 新的ID值
	 */
	set id(value: string | number);
	/**
	 * 获取数据项的ID
	 * @type {string|number}
	 */
	get id(): string | number;
	/**
	 * 获取数据项的经纬度坐标
	 * @type {Array}
	 */
	get coordinates(): any[];
	/**
	 * 获取数据项的源投影名称
	 * @type {string}
	 */
	get sourceProjectionName(): string;
	/**
	 * 获取数据项的几何类型
	 * @type {number}
	 * @see {@link GEOMETRY_TYPE_POINT}, {@link GEOMETRY_TYPE_LINE}, {@link GEOMETRY_TYPE_POLYGON}
	 */
	get type(): number;
	/**
	 * 是否为多要素类型（MultiPoint, MultiLineString, MultiPolygon）
	 * @type {boolean}
	 */
	get isMulti(): boolean;
	/**
	 * 多要素时的要素数量，单要素时为1
	 * @type {number}
	 */
	get size(): number;
	/**
	 * 数据项是否有效
	 * @type {boolean}
	 */
	get isValid(): boolean;
}
declare class DataSource {
	/**
	 * 创建数据源实例
	 * @param {object} options 配置选项
	 * @param {string} [options.id] 数据源ID，默认自动通过时间戳生成
	 * @param {object} [options.attributes] 属性映射对象，用于定义数据属性到着色器attribute的映射，映射的规则参考{@link DataSource.defineAttribute}
	 */
	constructor(options?: {
		id?: string;
		attributes?: object;
	});
	/**
	 * 主要入口方法，该方法为异步，根据路径或者原始数据请求并解析
	 * @param {string} url 请求路径
	 * @returns {Promise<DataSource>} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 加载远程数据
	 * await dataSource.load('path/to/data.geojson');
	 * ```
	 */
	load(url: string): Promise<DataSource>;
	set needsUpdate(value: boolean);
	get needsUpdate(): boolean;
	/**
	 * 根据数据中属性名设置着色器attribute字段
	 * @param {string} attribute 着色器attribute对应变量名
	 * @param {string|function} property 数据中property名或回调函数
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 用法1：将数据中的'height'属性映射到着色器中的'size'变量
	 * dataSource.defineAttribute('size', 'height');
	 *
	 * // 用法2：可以链式调用
	 * dataSource.defineAttribute('color', 'pointColor')
	 *          .defineAttribute('size', 'height');
	 *
	 * // 用法3：数据中的属性和着色器变量名相同时，可省略property参数
	 * dataSource.defineAttribute('size');
	 *
	 * // 用法4：property参数可传入回调函数，根据数据项的属性值动态计算着色器attribute的值
	 * dataSource.defineAttribute('color', attribute => {
	 *     return [attribute.red, attribute.green, attribute.blue, attribute.alpha];
	 * });
	 * ```
	 */
	defineAttribute(attribute: string, property: string | Function): DataSource;
	/**
	 * 根据数据中属性名批量设置着色器attribute字段
	 * @param {Object} obj 着色器attribute变量名与数据中property名对应关系
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 一次设置多个属性映射
	 * dataSource.defineAttributes({
	 *   color: 'pointColor',
	 *   size: 'height',
	 * });
	 * ```
	 */
	defineAttributes(obj: any): DataSource;
	/**
	 * 从着色器中移除属性名为name的attribute字段
	 * @param {string} name 属性名
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 移除对'color'属性的映射
	 * dataSource.undefineAttribute('color');
	 * ```
	 */
	undefineAttribute(name: string): DataSource;
	/**
	 * 从着色器移除所有添加的attribute字段，这些字段只能是通过defineAttribute或defineAttributes添加的
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 清除所有属性映射
	 * dataSource.undefineAllAttributes();
	 * ```
	 */
	undefineAllAttributes(): DataSource;
	/**
	 * 向数据源中增加数据元素
	 * @param {DataItem|DataItem[]} dataItem 数据元素实例或数组
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 添加单个点
	 * const point = new DataItem([116.39, 39.9], { name: '北京' });
	 * dataSource.add(point);
	 *
	 * // 添加多个要素
	 * const points = [
	 *   new DataItem([116.39, 39.9], { name: '北京' }),
	 *   new DataItem([121.47, 31.23], { name: '上海' })
	 * ];
	 * dataSource.add(points);
	 * ```
	 */
	/**
	 * 添加事件监听器
	 * @param {string} event 事件名称，支持 'afterAdd' 和 'afterRemove'
	 * @param {Function} listener 监听器函数
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * dataSource.addEventListener('afterRemove', (removedItems) => {
	 *     console.log('删除完成:', removedItems);
	 * });
	 * ```
	 */
	addEventListener(event: string, listener: Function): DataSource;
	/**
	 * 移除事件监听器
	 * @param {string} event 事件名称
	 * @param {Function} listener 要移除的监听器函数
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * const listener = (items) => console.log(items);
	 * dataSource.addEventListener('afterRemove', listener);
	 * dataSource.removeEventListener('afterRemove', listener);
	 * ```
	 */
	removeEventListener(event: string, listener: Function): DataSource;
	add(dataItem: any): this;
	/**
	 * 从数据源中移除数据元素
	 * @param {DataItem|DataItem[]} dataItem 数据元素实例或数组
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 移除单个点
	 * dataSource.remove(point);
	 *
	 * // 通过ID移除点
	 * dataSource.remove('point1');
	 *
	 * // 移除多个点
	 * dataSource.remove([point1, point2]);
	 * ```
	 */
	remove(dataItem: DataItem | DataItem[]): DataSource;
	/**
	 * 设置指定ID数据项的单个属性值
	 * @param {string|string[]} ids 数据项ID或ID数组
	 * @param {string} key 属性名
	 * @param {*} value 属性值
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 设置单个点的颜色
	 * dataSource.setAttributeValue('point1', 'color', [255, 0, 0]);
	 *
	 * // 设置多个点的颜色
	 * dataSource.setAttributeValue(['point1', 'point2'], 'color', [255, 0, 0]);
	 * ```
	 */
	setAttributeValue(ids: string | string[], key: string, value: any): DataSource;
	/**
	 * 设置指定ID数据项的多个属性值
	 * @param {string|string[]} ids 数据项ID或ID数组
	 * @param {object} values 属性名-值对象
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 同时设置点的多个属性
	 * dataSource.setAttributeValues('point1', {
	 *   color: [255, 0, 0],
	 *   size: 10,
	 * });
	 *
	 * // 对多个点设置相同的属性
	 * dataSource.setAttributeValues(['point1', 'point2'], {
	 *   color: [255, 0, 0],
	 *   size: 10
	 * });
	 * ```
	 */
	setAttributeValues(ids: string | string[], values: object): DataSource;
	/**
	 * 设置指定ID数据项的坐标
	 * @param {string|string[]} ids 数据项ID或ID数组
	 * @param {number[]|number[][]} coordinates 坐标或坐标数组
	 * @param {string} [projection] 投影类型
	 * @returns {DataSource} 当前数据源实例
	 * @example
	 * ```javascript
	 * // 修改点的位置
	 * dataSource.setCoordinates('point1', [116.39, 39.9]);
	 *
	 * // 修改线的坐标
	 * dataSource.setCoordinates('line1', [
	 *   [116.39, 39.9],
	 *   [121.47, 31.23]
	 * ]);
	 * ```
	 */
	setCoordinates(ids: string | string[], coordinates: number[] | number[][], projection?: string): DataSource;
	/**
	 * 获取已解析后的第index个数据
	 * @param {number} index 索引下标
	 * @returns {object|undefined} 对应索引的数据项，若索引无效则返回undefined
	 * @example
	 * ```javascript
	 * // 获取第一个数据项
	 * const item = dataSource.get(0);
	 * console.log(item.position, item.color);
	 * ```
	 */
	get(index: number): object | undefined;
	/**
	 * 获取原始数据中的数据索引
	 * @param {number} index 绘制元素的索引
	 * @returns {number} 原始数据的索引
	 */
	getDataItemIndex(index: number): number;
	/**
	 * 获取原始数据
	 * @param {number} index 绘制元素的索引
	 * @returns {DataItem|undefined} 数据项实例，若索引无效则返回undefined
	 * @example
	 * ```javascript
	 * // 获取索引为0的数据项原始数据
	 * const dataItem = dataSource.getDataItem(0);
	 * console.log(dataItem.coordinates, dataItem.attributes);
	 * ```
	 */
	getDataItem(index: number): DataItem | undefined;
	/**
	 * 导出数据成GeoJSON格式
	 * @returns {object} GeoJSON格式的数据对象
	 * @example
	 * ```javascript
	 * // 导出整个数据源为GeoJSON
	 * const geojson = dataSource.exportToGeoJSON();
	 * console.log(geojson.features.length); // 数据项数量
	 *
	 * // 可以保存为文件或发送到服务器
	 * const json = JSON.stringify(geojson);
	 * ```
	 */
	exportToGeoJSON(): object;
	/**
	 * 修改数据源中的数据
	 * @param {object} data 新的数据对象
	 * @example
	 * ```javascript
	 * // 替换整个数据源的数据
	 * const newData = {
	 *   type: 'FeatureCollection',
	 *   features: [...]
	 * };
	 * dataSource.setData(newData);
	 *
	 * // 更新相关的可视化对象会自动更新
	 * ```
	 */
	setData(data: object): void;
	/**
	 * 清空数据源中存储的数据，恢复初始状态
	 * @example
	 * ```javascript
	 * // 清空所有数据
	 * dataSource.clear();
	 * console.log(dataSource.size); // 0
	 * ```
	 */
	clear(): void;
	/**
	 * 设置过滤器，过滤器返回false的数据不会被添加到数据源中
	 * @param {Function} filter 过滤器
	 */
	setFilter(filter: Function): void;
	/**
	 * 释放数据源资源
	 */
	dispose(): void;
	/**
	 * 获取所有数据项
	 * @type {DataItem[]}
	 */
	get dataItems(): DataItem[];
	/**
	 * 数据大小
	 * @type {number}
	 */
	get size(): number;
	get data(): object;
	get userData(): object[];
	set objects(data: any[]);
	/**
	 * 该数据源连接的对象
	 * @type {Array}
	 */
	get objects(): any[];
}
/**
 * 全局标签类，可通过此类的API添加和移除标签 <br/>
 * 该类会随{@link EngineRendering}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.rendering.label`访问
 *
 * @category Internal
 * @example
* ```javascript
* // 添加一个简单的文本标签
* engine.rendering.label.add({
*     position: [116.404, 39.915, 0],
*     text: '北京市',
*     textSize: 14,
*     textFillStyle: '#ffffff',
* });
*
* // 添加一个图标标签
* engine.rendering.label.add({
*     position: [116.404, 39.915, 0],
*     mapSrc: 'marker.png',
*     width: 32,
*     height: 32,
* });
*
* // 添加一个图文组合标签
* engine.rendering.label.add({
*     position: [116.404, 39.915, 0],
*     text: '北京市',
*     mapSrc: 'marker.png',
*     width: 32,
*     height: 32,
*     collision: true, // 支持碰撞检测
*     textAnchor: 'left',  // 图标在文字左边
* });
* ```
*/
export class RenderingLabel {
	constructor(rendering: any);
	set enabled(enabled: boolean);
	get enabled(): boolean;
	set spriteTexture(spriteTexture: any);
	init(): void;
	initCollisionLabel(): void;
	initLabel(): void;
	getLabelType(label: any): any;
	processLabel(label: any): any;
	addCollisionLabel(label: any): any;
	addNormalLabel(label: any): any;
	/**
	 * 添加单个标签
	 * @param {Object} label 标签配置
	 * @param {Array<number>} label.position 标签位置 [经度, 纬度, 高度]
	 * @param {string} [label.text] 标签文本
	 * @param {string} [label.mapSrc] 图标URL
	 * @param {number} [label.width] 图标宽度(像素)
	 * @param {number} [label.height] 图标高度(像素)
	 * @param {number} [label.textSize=16] 文字大小(像素)
	 * @param {string} [label.textFillStyle='#ffffff'] 文字颜色
	 * @param {string} [label.textStrokeStyle='#000000'] 文字描边颜色
	 * @param {number} [label.textStrokeWidth=0] 文字描边宽度
	 * @param {string} [label.textAnchor='center'] 文字锚点位置
	 * @param {boolean} [label.collision=false] 是否启用碰撞检测
	 * @param {boolean} [label.flat=false] 是否贴地
	 * @returns {DataItem} 返回添加的标签项
	 *
	 * @example
	 * ```javascript
	 * const label = engine.rendering.label.add({
	 *     position: [116.404, 39.915, 0],
	 *     text: '北京市',
	 *     textSize: 16,
	 *     textFillStyle: '#ffffff',
	 *     textStrokeStyle: '#000000',
	 *     textStrokeWidth: 2,
	 *     textAnchor: 'bottom',
	 *     collision: true,
	 *     flat: false
	 * });
	 * ```
	*/
	addLabel(label: {
		position: Array<number>;
		text?: string;
		mapSrc?: string;
		width?: number;
		height?: number;
		textSize?: number;
		textFillStyle?: string;
		textStrokeStyle?: string;
		textStrokeWidth?: number;
		textAnchor?: string;
		collision?: boolean;
		flat?: boolean;
	}): DataItem;
	addLabels(labels: any, id: any): any;
	addBlock(id: any, labels: any): any;
	removeBlock(id: any): any;
	computeBoundingBox(label: any): any;
	removeCollisionLabel(label: any): void;
	removeNormalLabel(label: any): void;
	/**
	 * 移除单个标签
	 * @param {DataItem} label 要移除的标签项
	 * @example
	 * ```javascript
	 * const label = engine.rendering.label.add({
	 *     position: [116.404, 39.915, 0],
	 *     text: '北京市'
	 * });
	 *
	 * // 稍后移除该标签
	 * engine.rendering.label.removeLabel(label);
	 * ```
	*/
	removeLabel(label: DataItem): void;
	removeLabels(labels: any, id: any): any;
	/**
	 * 为所有内部DataSource添加事件监听器
	 * @param {string} event 事件名称，支持 'afterAdd' 和 'afterRemove'
	 * @param {Function} listener 监听器函数
	 * @returns {RenderingLabel} 当前实例
	 * @example
	 * ```javascript
	 * // 监听标签删除事件
	 * label.addEventListener('afterRemove', (removedItems) => {
	 *     removedItems.forEach(({id, item}) => {
	 *         console.log('标签已删除:', id);
	 *     });
	 * });
	 * ```
	 */
	addEventListener(event: string, listener: Function): RenderingLabel;
	/**
	 * 为所有内部DataSource移除事件监听器
	 * @param {string} event 事件名称
	 * @param {Function} listener 监听器函数
	 * @returns {RenderingLabel} 当前实例
	 * @example
	 * ```javascript
	 * const listener = (items) => console.log(items);
	 * label.addEventListener('afterRemove', listener);
	 * label.removeEventListener('afterRemove', listener);
	 * ```
	 */
	removeEventListener(event: string, listener: Function): RenderingLabel;
	dispose(): void;
}
/**
 * 渲染状态管理类，用于管理渲染状态<br/>
 * 该类会随{@link EngineRendering}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.rendering.renderState`访问<br/>
 * 该类会管理渲染状态，包括渲染时间、渲染帧数、渲染视图变化等。其状态由引擎内部自动管理，开发者可在回调中获取相关状态<br/>
 *
 * @category Internal
 * @example
 * ```javascript
 * engine.addBeforeRenderListener((engine, renderState) => {
 *     console.log(renderState.deltaTime);
 *     console.log(renderState.frameCount);
 *     console.log(renderState.viewChanged);
 *     console.log(renderState.viewMatrixWorld);
 *     console.log(renderState.projectionMatrix);
 *     console.log(renderState.cameraMatrix);
 *     console.log(renderState.cameraMatrixInverse);
 * });
 * ```
 */
export class RenderState {
	constructor(rendering: any);
	beginFrame(rendering: any, time: any): void;
	endFrame(): void;
	updateViewMatrixWorldInverse(matrix: any): void;
	updateCameraOffsetState(camera: any, offsetX: any, offsetY: any, offsetZ: any): void;
	getDepthByDistance(distance: any): number;
	/**
	 * 获取当前渲染时间
	 * @returns {number} 当前渲染时间
	 */
	get time(): number;
	/**
	 * 获取当前渲染视图是否发生变化
	 * @returns {boolean} 当前渲染视图是否发生变化
	 */
	get viewChanged(): boolean;
	/**
	 * 获取当前渲染视图矩阵
	 * @returns {Matrix4} 当前渲染视图矩阵
	 */
	get viewMatrixWorld(): Matrix4;
	/**
	 * 获取当前渲染视图矩阵的逆矩阵
	 * @returns {Matrix4} 当前渲染视图矩阵的逆矩阵
	 */
	get viewMatrixWorldInverse(): Matrix4;
	/**
	 * 获取当前渲染投影矩阵
	 * @returns {Matrix4} 当前渲染投影矩阵
	 */
	get projectionMatrix(): Matrix4;
	/**
	 * 获取当前渲染相机矩阵
	 * @returns {Matrix4} 当前渲染相机矩阵
	 */
	get cameraMatrix(): Matrix4;
	/**
	 * 获取当前渲染相机矩阵的逆矩阵
	 * @returns {Matrix4} 当前渲染相机矩阵的逆矩阵
	 */
	get cameraMatrixInverse(): Matrix4;
	/**
	 * 获取当前渲染相机偏移量X
	 * @returns {number} 当前渲染相机偏移量X
	 */
	get cameraOffsetX(): number;
	/**
	 * 获取当前渲染相机偏移量Y
	 * @returns {number} 当前渲染相机偏移量Y
	 */
	get cameraOffsetY(): number;
	/**
	 * 获取当前渲染时间差
	 * @returns {number} 当前渲染时间差
	 */
	get deltaTime(): number;
	/**
	 * 获取从渲染开始到当前的渲染时间
	 * @returns {number} 从渲染开始到当前的渲染时间
	 */
	get elapsedTime(): number;
	/**
	 * 获取当前渲染时间差，单位秒
	 * @returns {number} 当前渲染时间差，单位秒
	 */
	get deltaSeconds(): number;
	/**
	 * 获取当前渲染帧数
	 * @returns {number} 当前渲染帧数
	 */
	get frameCount(): number;
	/**
	 * 获取当前渲染视图稳定帧数
	 * @returns {number} 当前渲染视图稳定帧数
	 */
	get viewStableFrameCount(): number;
	/**
	 * 获取当前渲染相机偏移量
	 * @returns {Vector3} 当前渲染相机偏移量
	 */
	get cameraOffset(): Vector3;
	/**
	 * 获取当前渲染是否重新创建渲染器
	 * @returns {boolean} 当前渲染是否重新创建渲染器
	 */
	get isRendererRecreated(): boolean;
	set stage(value: any);
	get stage(): any;
	get isResolutionOrPixelRatioChanged(): boolean;
	get isResolutionChanged(): boolean;
	get isPixelRatioChanged(): boolean;
}
/**
 * 渲染管理器<br/>
 * 该类会随{@link Engine}的初始化自动实例化，不需要开发者手动执行初始化，通过`engine.rendering`访问，
 * 与渲染相关的配置和控制都在此类中实现
 *
 * @category Internal
 * @example
 * ```javascript
 * engine.rendering.features.bloom.enabled = true;
 * engine.rendering.enableAnimationLoop = true;
 * engine.rendering.animationLoopFrameTime = 16;
 * ```
 */
export class EngineRendering {
	/**
	 * @param {Engine} engine
	 * @param {object} overrideOptions
	 * @param {object} overrideOptions.contextParameters webgl context参数,大部分由引擎内部设置，开发者不需要关心
	 * @param {boolean} overrideOptions.contextParameters.preserveDrawingBuffer 是否保留绘图缓冲区, 默认false,开启截图时需要设置为true
	 * @param {number} overrideOptions.pixelRatio 像素缩放, 默认window.devicePixelRatio
	 * @param {object} overrideOptions.features 渲染特性配置
	 * @param {object} overrideOptions.features.antialias 抗锯齿配置
	 * @param {boolean} overrideOptions.features.antialias.enabled 是否开启抗锯齿, 默认true
	 * @param {string} overrideOptions.features.antialias.method 抗锯齿方法, 默认'smaa'
	 * @param {object} overrideOptions.features.bloom 泛光配置
	 * @param {boolean} overrideOptions.features.bloom.enabled 是否开启泛光, 默认false
	 * @param {number} overrideOptions.features.bloom.strength 泛光强度, 默认0.1
	 * @param {number} overrideOptions.features.bloom.threshold 泛光阈值, 默认1
	 * @param {number} overrideOptions.features.bloom.radius 泛光半径, 默认0
	 * @param {boolean} overrideOptions.enableAnimationLoop 是否开启动画循环, 默认false
	 * @param {number} overrideOptions.animationLoopFrameTime 动画循环帧时间, 默认16
	 */
	constructor(engine: Engine, overrideOptions?: {
		contextParameters: {
			preserveDrawingBuffer: boolean;
		};
		pixelRatio: number;
		features: {
			antialias: {
				enabled: boolean;
				method: string;
			};
			bloom: {
				enabled: boolean;
				strength: number;
				threshold: number;
				radius: number;
			};
		};
		enableAnimationLoop: boolean;
		animationLoopFrameTime: number;
	});
	uiScene: Group<import("three").Object3DEventMap>;
	objectsScene: Group<import("three").Object3DEventMap>;
	environmentScene: Group<import("three").Object3DEventMap>;
	set sky(value: any);
	/**
	 * 天空实例。
	 * 如果场景中有天空，则返回天空实例，否则返回null
	 */
	get sky(): any;
	set weather(value: any);
	/**
	 * 天气实例。
	 * 如果场景中有天气，则返回天气实例，否则返回null
	 */
	get weather(): any;
	renderVideo(videoConfig: any): Promise<any>;
	/**
	 * 释放场景中的资源，停止渲染更新操作。 由engine.dispose调用
	 */
	dispose(): void;
	get engine(): Engine;
	/**
	 * 获取当前webgl context参数
	 */
	get contextParameters(): {
		alpha: boolean;
		stencil: boolean;
		antialias: boolean;
		powerPreference: string;
		preserveDrawingBuffer: boolean;
		premultipliedAlpha: boolean;
	};
	set debugShaderType(value: number);
	get debugShaderType(): number;
	get isUseMRTChanged(): boolean;
	set useMrt(value: boolean);
	get useMrt(): boolean;
	set useMRT(value: boolean);
	get useMRT(): boolean;
	get main(): RenderingMainNew;
	get shadow(): FeatureShadow;
	get bloom(): FeatureBloom;
	get ssr(): {};
	get composition(): {};
	get fog(): {};
	get postprocessing(): {};
	/**
	 * 标签实例
	 */
	get label(): RenderingLabel;
	get colorAdjustment(): FeatureColorAdjustment;
	/**
	 * 用来保存渲染状态，如视图矩阵、相机的世界坐标等信息
	 */
	get renderState(): RenderState;
	get pick(): Picking;
	/**
	 * 获取拾取器实例
	 */
	get picking(): Picking;
	/**
	 * 获取渲染统计实例
	 */
	get stats(): Stats;
	get collision(): RenderingCollision;
	/**
	 * 动画管理器
	 */
	get animation(): RenderingAnimation;
	get xr(): RenderingXr;
	get taskScheduler(): RenderingMicroTaskScheduler;
	set enableAnimationLoop(value: any);
	/**
	 * 是否开启循环渲染
	 */
	get enableAnimationLoop(): any;
	/**
	 * 设置循环渲染的事件间隔
	 * @param {number} value
	 */
	set animationLoopFrameTime(value: number);
	/**
	 * 循环渲染的事件间隔，默认为16ms
	 */
	get animationLoopFrameTime(): number;
	set resolution(value: Vector2);
	/**
	 * 渲染场景分辨率
	 */
	get resolution(): Vector2;
	/**
	 * 设置设备像素比
	 * @param {number} value
	 */
	set pixelRatio(value: number);
	/**
	 * 设备像素比，默认为window.devicePixelRatio
	 */
	get pixelRatio(): number;
	set outputEncoding(value: any);
	get outputEncoding(): any;
	get canvas(): any;
	/**
	 * 渲染器对象
	 */
	get renderer(): any;
	/**
	 * 相机对象
	 */
	get camera(): any;
	/**
	 * 场景对象
	 */
	get scene(): any;
	get uniforms(): {
		time: {
			value: number;
		};
		elapsedTime: {
			value: number;
		};
		pixelRatio: {
			value: number;
		};
		zoomUnits: {
			value: number;
		};
		resolution: {
			value: Vector2;
		};
	};
	set wireframe(value: boolean);
	get wireframe(): boolean;
	/**
	 * 渲染器的debug模式，可以设置为DEBUG_MODE_NONE、DEBUG_MODE_MESH、DEBUG_MODE_MATERIAL、DEBUG_MODE_OBJECT
	 */
	set debugMode(value: number);
	/**
	 * 渲染器的debug模式
	 * @returns {number}
	 */
	get debugMode(): number;
	/**
	 * 设置是否自动偏移相机和场景，以使worldMatrix偏移量较小
	 */
	set autoOffsetRelativeCenter(value: boolean);
	/**
	 * 是否自动偏移相机和场景，以使worldMatrix偏移量较小
	 */
	get autoOffsetRelativeCenter(): boolean;
	/**
	 * 设置是否禁止更新
	 */
	set freezeUpdate(freezeUpdate: boolean);
	/**
	 * 是否禁止更新
	 */
	get freezeUpdate(): boolean;
	/**
	 * 设置是否使用高质量的渲染缓冲区
	 * @param {boolean} value
	 */
	set useHighPrecisionBuffer(value: boolean);
	/**
	 * 是否使用高质量的渲染缓冲区，默认false。
	 * 该参数会影响到渲染的性能和质量，开启后会使用高质量的渲染缓冲区，关闭后会使用低质量的渲染缓冲区。
	 * 有的渲染特性需要开启该参数才能正常工作，如泛光、反射等。这些内置的渲染特性会自动开启该参数。
	 * 当您在未使用高级渲染特性，但需要使用高质量的渲染缓冲区提升画面质量时，可以手动开启该参数。
	 */
	get useHighPrecisionBuffer(): boolean;
	set clampCameraNearFar(value: boolean);
	get clampCameraNearFar(): boolean;
	get hasWater(): boolean;
	get rawCamera(): any;
}
/**
 * 物体选择器，将场景中的某个物体或单体标记为选中状态<br/>
 * 该类会随{@link Engine}的初始化自动实例化，不需要开发者手动执行初始化，通过`engine.selection`访问
 *
 * @category Internal
 * @example
 * ```javascript
 * engine.selection.select(object);
 * engine.selection.deselect(object);
 * ```
 */
export class EngineSelection extends EventDispatcher<any> {
	/**
	 * @param {Engine} engine
	 * @param {Object} options
	 */
	constructor(engine: Engine, options?: any);
	/**
	 * 判断物体是否被选中
	 * @param {Object3D} object
	 * @returns {boolean}
	 */
	isSelected(object: Object3D): boolean;
	/**
	 * 选中物体
	 * @param {Object3D} object
	 */
	select(object: Object3D): void;
	/**
	 * 取消选中物体
	 * @param {Object3D} object
	 */
	deselect(object: Object3D): void;
	get transformControl(): any;
	/**
	 * 附加变换控制器
	 * @param {Object3D} object
	 */
	attachTransform(object: Object3D): void;
	/**
	 * 分离变换控制器
	 */
	detachTransform(): void;
	dispose(): void;
}
declare class BaseWidgets {
	/**
	 * @param {HTMLElement} container 容器元素
	 * @param {object} options 控件配置
	 * @param {boolean} options.enabled 是否启用控件
	 * @param {Engine} engine 引擎实例
	 */
	constructor(container: HTMLElement, options: {
		enabled: boolean;
	}, engine?: Engine);
	/**
	 * 初始化控件
	 * @protected
	 */
	protected init(): void;
	/**
	 * 初始化后处理
	 * @protected
	 */
	protected afterInit(): void;
	/**
	 * 创建DOM元素
	 * @protected
	 * @returns {HTMLElement}
	 */
	protected createDom(): HTMLElement;
	/**
	 * 释放资源
	 */
	dispose(): void;
	/**
	 * 清理事件监听
	 * @protected
	 */
	protected onDispose(): void;
	/**
	 * 获取容器元素
	 * @type {HTMLElement}
	 */
	get container(): HTMLElement;
	/**
	 * 获取控件元素
	 * @type {HTMLElement}
	 */
	get element(): HTMLElement;
	/**
	 * 设置控件是否启用
	 * @type {boolean}
	 */
	set enabled(value: boolean);
	/**
	 * 获取控件是否启用
	 * @type {boolean}
	 */
	get enabled(): boolean;
}
declare class FloorSwitcher extends BaseWidgets {
	createDom(): HTMLDivElement;
	/**
	 * 更新楼层信息
	 * @param {object} payload
	 * @param {string} payload.bid 室内建筑ID
	 * @param {Array<object>} payload.floors 楼层信息
	 */
	updateFloors({ bid, floors, defaultFloorName }: {
		bid: string;
		floors: Array<object>;
	}): void;
	/**
	 * 隐藏控件
	 */
	clear(): void;
	setFloorChangeHandler(handler: any): void;
}
declare class Compass extends BaseWidgets {
	/**
	 * 创建子节点
	 */
	createDom(): any;
	handleUpBtnClick(): void;
	handleDownBtnClick(): void;
	handleLeftBtnClick(): void;
	handleRightBtnClick(): void;
	handleCenterBtnClick(): void;
}
declare class Logo extends BaseWidgets {
	/**
	 * 设置logo的图片
	 */
	set url(url: any);
	/**
	 * logo的图片
	 */
	get url(): any;
	/**
	 * 创建子节点
	 */
	createDom(): any;
}
declare class Zoom extends BaseWidgets {
	/**
	 * 事件解绑
	 */
	createDom(): any;
}
declare class Scale extends BaseWidgets {
	static UNIT: {
		METRIC: string;
		IMPERIAL: string;
	};
	/**
	 * 创建子节点
	 */
	createDom(): any;
	set unit(value: any);
}
declare class Fullscreen extends BaseWidgets {
	/**
	 * 创建子节点
	 */
	createDom(): any;
}
declare class GeoLocate extends BaseWidgets {
	static COORD_TYPE: {
		WGS84: number;
		WGS84_MC: number;
		GCJ02: number;
		GCJ02_MC: number;
		BD09: number;
		BD09_MC: number;
		MAPBAR: number;
		MAP51: number;
	};
	/**
	 * 创建子节点
	 */
	createDom(): any;
	locate(): void;
	addSuccessListener(listener: any): void;
	removeSuccessListener(listener: any): void;
	addFailListener(listener: any): void;
	removeFailListener(listener: any): void;
	stopWatch(): void;
}
declare class ExportImage extends BaseWidgets {
	/**
	 * 创建子节点
	 */
	createDom(): any;
	/**
	 * 下载截图
	 * @param {string} filename 下载文件名
	 * @param {boolean} download 是否自动下载
	 */
	screenshot: (filename: string, download: boolean) => string;
}
declare class MapInfo extends BaseWidgets {
	set template(value: string);
	get template(): string;
	set prefix(value: {
		M: string;
		C: string;
		Z: string;
		H: string;
		P: string;
		R: string;
	});
	get prefix(): {
		M: string;
		C: string;
		Z: string;
		H: string;
		P: string;
		R: string;
	};
	set separator(value: string);
	get separator(): string;
	/**
	 * 创建子节点
	 */
	createDom(): any;
	eventCallback: any;
	set enableMousePositionTracking(isTracking: any);
	get enableMousePositionTracking(): any;
}
declare class Drawer extends BaseWidgets {
	/**
	 * 创建子节点
	 */
	createDom(): any;
	addChangeListener(element: any, handler: any): void;
	removeChangeListener(element: any): void;
	openDrawer(): void;
}
declare class CityList extends BaseWidgets {
	/**
	 * 创建子节点
	 */
	createDom(): any;
	addChangeBeforListener(listener: any): void;
	removeChangeBeforListener(listener: any): void;
	addChangeAfterListener(listener: any): void;
	removeChangeAfterListener(listener: any): void;
	addChangeSuccessListener(listener: any): void;
	removeChangeSuccessListener(listener: any): void;
	set canCheckSize(value: any);
	set expand(value: any);
}
/**
 * 引擎UI控件入口 <br/>
 * 该类会随{@link Engine}的初始化自动实例化，不需要开发者手动执行初始化调用，通过`engine.widgets`访问
 *
 * @category Internal
 * @example
 * ```javascript
 * // 动态启用组件
 * engine.widgets.logo.enabled = true;
 *
 * // 初始化时配置组件
 * const engine = new Engine(container, {
 *     widgets: {
 *         logo: {
 *             enabled: true,
 *         },
 *         zoom: {
 *             enabled: true
 *         },
 *         scale: {
 *             enabled: true
 *         },
 *         fullscreen: {
 *             enabled: true
 *         },
 *         geoLocate: {
 *             enabled: true
 *         },
 *         exportImage: {
 *             enabled: true
 *         },
 *         mapInfo: {
 *             enabled: true,
 *             template: 'CHP',
 *             separator: ', '
 *         },
 *         compass: {
 *             enabled: true
 *         },
 *         drawer: {
 *             enabled: true,
 *             draws: [{
 *                 defaultChecked: true,
 *                 name: '点图层',
 *                 data: 'point',
 *                 onChange: (checked, data, engine) => {
 *                     console.log(checked, data, engine);
 *                 }
 *             }, {
 *                 name: '面图层',
 *                 data: 'polygon',
 *                 onChange: (checked, data, engine) => {
 *                     console.log(checked, data, engine);
 *                 }
 *             }]
 *         }
 *     }
 * });
 * ```
 */
export class EngineWidgets {
	/**
	 * @param {Engine} engine 引擎实例
	 * @param {object} options 控件配置选项
	 * @param {object} options.logo logo控件配置
	 * @param {boolean} options.logo.enabled 是否启用logo控件
	 * @param {object} options.zoom 缩放控件配置
	 * @param {boolean} options.zoom.enabled 是否启用缩放控件
	 * @param {object} options.scale 比例尺控件配置
	 * @param {boolean} options.scale.enabled 是否启用比例尺控件
	 * @param {object} options.fullscreen 全屏控件配置
	 * @param {boolean} options.fullscreen.enabled 是否启用全屏控件
	 * @param {object} options.geoLocate 定位控件配置
	 * @param {boolean} options.geoLocate.enabled 是否启用定位控件
	 * @param {object} options.exportImage 导出图片控件配置
	 * @param {boolean} options.exportImage.enabled 是否启用导出图片控件
	 * @param {object} options.mapInfo 地图信息控件配置
	 * @param {boolean} options.mapInfo.enabled 是否启用地图信息控件
	 * @param {object} options.mapInfo.template 地图信息模板，默认值为'CR'，其中'C'表示中心点，'R'表示视野距离，'H'表示旋转角度，'P'表示倾斜角度
	 * @param {object} options.mapInfo.separator 地图信息分隔符，默认值为' | '
	 * @param {object} options.compass 指南针控件配置
	 * @param {boolean} options.compass.enabled 是否启用指南针控件
	 * @param {object} options.drawer 抽屉控件配置
	 * @param {boolean} options.drawer.enabled 是否启用抽屉控件
	 * @param {object} options.drawer.draws 抽屉控件的绘制配置
	 * @param {object} options.drawer.draws.name 抽屉控件的名称
	 * @param {boolean} options.drawer.draws.defaultChecked 抽屉控件的默认选中状态
	 * @param {function} options.drawer.draws.onChange 抽屉控件的选中状态改变回调函数
	 * @param {object} options.drawer.draws.data 抽屉控件的数据
	 */
	constructor(engine: Engine, options?: {
		logo: {
			enabled: boolean;
		};
		zoom: {
			enabled: boolean;
		};
		scale: {
			enabled: boolean;
		};
		fullscreen: {
			enabled: boolean;
		};
		geoLocate: {
			enabled: boolean;
		};
		exportImage: {
			enabled: boolean;
		};
		mapInfo: {
			enabled: boolean;
			template: object;
			separator: object;
		};
		compass: {
			enabled: boolean;
		};
		drawer: {
			enabled: boolean;
			draws: {
				name: object;
				defaultChecked: boolean;
				onChange: Function;
				data: object;
			};
		};
	});
	dispose(): void;
	/**
	 * mapvthree的容器
	 */
	get container(): any;
	/**
	 * engine对象
	 */
	get engine(): any;
	/**
	 * compass组件实例，通过`.enable`属性控制启用
	 */
	get compass(): Compass;
	/**
	 * logo组件实例，通过`.enable`属性控制启用
	 */
	get logo(): Logo;
	/**
	 * zoom组件实例，通过`.enable`属性控制启用
	 */
	get zoom(): Zoom;
	/**
	 * scale组件实例，通过`.enable`属性控制启用
	 */
	get scale(): Scale;
	/**
	 * fullscreen组件实例，通过`.enable`属性控制启用
	 */
	get fullscreen(): Fullscreen;
	/**
	 * geoLocate组件实例，通过`.enable`属性控制启用
	 */
	get geoLocate(): GeoLocate;
	/**
	 * exportImage组件实例，通过`.enable`属性控制启用
	 */
	get exportImage(): ExportImage;
	/**
	 * mapInfo组件实例，通过`.enable`属性控制启用
	 */
	get mapInfo(): MapInfo;
	get drawer(): Drawer;
	get floorSwitcher(): FloorSwitcher;
	get cityList(): CityList;
}
/**
 * 引擎时钟系统，用于管理和控制时间流逝。<br/>
 * 该类会随{@link Engine}的初始化自动实例化，不需要开发者手动执行初始化，通过`engine.clock`访问。<br/>
 * 提供多种时钟模式，支持时间循环、限制、速度控制等功能。
 *
 * @category Internal
 * @example
 * ```javascript
 * // 访问时钟
 * const clock = engine.clock;
 *
 * // 设置当前时间
 * clock.currentTime = new Date('2024-01-01 10:00:00');
 * ```
 */
export class EngineClock {
	/** 无任何限制模式，时间不会自动流逝 */
	static TICK_NONE: number;
	/** 正常模式，忽略起止时间限制 */
	static TICK_NORMAL: number;
	/** 循环模式，时间到达停止时间后循环到开始时间 */
	static TICK_LOOP: number;
	/** 限制模式，时间会被限制在开始和停止时间之间 */
	static TICK_CLAMP: number;
	/**
	 * @param {object} options 时钟配置选项
	 * @param {Date} [options.startTime] 开始时间，未设置则使用当前时间
	 * @param {Date} [options.stopTime] 停止时间，未设置则使用当前时间
	 * @param {Date} [options.currentTime] 当前时间，未设置则使用当天10:00:00
	 * @param {number} [options.speed=1] 时间流速倍率
	 * @param {number} [options.tickMode=0] 时钟模式，可选值：TICK_NONE、TICK_NORMAL、TICK_LOOP、TICK_CLAMP
	 * @param {number} [options.timeZoneOffset=8] 时区偏移量（小时），例如东八区为8
	 */
	constructor(options?: {
		startTime?: Date;
		stopTime?: Date;
		currentTime?: Date;
		speed?: number;
		tickMode?: number;
		timeZoneOffset?: number;
	});
	/**
	 * 重置时钟到开始时间
	 */
	reset(): void;
	/**
	 * 设置当前本地时间
	 * @param {Date} value 要设置的本地时间
	 */
	set currentTime(value: Date);
	/**
	 * 获取当前本地时间
	 * @returns {Date} 当前本地时间（缓存对象，请勿修改）
	 */
	get currentTime(): Date;
	/**
	 * 设置当前UTC时间
	 * @param {Date} value 要设置的UTC时间
	 */
	set currentTimeUTC(value: Date);
	/**
	 * 获取当前UTC时间
	 * @returns {Date} 当前UTC时间（缓存对象，请勿修改）
	 */
	get currentTimeUTC(): Date;
	/**
	 * 设置开始时间
	 * @param {Date} value 要设置的开始时间（本地时区）
	 */
	set startTime(value: Date);
	/**
	 * 获取开始时间
	 * @returns {Date} 开始时间（本地时区）
	 */
	get startTime(): Date;
	/**
	 * 设置停止时间
	 * @param {Date} value 要设置的停止时间（本地时区）
	 */
	set stopTime(value: Date);
	/**
	 * 获取停止时间
	 * @returns {Date} 停止时间（本地时区）
	 */
	get stopTime(): Date;
	/**
	 * 设置时区偏移量
	 * @param {number} value 时区偏移量（小时），例如东八区为8，西五区为-5
	 */
	set timeZoneOffset(value: number);
	/**
	 * 获取时区偏移量
	 * @returns {number} 时区偏移量（小时）
	 */
	get timeZoneOffset(): number;
	/**
	 * 设置时间流速倍率
	 * @param {number} value 时间流速倍率，例如2表示2倍速，0.5表示0.5倍速
	 */
	set speed(value: number);
	/**
	 * 获取时间流速倍率
	 * @returns {number} 时间流速倍率
	 */
	get speed(): number;
	/**
	 * 设置时钟模式
	 * @param {number} value 时钟模式：TICK_NONE、TICK_NORMAL、TICK_LOOP、TICK_CLAMP
	 */
	set tickMode(value: number);
	/**
	 * 获取时钟模式
	 * @returns {number} 时钟模式：TICK_NONE、TICK_NORMAL、TICK_LOOP、TICK_CLAMP
	 */
	get tickMode(): number;
}
/**
 * 键鼠交互控制器API
* @category Internal
 * @example
 * ```javascript
 * // 访问控制器
 * const controller = engine.controller;
 *
 *  // 设置是否启用
 * controller.enabled = true;
 *
 * // 设置是否启用旋转
 * controller.enableRotate = true;
 *
 * // 设置是否启用缩放
 * controller.enableZoom = true;
 *
 * // 设置是否启用平移
 * controller.enablePan = true;
 *
 * // 设置惯性拖拽
 * controller.inertiaDragging = 0.9;
 *
 * // 设置惯性缩放
 * controller.inertiaZoom = 0.8;
 * ```
 *
 */
export class EngineController {
	constructor(engine: any, options?: {});
	/**
	 * 设置是否启用控制器，设置为false时，地图将无法响应任何交互事件
	 * @type {Boolean}
	 * @default true
	 */
	set enabled(value: boolean);
	/**
	 * 是否启用控制器
	 * @type {Boolean}
	 * @default true
	 */
	get enabled(): boolean;
	/**
	 * 设置是否启用旋转
	 * @type {Boolean}
	 * @default true
	 */
	set enableRotate(value: boolean);
	/**
	 * 是否启用旋转
	 * @type {Boolean}
	 * @default true
	 */
	get enableRotate(): boolean;
	/**
	 * 设置是否启用缩放
	 * @type {Boolean}
	 * @default true
	 */
	set enableZoom(value: boolean);
	/**
	 * 是否启用缩放
	 * @type {Boolean}
	 * @default true
	 */
	get enableZoom(): boolean;
	/**
	 * 设置是否启用平移
	 * @type {Boolean}
	 * @default true
	 */
	set enablePan(value: boolean);
	/**
	 * 是否启用平移
	 * @type {Boolean}
	 * @default true
	 */
	get enablePan(): boolean;
	/**
	 * 设置是否启用倾斜
	 * @type {Boolean}
	 * @default true
	 */
	set enableTilt(value: boolean);
	/**
	 * 是否启用倾斜
	 * @type {Boolean}
	 * @default true
	 */
	get enableTilt(): boolean;
	set enableFixCenter(value: boolean);
	get enableFixCenter(): boolean;
	set enableTerrainCollision(value: boolean);
	get enableTerrainCollision(): boolean;
	inertiaTranslate: any;
	/**
	 * 设置惯性缩放，0-1，0表示完全禁用惯性缩放，1表示惯性达到最大
	 * @type {Number}
	 * @default 0.8
	 */
	set inertiaZoom(value: number);
	/**
	 * 惯性缩放值
	 * @type {Number}
	 * @default 0.8
	 */
	get inertiaZoom(): number;
	set maximumMovementRatio(value: number);
	get maximumMovementRatio(): number;
	set bounceAnimationTime(value: number);
	get bounceAnimationTime(): number;
	set minimumZoomDistance(value: number);
	get minimumZoomDistance(): number;
	set maximumZoomDistance(value: number);
	get maximumZoomDistance(): number;
	/**
	 * 设置惯性拖拽，0-1，0表示完全禁用惯性拖拽，1表示惯性达到最大
	 * @default 0.9
	 */
	set inertiaDragging(value: number);
	/**
	 * 惯性拖拽值
	 * @type {Number}
	 * @default 0.9
	 */
	get inertiaDragging(): number;
}
declare class TileQuadtree {
	constructor(grid: any);
	getTileByKey(key: any): any;
	getTile(z: any, x: any, y: any, getReusedTile?: boolean): any;
	getTileChildren(tile: any): any;
	/**
	 * 判断给定的瓦片tile是否是指定xyz瓦片的祖先瓦片
	 * @param z 指定瓦片的z层级
	 * @param x 指定瓦片的x行列号
	 * @param y 指定瓦片的y行列号
	 * @param tile 祖先瓦片对象
	 * @returns 如果tile瓦片是指定xyz瓦片的祖先瓦片，则返回 true；否则返回 false
	 */
	isAncestralTile(z: any, x: any, y: any, tile: any): boolean;
	get root(): any;
}
declare class LRUCache {
	constructor(opts: any);
	cache: {};
	head: any;
	tail: any;
	length: number;
	max: any;
	maxAge: any;
	onRemove: any;
	clear(): void;
	remove(key: any): any;
	peek(key: any): any;
	set(key: any, value: any): any;
	has(key: any): boolean;
	get(key: any): any;
	evict(): void;
	triggerRemoveEvent: (key: any, value: any) => void;
}
declare class CommonShaderMaterial extends ShaderMaterial {
	constructor(parameters: any);
	isCommonShaderMaterial: boolean;
	setCommonUniforms: (uniforms: any) => void;
}
declare class PlaceholderMaterial extends CommonShaderMaterial {
	type: string;
	isPlaceholderMaterial: boolean;
	fragmentShader: any;
	vertexShader: any;
}
declare class Placeholder {
	constructor(options: {}, placeholderColor: any);
	createMesh(tile: any): Mesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, PlaceholderMaterial, import("three").Object3DEventMap>;
	get(tile: any): any;
	clear(): void;
	handleRemove: (mesh: any, tileKey: any) => void;
	set maxCacheSize(value: number);
	get maxCacheSize(): number;
	set backgroundColor(value: any);
	get backgroundColor(): any;
	set borderColor(value: any);
	get borderColor(): any;
}
declare class Cartesian3 {
	static ZERO: Readonly<Vector3>;
	static UNIT_X: Readonly<Vector3>;
	static UNIT_Y: Readonly<Vector3>;
	static UNIT_Z: Readonly<Vector3>;
	static clone(v1: any, v2: any): any;
	static equals(v1: any, v2: any): any;
	static normalize(v1: any, v2: any): any;
	static add(v1: any, v2: any, result: any): any;
	static dot(v1: any, v2: any): any;
	static cross(v1: any, v2: any, result: any): any;
	static magnitudeSquared(v1: any): any;
	static multiplyByScalar(v1: any, scalar: any, result: any): any;
	static divideByScalar(v1: any, scalar: any, result: any): any;
	static subtract(v1: any, v2: any, result: any): any;
	static distance(v1: any, v2: any): any;
	static negate(v1: any, result: any): any;
	static multiplyComponents(v1: any, v2: any, result: any): any;
	static magnitude(v: any): any;
	static equalsEpsilon(left: any, right: any, relativeEpsilon: any, absoluteEpsilon: any): boolean;
	static fromCartesian4(v: any, result: any): any;
	static abs: (cartesian: any, result: any) => any;
	static mostOrthogonalAxis: (cartesian: any, result: any) => any;
	static fromElements(x: any, y: any, z: any, result: any): any;
	static fromRadians(longitude: any, latitude: any, height: any, ellipsoid: any, result: any): any;
	static angleBetween(left: any, right: any): number;
	static fromDegrees(longitude: any, latitude: any, height: any, ellipsoid: any, result: any): any;
	COLUMN0ROW0: number;
	COLUMN0ROW1: number;
	COLUMN0ROW2: number;
	COLUMN1ROW0: number;
	COLUMN1ROW1: number;
	COLUMN1ROW2: number;
	COLUMN2ROW0: number;
	COLUMN2ROW1: number;
	COLUMN2ROW2: number;
}
declare class GroundSceneRenderer {
	render(groundScene: any, engine: any, scene: any, camera: any, renderState: any): void;
	get copyMesh(): Mesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, ShaderMaterial, import("three").Object3DEventMap>;
}
/**
 * 地图表面一层覆盖层
 * 负责根据视野和网格计算出需要加载的瓦片，向数据层请求瓦片，并将瓦片显示到地图上
 *
 * @category Internal
 */
export class MapSurface extends Object3D<import("three").Object3DEventMap> {
	constructor(options?: {});
	statistics: {
		visited: number;
		used: number;
		rendered: number;
		request: number;
		unstable: number;
	};
	/**
	 * 设置瓦片加载策略, {@link RasterSurface}默认使用HierarchicalTileLoaderStrategy,
	 * {@link VectorSurface}默认使用FastTileLoaderStrategy
	 */
	set strategy(strategy: any);
	/**
	 * 获取瓦片加载策略
	 */
	get strategy(): any;
	/**
	 * 计算瓦片到相机的距离
	 * @param tile {MapTile} 瓦片
	 * @param cameraPosition {Cartesian3} 相机位置
	 * @param renderState {Object} 渲染状态
	 * @param mode {SceneMode} 场景模式
	 * @param mapProjection {MapProjection} 地图投影
	 * @param ellipsoid {Ellipsoid} 椭球体
	 * @param accurateDistance {boolean} 是否精确计算距离, false时如果没有mesh将使用默认包围盒计算
	 * @returns {number} 瓦片到相机的距离
	 */
	computeDistanceToTile(tile: MapTile, cameraPosition: Cartesian3, renderState: any, mode: Readonly<{
		MORPHING: number;
		COLUMBUS_VIEW: number;
		SCENE2D: number;
		SCENE3D: number;
	}>, mapProjection: MapProjection, ellipsoid: Ellipsoid, accurateDistance?: boolean): number;
	refresh(): void;
	clearTilesInView(): void;
	isInStableRenderState(): boolean;
	onAfterColorPass: (engine: any) => void;
	onAfterMainPass: (engine: any) => void;
	beginFrame(renderState: any): void;
	updatePendingRequest(renderState: any): void;
	endFrame(renderState: any): void;
	updateTileBoundingRegion(tile: any, renderState: any): void;
	screenSpaceError(tile: any): number;
	reverseScreenSpaceErrorZ(tile: any): number;
	projectBoundingBoxToNdc(tile: any): number[][];
	onSurfaceTileAdded(tile: any): void;
	onSurfaceTileRemoved(tile: any): void;
	onSurfaceTileRefresh(tile: any): void;
	onSurfaceTileSSEChanged(tile: any): void;
	dispose(): void;
	set quadMap(quadMap: any);
	get quadMap(): any;
	/**
	 * 设置是否显示瓦片包围盒
	 */
	set showTileBoundingBox(value: boolean);
	/**
	 * 获取是否显示瓦片包围盒
	 */
	get showTileBoundingBox(): boolean;
	/**
	 * 设置是否显示瓦片调试标签
	 */
	set showTileDebugLabel(value: boolean);
	/**
	 * 获取是否显示瓦片调试标签
	 */
	get showTileDebugLabel(): boolean;
	/**
	 * 设置是否冻结瓦片更新
	 */
	set freezeUpdate(value: boolean);
	/**
	 * 获取是否冻结瓦片更新
	 */
	get freezeUpdate(): boolean;
	set enableHorizonCulling(value: boolean);
	get enableHorizonCulling(): boolean;
	get tileManager(): any;
	/**
	 * 设置是否加载兄弟瓦片
	 */
	set loadSiblings(value: any);
	/**
	 * 获取是否加载兄弟瓦片
	 */
	get loadSiblings(): any;
	set sseFactor(value: number);
	get sseFactor(): number;
	/**
	 * 设置细节层次缩放因子
	 */
	set lodScaleFactor(value: number);
	/**
	 * 获取细节层次缩放因子
	 */
	get lodScaleFactor(): number;
	get computedLodScaleFactor(): number;
	set showGroundWireframe(value: boolean);
	get showGroundWireframe(): boolean;
	get placeholder(): Placeholder;
}
declare class Ellipsoid {
	static fromCartesian3(vector: any): Ellipsoid;
	static clone(ellipsoid: any, result: any): any;
	constructor(x: any, y: any, z: any);
	geodeticSurfaceNormalCartographic(cartographic: any, result: any): any;
	cartographicDegreeToCartesian(cartographicDegree: any, result: any): any;
	cartographicToCartesian(cartographic: any, k: any): any;
	cartesianToCartographicDegree(cartesian: any, result: any): any;
	scaleToGeodeticSurface(cartesian: any, result: any): Cartesian3;
	scaleToGeocentricSurface(cartesian: any, result: any): any;
	cartesianToCartographic(cartesian: any, result: any): any;
	geodeticSurfaceNormal(cartesian: any, result: any): any;
	getSurfaceNormalIntersectionWithZAxis(position: any, buffer: any, result: any): any;
	transformPositionToScaledSpace(position: any, result: any): any;
	get radii(): Vector3;
	get radiiSquared(): Vector3;
	get radiiToTheFourth(): any;
	get oneOverRadii(): Vector3;
	get oneOverRadiiSquared(): Vector3;
	get maximumRadius(): number;
	get minimumRadius(): number;
}
declare namespace Ellipsoid {
	let WGS84: Readonly<Ellipsoid>;
}
/**
 * 地图投影的基类，定义了投影坐标系统的基本接口
 *
 * 投影类负责在地理坐标(经纬度)和投影坐标(米、像素等)之间进行转换。
 * 所有的具体投影类都继承自这个基类，并实现其定义的接口方法。
 *
 * 主要功能：
 * - 坐标正向投影与反向投影
 * - 边界框转换
 * - 投影平面法线计算
 *
 * @category Internal
 */
export class Projection {
	/**
	 * 标识该对象是投影类
	 * @type {boolean}
	 * @readonly
	 * */
	readonly isProjection: boolean;
	/**
	 * 表示该投影是否是地理投影(经纬度为基础的投影)
	 * @type {boolean}
	 * @readonly
	 */
	readonly isGeo: boolean;
	/**
	 * 表示该投影坐标延续方向是否和世界坐标方向是平行的
	 * 即投影后的坐标不会出现曲线、曲面的情况
	 * 这些投影在绘制背景面（Rectangle类型）等元素时，可以使用更高效的简化绘制方式
	 * @type {boolean}
	 * @readonly
	 */
	readonly isAxisAligned: boolean;
	/**
	 * 表示边界框的表示方法
	 * @type {number}
	 * @readonly
	 */
	readonly projectBoundingBoxMethod: number;
	/**
	 * 将地理坐标(经纬度)转换为投影坐标
	 * @param {Vector3} input 输入的地理坐标
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @returns {Vector3} 转换后的投影坐标
	 */
	projectCoordinate(input: Vector3, output?: Vector3): Vector3;
	/**
	 * 将投影坐标转换为地理坐标(经纬度)
	 * @param {Vector3} input 输入的投影坐标
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @returns {Vector3} 转换后的地理坐标
	 */
	unprojectCoordinate(input: Vector3, output?: Vector3): Vector3;
	/**
	 * 将地理边界框转换为投影坐标系边界框
	 * @param {Box3} geoBox 地理坐标系中的边界框
	 * @param {Box3} [projectedBox] 可选的输出边界框，如不提供则创建新的Box3
	 * @returns {Box3} 投影坐标系中的边界框
	 */
	geoBoxToProjectedBox(geoBox: Box3, projectedBox?: Box3, extend?: boolean): Box3;
	/**
	 * 获取地理表面在指定坐标点的法线向量
	 * @param {Vector3} input 输入的地理坐标
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @returns {Vector3} 法线向量
	 */
	getGeodeticSurfaceNormal(input: Vector3, output?: Vector3): Vector3;
	/**
	 * 获取投影表面在指定坐标点的法线向量
	 * @param {Vector3} input 输入的投影坐标
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @returns {Vector3} 法线向量
	 */
	getProjectedSurfaceNormal(input: Vector3, output?: Vector3): Vector3;
	/**
	 * 将投影坐标系边界框转换为地理边界框
	 * @param {Box3} projectedBox 投影坐标系中的边界框
	 * @param {Box3} [geoBox] 可选的输出边界框，如不提供则创建新的Box3
	 * @returns {Box3} 地理坐标系中的边界框
	 */
	projectedBoxToGeoBox(projectedBox: Box3, geoBox?: Box3, extend?: boolean): Box3;
	/**
	 * 判断两个投影是否相等
	 * @param {Projection} projection 要比较的投影对象
	 * @returns {boolean} 如果两个投影相等则返回true
	 */
	equals(projection: Projection): boolean;
	/**
	 * 将本地坐标系转换为固定坐标系
	 * @param {Vector3} origin 本地坐标系的原点
	 * @param {Matrix4} [fixedFrame] 可选的输出矩阵，如不提供则创建新的Matrix4
	 * @returns {Matrix4} 转换后的固定坐标系矩阵
	 */
	localFrameToFixedFrame(origin: Vector3, fixedFrame?: Matrix4): Matrix4;
	/**
	 * 获取投影的地理边界框
	 * @returns {Box3} 投影的地理边界框, 可为空
	 */
	get geoBoundingBox(): Box3;
	/**
	 * 获取投影的投影边界框
	 * @returns {Box3} 投影的投影边界框
	 */
	get projectedBoundingBox(): Box3;
}
/**
 * Web墨卡托投影(EPSG:3857)，常用于网络地图服务
 *
 * Web墨卡托投影是一种常用的地图投影，在大多数网络地图服务中使用，如Google Maps、OpenStreetMap等。
 * 它将地球投影到正方形平面上，具有以下特点：
 * - 等角性：保持局部形状
 * - 不保持面积比例，高纬度地区面积被放大
 * - 经线和纬线都是直线
 * - 坐标单位为米
 *
 * 投影有效范围为经度±180度，纬度约±85.05度。
 *
 * @category Internal
 */
export class WebMercatorProjection extends Projection {
	/**
	 * 投影名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
	/**
	 * 将地理坐标(经纬度)转换为Web墨卡托投影坐标
	 * @param {Vector3} input 输入的地理坐标，x,y分别为经度和纬度
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @param {boolean} [extend=false] 是否扩展坐标，如果为true，则将超出范围的坐标扩展到范围外
	 * @returns {Vector3} 转换后的墨卡托投影坐标(单位:米)
	 */
	projectCoordinate(input: Vector3, output?: Vector3, extend?: boolean): Vector3;
	/**
	 * 将Web墨卡托投影坐标转换为地理坐标(经纬度)
	 * @param {Vector3} input 输入的墨卡托投影坐标(单位:米)
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @param {boolean} [extend=false] 是否扩展坐标，如果为true，则将超出范围的坐标扩展到范围外
	 * @returns {Vector3} 转换后的地理坐标，x,y分别为经度和纬度
	 */
	unprojectCoordinate(input: Vector3, output?: Vector3, extend?: boolean): Vector3;
}
declare class Rectangle {
	constructor(west: any, south: any, east: any, north: any);
	west: any;
	south: any;
	east: any;
	north: any;
	/**
	 * Gets the width of the rectangle in radians.
	 * @memberof Rectangle.prototype
	 * @type {number}
	 * @readonly
	 */
	readonly get width(): number;
	/**
	 * Gets the height of the rectangle in radians.
	 * @memberof Rectangle.prototype
	 * @type {number}
	 * @readonly
	 */
	readonly get height(): number;
}
declare namespace Rectangle {
	function fromDegrees(west: any, south: any, east: any, north: any, result: any): any;
	/**
	 * Computes the width of a rectangle in radians.
	 * @param {Rectangle} rectangle The rectangle to compute the width of.
	 * @returns {number} The width.
	 */
	function computeWidth(rectangle: Rectangle): number;
	/**
	   * Computes the height of a rectangle in radians.
	   * @param {Rectangle} rectangle The rectangle to compute the height of.
	   * @returns {number} The height.
	   */
	function computeHeight(rectangle: Rectangle): number;
	function clone(rectangle: any, result: any): any;
	/**
	 * Computes the southwest corner of a rectangle.
	 *
	 * @param {Rectangle} rectangle The rectangle for which to find the corner
	 * @param {Vector3} [result] The object onto which to store the result.
	 * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
	 */
	function southwest(rectangle: Rectangle, result?: Vector3): Vector3;
	/**
	 * Computes the northeast corner of a rectangle.
	 *
	 * @param {Rectangle} rectangle The rectangle for which to find the corner
	 * @param {Vector3} [result] The object onto which to store the result.
	 * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
	 */
	function northeast(rectangle: Rectangle, result?: Vector3): Vector3;
	/**
	 * Computes the southeast corner of a rectangle.
	 *
	 * @param {Rectangle} rectangle The rectangle for which to find the corner
	 * @param {Vector3} [result] The object onto which to store the result.
	 * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
	 */
	function southeast(rectangle: Rectangle, result?: Vector3): Vector3;
	/**
	 * Computes the northwest corner of a rectangle.
	 *
	 * @param {Rectangle} rectangle The rectangle for which to find the corner
	 * @param {Vector3} [result] The object onto which to store the result.
	 * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
	 */
	function northwest(rectangle: Rectangle, result?: Vector3): Vector3;
	/**
	 * Computes the center of a rectangle.
	 *
	 * @param {Rectangle} rectangle The rectangle for which to find the center
	 * @param {Vector3} [result] The object onto which to store the result.
	 * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
	 */
	function center(rectangle: Rectangle, result?: Vector3): Vector3;
	/**
	 * Returns true if the cartographic is on or inside the rectangle, false otherwise.
	 *
	 * @param {Rectangle} rectangle The rectangle
	 * @param {Vector3} cartographic The cartographic to test.
	 * @returns {boolean} true if the provided cartographic is inside the rectangle, false otherwise.
	 */
	function contains(rectangle: Rectangle, cartographic: Vector3): boolean;
	function fromBox(box: any, result: any, restrict?: boolean): any;
	let MAX_VALUE: Readonly<Rectangle>;
}
declare class OrientedBoundingBox {
	constructor(center: any, halfAxes: any);
	isOrientedBoundingBox: boolean;
	/**
	 * The center of the box.
	 */
	center: any;
	/**
	 * The three orthogonal half-axes of the bounding box. Equivalently, the
	 * transformation matrix, to rotate and scale a 2x2x2 cube centered at the
	 * origin.
	 */
	halfAxes: any;
	intersectPlane(plane: any): number;
	distanceSquaredTo(cartesian: any): Interval;
	computeCorners(result: any): Cartesian3[];
	getCenter(result: any): any;
	/**
	 * 检测当前OBB是否与另一个OBB相交
	 * @param {OrientedBoundingBox} otherObb 另一个OBB
	 * @returns {boolean} 是否相交
	 */
	intersectsObb(otherObb: OrientedBoundingBox): boolean;
}
declare namespace OrientedBoundingBox {
	/**
	 * Computes an OrientedBoundingBox that bounds a {@link Rectangle} on the surface of an {@link Ellipsoid}.
	 * There are no guarantees about the orientation of the bounding box.
	 *
	 * @param {Rectangle} rectangle The cartographic rectangle on the surface of the ellipsoid.
	 * @param {number} [minimumHeight=0.0] The minimum height (elevation) within the tile.
	 * @param {number} [maximumHeight=0.0] The maximum height (elevation) within the tile.
	 * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the rectangle is defined.
	 * @param {OrientedBoundingBox} [result] The object onto which to store the result.
	 * @returns {OrientedBoundingBox} The modified result parameter
	 * or a new OrientedBoundingBox instance if none was provided.
	 *
	 * @exception {DeveloperError} rectangle.width must be between 0 and 2 * pi.
	 * @exception {DeveloperError} rectangle.height must be between 0 and pi.
	 * @exception {DeveloperError} ellipsoid must be an ellipsoid of revolution (<code>radii.x == radii.y</code>)
	 */
	function fromRectangle(rectangle: Rectangle, minimumHeight?: number, maximumHeight?: number, ellipsoid?: Ellipsoid, result?: OrientedBoundingBox): OrientedBoundingBox;
	/**
	 * The distances calculated by the vector from the center of the bounding box to position projected onto direction.
	 * <br>
	 * If you imagine the infinite number of planes with normal direction, this computes the smallest distance to the
	 * closest and farthest planes from position that intersect the bounding box.
	 *
	 * @param {OrientedBoundingBox} box The bounding box to calculate the distance to.
	 * @param {Cartesian3} position The position to calculate the distance from.
	 * @param {Cartesian3} direction The direction from position.
	 * @param {Interval} [result] A Interval to store the nearest and farthest distances.
	 * @returns {Interval} The nearest and farthest distances on the bounding box from position in direction.
	 */
	function distanceSquaredTo(box: OrientedBoundingBox, cartesian: any): Interval;
	function intersectPlane(box: any, plane: any): number;
	/**
	 * Computes the eight corners of an oriented bounding box. The corners are ordered by
	 * (-X, -Y, -Z), (-X, -Y, +Z), (-X, +Y, -Z), (-X, +Y, +Z), (+X, -Y, -Z), (+X, -Y, +Z), (+X, +Y, -Z), (+X, +Y, +Z).
	 *
	 * @param {OrientedBoundingBox} box The oriented bounding box.
	 * @param {Cartesian3[]} [result] An array of eight {@link Cartesian3} instances onto which to store the corners.
	 * @returns {Cartesian3[]} The modified result parameter or a new array if none was provided.
	 */
	function computeCorners(box: OrientedBoundingBox, result?: Cartesian3[]): Cartesian3[];
	function fromGeoBoundingBox(geoBoundingBox: any, result: any): OrientedBoundingBox;
}
/**
 * 地球中心地固坐标系(ECEF)投影，用于3D地球表示
 *
 * ECEF坐标系是一种以地球中心为原点的笛卡尔坐标系：
 * - X轴通过赤道面和本初子午线(0°经线)的交点
 * - Z轴通过北极
 * - Y轴与X和Z轴垂直，形成右手坐标系
 *
 * 特点：
 * - 坐标单位为米
 * - 可以精确表示地球曲面
 * - 适用于全球尺度的3D可视化
 * - 随地球自转而旋转
 *
 * 该投影主要用于：
 * - 3D地球表示
 * - 卫星轨道计算
 * - 精确的全球定位
 *
 * @category Internal
 */
export class ECEFProjection extends Projection {
	/**
	 * 投影名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
	/**
	 * 将地理边界框转换为投影坐标系边界框
	 * @param {Box3} geoBox 地理坐标系中的边界框
	 * @param {OrientedBoundingBox} [projectedBox] 可选的输出边界框，如不提供则创建新的OrientedBoundingBox
	 * @returns {OrientedBoundingBox} 投影坐标系中的有向边界框
	 */
	geoBoxToProjectedBox(geoBox: Box3, projectedBox?: OrientedBoundingBox): OrientedBoundingBox;
	/**
	 * 获取地理边界框的LOD缩放因子
	 * @param {Box3} geoBoundingBox 地理坐标系中的边界框
	 * @returns {number} LOD缩放因子
	 */
	getLODSacleOfGeoBoundingBox(geoBoundingBox: Box3): number;
	localFrameToFixedFrame(origin: any, fixedFrame: any): any;
}
/**
 * 地理经纬度投影，将经纬度坐标按比例缩放
 *
 * GeoProjection是最简单的投影方式，它仅将经纬度坐标按一定比例缩放，不改变坐标的拓扑关系。
 * 缩放系数为地球半径(6378137米)乘以π/180，将角度单位转换为近似的米单位。
 * 该投影主要用于：
 * - 简单的地理数据可视化
 * - 不要求高精度的场景
 * - 作为其他投影的基础
 *
 * @category Internal
 */
export class GeoProjection extends Projection {
	/**
	 * 投影名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
}
/**
 * 百度墨卡托投影，用于百度地图的坐标系统
 *
 * 百度墨卡托投影是基于Web墨卡托投影的变体，专用于百度地图服务。
 * 它对标准墨卡托投影进行了偏移和变换，使其与百度地图系统匹配。
 * 特点：
 * - 坐标系原点位于中国地区
 * - 坐标单位为米
 * - 与WGS84坐标系存在非线性偏移
 *
 * 该投影主要用于：
 * - 与百度地图服务对接
 * - 处理百度地图提供的数据
 * - 开发基于百度地图的应用
 *
 * @category Internal
 */
export class BaiduMercatorProjection extends Projection {
	/**
	 * 投影名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
	/**
	 * 将地理坐标(经纬度)转换为百度墨卡托投影坐标
	 * @param {Vector3} input 输入的地理坐标，x,y分别为经度和纬度
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @returns {Vector3} 转换后的百度墨卡托投影坐标(单位:米)
	 */
	projectCoordinate(input: Vector3, output?: Vector3, extend?: boolean): Vector3;
	/**
	 * 将百度墨卡托投影坐标转换为地理坐标(经纬度)
	 * @param {Vector3} input 输入的百度墨卡托投影坐标(单位:米)
	 * @param {Vector3} [output] 可选的输出向量，如不提供则创建新的Vector3
	 * @returns {Vector3} 转换后的地理坐标，x,y分别为经度和纬度
	 */
	unprojectCoordinate: (input: Vector3, output?: Vector3, extend: any) => Vector3;
}

export {
	Stats as RenderingStats,
};

export {};