import { AmbientLight, AnimationMixer, Box3, BoxGeometry, BufferGeometry, CameraHelper, CanvasTexture, CatmullRomCurve3, Clock, Color, CubeCamera, DataTexture, DepthTexture, DirectionalLight, Euler, EventDispatcher, Float32BufferAttribute, Group, InstancedBufferAttribute, Loader, Matrix3, Matrix4, Mesh, MeshBasicMaterial, Object3D, OrthographicCamera, Plane, PlaneGeometry, Scene, ShaderMaterial, Sphere, SphereGeometry, Texture, Vector2, Vector3, Vector4, WebGLCubeRenderTarget, 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);
}
declare 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;
}
declare 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;
}
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;
}
declare 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;
}
declare 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;
}
declare 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;
}
declare 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;
}
/**
 * 数据元素类，表示单个可渲染的数据项
 *
 * DataItem是数据源中的基本单元，用于存储和管理单个地理要素的数据。
 * 它支持多种几何类型（点、线、面）及其multi-*变体，并能处理不同投影之间的坐标转换。
 *
 * 每个DataItem包含：
 * - 几何数据：坐标信息
 * - 属性数据：与几何关联的业务数据
 * - 投影信息：坐标的参考系统
 *
 * @category DataSource
 * @example
 * ```javascript
 * // 创建一个点要素
 * const point = new DataItem({
 *   type: 'Feature',
 *   geometry: {
 *     type: 'Point',
 *     coordinates: [116.39, 39.9]
 *   },
 *   properties: {
 *     name: '北京',
 *     value: 100
 *   }
 * });
 *
 * // 创建一个线要素
 * const line = new DataItem({
 *   type: 'Feature',
 *   geometry: {
 *     type: 'LineString',
 *     coordinates: [
 *       [116.39, 39.9],
 *       [121.47, 31.23]
 *     ]
 *   },
 *   properties: {
 *     name: '北京-上海',
 *     value: 500
 *   }
 * });
 * ```
 */
export 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;
}
/**
 * 抽象数据源类，用来管理传入原始数据到面向渲染数据的流转过程
 * 数据源负责：
 * - 加载和解析原始数据
 * - 管理数据属性和着色器attribute映射
 * - 提供数据操作接口（添加、删除、修改）
 * - 生成可供渲染的数据结构
 *
 * 主要的子类包括：
 * - {@link GeoJSONDataSource} GeoJSON格式数据源
 * - {@link CSVDataSource} CSV格式数据源
 * - {@link JSONDataSource} JSON格式数据源
 *
 * @category DataSource
 * @example
 * ```javascript
 * // 创建一个基础数据源
 * const dataSource = new DataSource();
 *
 * // 创建多个数据项
 * const point1 = new DataItem([116.39, 39.9], { id: 'beijing', name: '北京', value: 100 });
 * const point2 = new DataItem([121.47, 31.23], { id: 'shanghai', name: '上海', value: 90 });
 *
 * // 添加数据项到数据源
 * dataSource.add(point1);
 * dataSource.add(point2);
 *
 * // 定义数据属性到着色器属性的映射
 * dataSource.defineAttributes({
 *   color: 'value',
 *   size: 'value',
 * });
 *
 * // 将数据源与可视化对象关联
 * const pointLayer = new SimplePoint({
 *   size: 10,
 *   color: 'red',
 *   vertexColors: true,
 *   vertexSizes: true,
 * });
 * pointLayer.dataSource = dataSource;
 * engine.add(pointLayer);
 * ```
 */
export 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[];
}
declare 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;
}
declare 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;
}
declare 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;
}
declare 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);
}
declare 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;
}
declare 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;
}
declare 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;
}
/**
 * 引擎核心入口，用来初始化渲染引擎。
 * 内部核心系统包括：
 * - {@link EngineMap} 地图视野系统
 * - {@link EngineRendering} 渲染系统
 * - {@link EngineEvent} 事件系统
 * - {@link EngineWidgets} UI控件系统
 * - {@link EngineSelection} 选择器系统
 * - {@link EngineController} 键鼠交互控制器系统
 * - {@link EngineClock} 时钟系统
 *
 * @category Core
 * @example
 * ```javascript
 * const engine = new Engine(container, options);
 * ```
 */
export class Engine {
	/**
	 *
	 * @param {HTMLElement} container 容器对象
	 * @param {object} options 配置选项
	 * @param {object} options.rendering 渲染选项，传入{@link EngineRendering.constructor}的参数
	 * @param {object} options.map 地图选项，传入 {@link EngineMap.constructor}的参数
	 * @param {object} options.event 事件选项，传入{@link EngineEvent.constructor}的参数
	 * @param {object} options.selection 选择器选项，传入{@link EngineSelection.constructor}的参数
	 * @param {object} options.widgets 控件选项，传入{@link EngineWidgets.constructor}的参数
	 */
	constructor(container: HTMLElement, options?: {
		rendering: object;
		map: object;
		event: object;
		selection: object;
		widgets: object;
	});
	/**
	 * 将object放到渲染场景中
	 * @param {Object3D} object threejs或者mapvthree的object对象
	 * @returns {Object3D} 返回添加的object对象
	 * @example
	 * ```javascript
	 * const object = new THREE.Mesh();
	 * engine.add(object);
	 * ```
	 * @example
	 * ```javascript
	 * engine.add(new mapvthree.SimplePoint());
	 * ```
	 */
	add(object: Object3D): Object3D;
	/**
	 * 将object从渲染场景中移除
	 * @param {Object3D} object threejs或者mapvthree的object对象
	 */
	remove(object: Object3D): void;
	/**
	 * 请求一次引擎渲染，此方法会让引擎在下一帧进行一次渲染
	 */
	requestRender(): void;
	/**
	 * 添加callback函数到函数列表中，每次渲染更新之前执行。
	 * 此函数的调用时机发生在渲染循环的开始阶段，所有真实渲染操作均还未执行，物体的所有属性均和通过API设置的一致。
	 * @param {Function} callback
	 * @example
	 * ```javascript
	 * engine.addPrepareRenderListener(() => {
	 *     console.log('prepare render');
	 * });
	 * ```
	 */
	addPrepareRenderListener(callback: Function): void;
	/**
	 * 添加callback函数到函数列表中，每次渲染前时执行。
	 * 此时引擎已经将内部的状态更新到最新状态，所有物体的属性均和渲染一致。比如，自动相机偏移已经完成，物体的transform可能已经变为相对于偏移后的相机的transform。
	 * @param {Function} callback
	 * @example
	 * ```javascript
	 * engine.addBeforeRenderListener(() => {
	 *    console.log('before render');
	 * });
	 * ```
	 */
	addBeforeRenderListener(callback: Function): void;
	/**
	 * 从函数列表中移除callback函数，在渲染更新时不再执行
	 * @param {Function} callback
	 */
	removeBeforeRenderListener(callback: Function): void;
	/**
	 * 从函数列表中移除callback函数，在渲染更新之前不再执行
	 */
	removePrepareRenderListener(callback: any): void;
	/**
	 * 渲染电影
	 * @param {VideoConfig} videoConfig 影片配置对象
	 */
	renderVideo(videoConfig: VideoConfig): Promise<void>;
	/**
	 * 容器对象
	 * @type {HTMLElement}
	 */
	get container(): HTMLElement;
	/**
	 * map对象
	 */
	get map(): EngineMap;
	/**
	 * rendering对象
	 */
	get rendering(): EngineRendering;
	/**
	 * UI控件对象
	 */
	get widgets(): EngineWidgets;
	/**
	 * renderer对象，实际为rendering.renderer的代理对象，此处仅为方便使用
	 * @type {WebGLRenderer}
	 */
	get renderer(): WebGLRenderer;
	/**
	 * 场景对象，实际为rendering.scene的代理对象，此处仅为方便使用
	 * @type {Scene}
	 */
	get scene(): Scene;
	/**
	 * 相机对象，实际为rendering.camera的代理对象，此处仅为方便使用
	 * @type {Camera}
	 */
	get camera(): Camera;
	/**
	 * 事件对象
	 */
	get event(): EngineEvent;
	/**
	 * 物体选择器
	 */
	get selection(): EngineSelection;
	/**
	 * 时钟对象，用于模拟时间
	 */
	get clock(): EngineClock;
	/**
	 * 键鼠交互控制器对象
	 */
	get controller(): EngineController;
	/**
	 * 引擎实例唯一ID
	 */
	get id(): number;
	/**
	 * 释放全部资源，之后引擎实例不再可用
	*/
	dispose(): void;
}
declare class GradientColorLerp {
	/**
	 * @param {Array} points
	 * points = [[0, new Color(0xffffff)], [1, new Color(0x000000)]]
	 *
	 */
	constructor(points: any[]);
	lerp(t: any, result: any): any;
}
/**
 * 空白天空，仅提供基本的天空和光照系统，包含日光、环境光和太阳位置控制，不包含天空背景的渲染。
 * 可以通过设置时间来改变光照方向和强度，模拟一天中不同时间的光照效果。
 *
 * 如果想要使用背景效果更好的天空，可以使用{@link DefaultSky}或者{@link DynamicSky}
 *
 * @category Natural
 * @example
 * ```javascript
 * // 创建空白天空
 * const sky = engine.add(new mapvthree.EmptySky());
 *
 * // 设置时间为中午12点
 * sky.time = 3600 * 12;
 * ```
 */
export class EmptySky extends Group<import("three").Object3DEventMap> {
	/**
	 * 创建一个空白天空实例
	 * 初始化光照系统，包括太阳光源和环境
	 * @param {object} options
	 * @param {number} options.time 初始时间， 单位秒。例如：3600 * 15.5代表15点30分
	 */
	constructor(options?: {
		time: number;
	});
	/**
	 * 标识为EmptySky对象
	 * @type {boolean}
	 * @readonly
	 */
	readonly isEmptySky: boolean;
	sunLight: DirectionalLight;
	skyLight: AmbientLight;
	set envLightIntensity(value: number);
	get envLightIntensity(): number;
	/**
	 * 添加到引擎后的初始化
	 * @protected
	 * @param {Engine} engine 引擎实例
	 */
	protected afterAddToEngine(engine: Engine): void;
	engine: Engine;
	/**
	 * 从引擎移除前的清理
	 * @protected
	 * @param {Engine} engine 引擎实例
	 */
	protected beforeRemoveFromEngine(engine: Engine): void;
	/**
	 * 每次渲染时，更新时间和光照
	 * @protected
	 */
	protected onBeforeScenePrepareRender(): void;
	/**
	 * 根据太阳光的高度来更新太阳光和天空光的光照强度和颜色
	 * @protected
	 */
	protected updateLight(): void;
	/**
	 * 更新太阳阴影
	 * @protected
	 */
	protected updateSunLightShadowCamera: () => void;
	/**
	 * 添加时间变化后需要执行的监听函数listener
	 * @param {Function} listener
	 */
	addTimeChangedListener(listener: Function): void;
	/**
	 * 从时间变化后需要执行的监听函数的列表中移除listener
	 * @param {Function} listener
	 */
	removeTimeChangedListener(listener: Function): void;
	getPresetWeatherProperties(weather: any): any;
	/**
	 * 释放资源
	 */
	dispose(): void;
	/**
	 * 设置时间，更新太阳光源位置与光照强度，单位是秒<br />
	 * 通常可以设置成小时*3600，比如 12 * 3600 表示中午12点
	 * @type {number}
	 * @example
	 * ```javascript
	 * // 设置时间为早上8点
	 * sky.time = 3600 * 8;
	 *
	 * // 设置时间为下午6点
	 * sky.time = 3600 * 18;
	 * ```
	 */
	set time(time: number);
	/**
	 * 获取当前设置的时间
	 * @type {number}
	 */
	get time(): number;
	set sunIntensityBias(value: number);
	get sunIntensityBias(): number;
	set sunIntensityScale(value: number);
	get sunIntensityScale(): number;
	set sunLightIntensity(value: number);
	get sunLightIntensity(): number;
	set skyLightIntensity(value: number);
	get skyLightIntensity(): number;
	set skyLightAttenuationRatio(value: number);
	get skyLightAttenuationRatio(): number;
	get sunDirection(): Vector3;
	get localSunDirection(): Vector3;
	get affectWorld(): boolean;
}
declare class HeadingPitchRange {
	constructor(heading: any, pitch: any, range: any);
	heading: any;
	pitch: any;
	range: any;
	clone(hpr: any, result: any): any;
}
declare class EllipsoidCamera {
	static DEFAULT_VIEW_RECTANGLE: any;
	static DEFAULT_VIEW_FACTOR: number;
	static DEFAULT_OFFSET: HeadingPitchRange;
	constructor(scene: any);
	position: Vector3;
	positionWCDeltaMagnitude: number;
	positionWCDeltaMagnitudeLastFrame: number;
	timeSinceMoved: number;
	direction: Vector3;
	up: Vector3;
	right: Vector3;
	defaultMoveAmount: number;
	defaultLookAmount: number;
	defaultRotateAmount: number;
	defaultZoomAmount: number;
	constrainedAxis: any;
	maximumZoomFactor: number;
	percentageChanged: number;
	canPreloadFlight(): boolean;
	setView(options: any): void;
	lookAt(target: any, offset: any): void;
	lookAtTransform(transform: any, offset: any): void;
	move(direction: any, amount: any): void;
	moveForward(amount: any): void;
	moveBackward(amount: any): void;
	moveUp(amount: any): void;
	moveDown(amount: any): void;
	moveRight(amount: any): void;
	moveLeft(amount: any): void;
	/**
	 * 绕着point，以axis为旋转轴，旋转angle
	 */
	rotateAroundPoint(point: any, axis: any, angle: any): void;
	zoomIn(amount: any): void;
	rotate(axis: any, angle: any): void;
	rotateDown(angle: any): void;
	rotateUp(angle: any): void;
	rotateRight(angle: any): void;
	rotateLeft(angle: any): void;
	look(axis: any, angle: any): void;
	lookLeft(amount: any): void;
	lookRight(amount: any): void;
	lookUp(amount: any): void;
	lookDown(amount: any): void;
	getPickRay(windowPosition: any, result: any): any;
	pickEllipsoid(windowPosition: any, ellipsoid: any, result: any): any;
	worldToCameraCoordinates(cartesian: any, result: any): any;
	worldToCameraCoordinatesPoint(cartesian: any, result: any): any;
	cancelFlight(): void;
	/**
	 * Completes the current camera flight and moves the camera immediately to its final destination.
	 * If no flight is in progress, this this function does nothing.
	 */
	completeFlight(): void;
	flyTo(options: any): void;
	flyHome(duration: any): void;
	getRectangleCameraCoordinates(rectangle: any, result: any): any;
	update(): void;
	clone(camera: any, result: any): any;
	getLocalTransform(): Matrix4;
	get transform(): Matrix4;
	get inverseTransform(): Matrix4;
	get viewMatrix(): Matrix4;
	get inverseViewMatrix(): Matrix4;
	get positionCartographic(): Vector3;
	get positionWC(): Vector3;
	get directionWC(): Vector3;
	get upWC(): Vector3;
	get rightWC(): Vector3;
	get heading(): number;
	get pitch(): number;
	get roll(): number;
	get moveStart(): any;
	get moveEnd(): any;
	get changed(): any;
}
declare class SkyAtmospherePass extends Pass {
	uniforms: {
		tDiffuse: {
			value: any;
		};
		tDepth: {
			value: any;
		};
		tNormal: {
			value: any;
		};
		tAtmosphere: {
			value: any;
		};
		cameraNear: {
			value: number;
		};
		cameraFar: {
			value: number;
		};
		projectionInverseMatrix: {
			value: Matrix4;
		};
		viewInverseMatrix: {
			value: Matrix4;
		};
		mvt_viewMatrix: {
			value: Matrix4;
		};
		cameraPosition: {
			value: Vector3;
		};
		altitude: {
			value: number;
		};
		viewHeight: {
			value: number;
		};
		transmittanceTexture: {
			value: any;
		};
		transmittanceResolution: {
			value: number[];
		};
		scatteringTexture: {
			value: any;
		};
		scatteringResolution: {
			value: number[];
		};
		viewTexture: {
			value: any;
		};
		viewResolution: {
			value: number[];
		};
		resolution: {
			value: number[];
		};
		cameraDirection: {
			value: Vector3;
		};
		sunDirection: {
			value: Vector3;
		};
		upDirection: {
			value: Vector3;
		};
		isGlobe: {
			value: boolean;
		};
		fogDepthRange: {
			value: import("three").Vector2;
		};
		rotationMatrix: {
			value: Matrix3;
		};
	};
	material: ShaderMaterial;
	fsQuad: FullScreenQuad;
	needsDepthTexture: boolean;
	needsNormalTextureWhenMRT: boolean;
	/**
	 * 渲染天空盒子
	 * @param renderer 渲染器
	 * @param writeBuffer 替换缓冲
	 * @param readBuffer 读取缓冲
	 * @param deltaTime 时间差
	 * @param maskActive 是否激活蒙版
	 */
	render(renderer: any, writeBuffer: any, readBuffer: any): void;
	getCurrentUsedTextures(): any[];
}
declare class VolumetricCloudsPass extends Pass {
	constructor(parameters?: {});
	needsDepthTexture: boolean;
	render(renderer: any, writeBuffer: any, readBuffer: any, deltaTime: any, maskActive: any): void;
	isStable: boolean;
	getCurrentUsedTextures(): import("three").Texture[];
	set coverage(value: number);
	get coverage(): number;
	set density(value: number);
	get density(): number;
	set speed(value: number);
	get speed(): number;
	set sunColor(value: Vector3);
	get sunColor(): Vector3;
	set sunDirection(value: Vector3);
	get sunDirection(): Vector3;
	set ambientColorBottom(value: Vector3);
	get ambientColorBottom(): Vector3;
	set shapeBaseScale(value: number);
	get shapeBaseScale(): number;
	set shapeDetailScale(value: number);
	get shapeDetailScale(): number;
	set useVolumetric(value: boolean);
	get useVolumetric(): boolean;
	set marchSteps(value: any);
	get marchSteps(): any;
	set selfShadowSteps(value: any);
	get selfShadowSteps(): any;
}
declare class SkyAtmosphere extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
	constructor();
	set altitude(value: any);
	get altitude(): any;
	onBeforeRender(renderer: any, scene: any, camera: any): void;
	updateRenderTargets(renderer: any, camera: any): void;
	dispose(): void;
	set viewHeight(value: any);
	get viewHeight(): any;
	set mixGrayFactor(value: any);
	get mixGrayFactor(): any;
}
/**
 * 动态天空继承自 {@link EmptySky}，提供高级的大气层渲染、光照变化和云层效果，可以根据时间自动变化光照和天空外观。
 * 支持体积云、大气散射以及环境反射烘培，为3D场景提供真实感的天空和照明效果。
 *
 * @category Natural
 * @example
 * ```javascript
 * // 创建动态天空
 * const sky = engine.add(new mapvthree.DynamicSky());
 *
 * // 设置时间为下午5:30
 * sky.time = 3600 * 17.5;
 * ```
 */
export class DynamicSky extends EmptySky {
	/**
	 * 标识为DynamicSky对象
	 * @type {boolean}
	 * @readonly
	 */
	readonly isDynamicSky: boolean;
	/**
	 * 天空名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
	set useVolumetricClouds(value: boolean);
	get useVolumetricClouds(): boolean;
	set affectWorld(value: boolean);
	get affectWorld(): boolean;
	set mixGrayFactor(value: number);
	get mixGrayFactor(): number;
	set realtimeCapture(value: boolean);
	get realtimeCapture(): boolean;
	get skyAtmosphere(): SkyAtmosphere;
	set clipUnderground(value: boolean);
	get clipUnderground(): boolean;
	set enableAtmospherePass(value: boolean);
	get enableAtmospherePass(): boolean;
	set enableCloudsPass(value: boolean);
	get enableCloudsPass(): boolean;
	set cloudsCoverage(value: number);
	get cloudsCoverage(): number;
	set cloudDensity(value: number);
	get cloudDensity(): number;
	set cloudsSpeed(value: number);
	get cloudsSpeed(): number;
	set cloudShapeBaseScale(value: number);
	get cloudShapeBaseScale(): number;
	set cloudShapeDetailScale(value: number);
	get cloudShapeDetailScale(): number;
	set cloudMarchSteps(value: number);
	get cloudMarchSteps(): number;
	set cloudSelfShadowSteps(value: number);
	get cloudSelfShadowSteps(): number;
	get upDirection(): Vector3;
	set cloudsBaseHeight(value: number);
	get cloudsBaseHeight(): number;
}
/**
 * 默认天空效果，提供简单的渐变天空效果，是性能开销与效果比较平衡的天空。
 *
 * DefaultSky类是{@link EmptySky}的扩展，添加了一个梯度天空后处理通道，可以创建简单的渐变天空效果，适用于不需要高级天空效果的场景。
 *
 * 如果需要更复杂的天空效果，可以使用{@link DynamicSky}
 *
 * @category Natural
 * @example
 * ```javascript
 * const sky = engine.add(new mapvthree.DefaultSky());
 * sky.color = new THREE.Color(0x87ceeb); // 设置天空基础颜色
 * sky.highColor = new THREE.Color(0x67ceeb); // 设置天空高处颜色
 * ```
 */
export class DefaultSky extends EmptySky {
	/**
	 * 标识为DefaultSky
	 * @type {boolean}
	 * @readonly
	 */
	readonly isDefaultSky: boolean;
	/**
	 * 天空名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
	/**
	 * 设置天空高处颜色
	 * @type {Color}
	 */
	set highColor(color: Color);
	/**
	 * 获取天空高处颜色
	 * @type {Color}
	 */
	get highColor(): Color;
	/**
	 * 设置天空基础颜色
	 * @type {Color}
	 */
	set color(color: Color);
	/**
	 * 获取天空基础颜色
	 * @type {Color}
	 */
	get color(): Color;
	set enablePostPass(value: boolean);
	get enablePostPass(): boolean;
}
declare class CustomStaticSky extends EmptySky {
	constructor(options?: {});
	isCustomStaticSky: boolean;
	set isVerticalTexture(value: any);
	get isVerticalTexture(): any;
	/** @protected */
	protected afterAddToEngine(engine: any): void;
	/** @protected */
	protected onBeforeScenePrepareRender(engine: any, scene: any, camera: any): void;
	set textureIsCube(value: boolean);
	get textureIsCube(): boolean;
	set textureURL(value: any);
	/**
	 * 自定义天空贴图url
	 */
	get textureURL(): any;
	set affectWorld(value: boolean);
	get affectWorld(): boolean;
}
/**
 * 静态天空，预置了常见的天气状态和时段状态
 * 根据时间和天气自动切换不同的天空纹理贴图，提供基础的天空渲染效果。
 * 相比 {@link DynamicSky}，静态天空性能更好但效果相对简单。
 *
 * @category Natural
 * @example
 * ```javascript
 * // 创建静态天空
 * const sky = engine.add(new mapvthree.StaticSky());
 *
 * // 设置时间为下午5:30
 * sky.time = 3600 * 17.5;
 * ```
 */
export class StaticSky extends CustomStaticSky {
	/**
	 * 标识为StaticSky对象
	 * @type {boolean}
	 * @readonly
	 */
	readonly isStaticSky: boolean;
	/**
	 * 天空名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
}
declare class LightningBillboardMaterial extends ShaderMaterial {
	constructor(parameters?: {});
}
declare class Thunderstorm extends Object3D<import("three").Object3DEventMap> {
	constructor(renderer: any, camera: any, options?: {});
	sceneSize: any;
	update(engine: any): void;
	set density(value: number);
	get density(): number;
	dispose(): void;
}
/**
 * 动态天气系统，提供多种天气效果模拟，包括晴天、多云、雪、雨和雾等，并支持天气效果之间的平滑过渡。
 * 会调整光照强度、云密度、雾密度以及各种视觉效果来模拟不同的天气状态。
 * 需要基于 {@link DynamicSky} 使用。
 *
 * 支持的天气类型包括：
 * - `clear`: 晴天
 * - `partlyCloudy`: 局部多云
 * - `cloudy`: 多云
 * - `overcast`: 阴天
 * - `foggy`: 雾天
 * - `rainy`: 雨天
 * - `snowy`: 雪天
 * - `stormy`: 暴雨天
 * - `thunderstorm`: 雷阵雨
 *
 * @category Natural
 * @example
 * ```javascript
 * // 创建动态天气系统
 * const weather = engine.add(new mapvthree.DynamicWeather(sky));
 *
 * // 设置为下雪天气
 * weather.weather = 'snowy';
 *
 * // 设置天气过渡时间（毫秒）
 * weather.transitionDuration = 2000;
 * ```
 */
export class DynamicWeather extends Object3D<import("three").Object3DEventMap> {
	/**
	 * 创建一个动态天气实例
	 * @param {DynamicSky} sky 关联的动态天空实例
	 */
	constructor(sky: DynamicSky);
	/**
	 * 天气变化过渡的持续时间(毫秒)
	 * @type {number}
	 * @example
	 * ```javascript
	 * // 设置天气过渡时间为2秒
	 * weather.transitionDuration = 2000;
	 * ```
	 */
	transitionDuration: number;
	/**
	 * 设置天气类型
	 * @type {string}
	 * @example
	 * ```javascript
	 * // 设置为晴天
	 * weather.weather = 'clear';
	 *
	 * // 设置为雨天
	 * weather.weather = 'rainy';
	 * ```
	 */
	set weather(weather: string);
	/**
	 * 获取当前天气类型
	 * @type {string}
	 * @example
	 * ```javascript
	 * // 获取当前天气
	 * const currentWeather = weather.weather;
	 * ```
	 */
	get weather(): string;
	/**
	 * 添加到引擎后的初始化
	 * @param {Engine} engine 引擎实例
	 * @protected
	 */
	protected afterAddToEngine(engine: Engine): void;
	/**
	 * 从引擎移除前的清理
	 * @param {Engine} engine 引擎实例
	 * @protected
	 */
	protected beforeRemoveFromEngine: (engine: Engine) => void;
	/**
	 * 添加天气变化监听器
	 * @param {Function} listener 监听器函数
	 * @example
	 * ```javascript
	 * // 添加天气变化监听
	 * weather.addWeatherChangedListener((weatherType) => {
	 *     console.log('天气变为:', weatherType);
	 * });
	 * ```
	 */
	addWeatherChangedListener(listener: Function): void;
	/**
	 * 移除天气变化监听器
	 * @param {Function} listener 监听器函数
	 */
	removeWeatherChangedListener(listener: Function): void;
	set sunLightIntensity(value: number);
	get sunLightIntensity(): number;
	set cloudIntensity(value: number);
	get cloudIntensity(): number;
	set skyLightIntensity(value: number);
	get skyLightIntensity(): number;
	set groundColor(value: Color);
	get groundColor(): Color;
	set mixGrayFactor(value: number);
	get mixGrayFactor(): number;
	set coverageIntensity(value: number);
	get coverageIntensity(): number;
	set tCoverageIntensity(value: Texture);
	get tCoverageIntensity(): Texture;
	set tRelectionEnhancement(value: Texture);
	get tRelectionEnhancement(): Texture;
	set fogDensity(value: number);
	get fogDensity(): number;
	set skyLightScale(value: number);
	get skyLightScale(): number;
	set sunLightScale(value: number);
	get sunLightScale(): 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>;
}
declare 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 SurfaceTileManager {
	constructor(surface: any);
	beginFrame(renderState: any): void;
	endFrame(renderState: any): void;
	getSurfaceTile(tile: any, renderState: any): void;
	requestSurfaceTile(tile: any): void;
	cancelSurfaceTiles(tile: any): void;
	dispose(): void;
	get pendingCount(): number;
}
declare class RasterSurfaceTileManager extends SurfaceTileManager {
	forceUpdateTileState(tile: any): void;
	isTileComputable(tile: any, renderState: any): boolean;
	isTileRenderable(tile: any, renderState: any): boolean;
	isTileStable(tile: any, renderState: any): boolean;
	markTileUsed(tile: any): any;
	getSurfaceTile(tile: any, renderState: any): any;
	requestSurfaceTile(tile: any, onlyRequestToRenderable?: boolean): void;
	clear(): void;
}
/**
 * 地形、影像瓦片数据加载的surface，用于加载地形、影像瓦片数据<br/>
 *
 * @category MapView
 * @example
 * ```javascript
 * const rasterSurface = new RasterSurface(terrainProvider, imageryProviders);
 * const mapView = engine.add(new MapView());
 * mapView.addSurface(rasterSurface);
 * ```
 */
export class RasterSurface extends MapSurface {
	/**
	 * @param {TerrainProvider} terrainProvider - 地形提供者
	 * @param {ImageryProvider[]} imageryProviders - 影像提供者
	 * @param {Object} options - 选项参数
	 */
	constructor(terrainProvider: TerrainProvider, imageryProviders: ImageryProvider[], options?: any);
	isMapRasterSurface: boolean;
	addImageryLayer(imageProvider: any): void;
	removeImageryLayer(imageProvider: any): void;
	/**
	 * 设置地形提供者
	 */
	set terrainProvider(terrainProvider: TerrainProvider);
	/**
	 * 获取地形提供者
	 */
	get terrainProvider(): TerrainProvider;
	/**
	 * 设置影像提供者
	 */
	set imageryProviders(imageryProviders: ImageryProvider[]);
	/**
	 * 获取影像提供者
	 */
	get imageryProviders(): ImageryProvider[];
}
declare class VectorSurfaceTileManager extends SurfaceTileManager {
	markTileUsed(tile: any): any;
	isTileComputable(tile: any, renderState: any): boolean;
	isTileStable(tile: any, renderState: any): boolean;
	/**
	 * 更新图形对象
	 *
	 * @param data 数据信息，包含需要更新的图形对象数据及其状态等信息。
	 */
	getSurfaceTile(tile: any, renderState: any): any;
	clear(): void;
}
/**
 * 矢量瓦片数据加载的surface，用于加载矢量瓦片数据<br/>
 * vector surface需要将原始矢量数据转换到map的投影模式，但网格以tileProvider原始数据为准
 *
 * @category MapView
 * @example
 * ```javascript
 * const mapView = engine.add(new MapView());
 * const vectorSurface = new VectorSurface(vectorTileProvider);
 * mapView.addSurface(vectorSurface);
 * ```
 */
export class VectorSurface extends MapSurface {
	/**
	 * @param {VectorProvider} vectorTileProvider - 矢量提供者
	 * @param {Object} options - 选项参数
	 */
	constructor(vectorTileProvider: VectorProvider, options?: any);
	isMapVectorSurface: boolean;
	/**
	 * 设置矢量提供者
	 */
	set tileProvider(tileProvider: VectorProvider);
	/**
	 * 获取矢量提供者
	 */
	get tileProvider(): VectorProvider;
}
/**
 * 地图视图<br/>
 * 用于承载地图底图数据的容器视图，支持多种瓦片数据加载，包括地形、影像、矢量等<br/>
 * 开发者可以调用`addSurface`方法添加自定义瓦片数据加载，也可以调用`removeSurface`方法移除瓦片数据加载<br/>
 * surface包括：
 * - {@link RasterSurface}：用于加载地形、影像等瓦片数据<br/>
 * - {@link VectorSurface}：用于加载矢量数据<br/>
 * surface具体的数据由{@link TileProvider}提供，开发者可以传入自定义的{@link TileProvider}实现自定义瓦片数据加载<br/>
 *
 * @category MapView
 * @example
 * ```javascript
 * const mapView = new MapView();
 * engine.add(mapView);
 * mapView.addSurface(new RasterSurface(terrainProvider, imageryProviders));
 * ```
 */
export class MapView extends Object3D<import("three").Object3DEventMap> {
	/**
	 * @param {Object} options 选项参数
	 * @param {RasterSurface} options.rasterSurface - raster surface，如果提供，terrainProvider和imageryProviders无效
	 * @param {TerrainProvider} options.terrainProvider - 地形提供者，如果不提供，则默认使用{@link PlaneTerrainTileProvider}
	 * @param {ImageryProvider[]} options.imageryProviders - 影像提供者，如果不提供，则默认使用{@link BingImageryTileProvider}
	 * @param {VectorSurface} options.vectorSurface - vector surface，如果提供，vectorProvider无效
	 * @param {VectorProvider} options.vectorProvider - 矢量提供者
	 * @param {Object} options.vectorSurfaceOptions - vector surface选项，将传入{@link VectorSurface.constructor}
	 */
	constructor(options?: {
		rasterSurface: RasterSurface;
		terrainProvider: TerrainProvider;
		imageryProviders: ImageryProvider[];
		vectorSurface: VectorSurface;
		vectorProvider: VectorProvider;
		vectorSurfaceOptions: any;
	});
	isQuadMap: boolean;
	supportRenderPassCallbacks: boolean;
	/**
	 * 添加一层surface
	 * */
	addSurface(surface: any): void;
	/**
	 * 添加一层地形、影像瓦片数据加载的surface
	 * @param {TerrainProvider} terrainProvider - 地形提供者
	 * @param {ImageryProvider[]} imageryProviders - 影像提供者
	 * @param {Object} options - 选项参数
	 * @returns {RasterSurface} 返回添加的surface
	 */
	addRasterSurface(terrainProvider: TerrainProvider, imageryProviders: ImageryProvider[], options: any): RasterSurface;
	/**
	 * 添加一层矢量瓦片数据加载的surface
	 * @param {VectorProvider} vectorProvider - 矢量提供者
	 * @param {Object} options - 选项参数
	 * @returns {VectorSurface} 返回添加的surface
	 */
	addVectorSurface(vectorProvider: VectorProvider, options: any): VectorSurface;
	/**
	 * 移除一层surface
	 * @param {Surface} surface - 要移除的surface
	 */
	removeSurface(surface: Surface): void;
	setTerrainProvider(terrainProvider: any): void;
	setImageryProviders(imageryProviders: any): void;
	setImageryProvider(imageryProvider: any): void;
	setVectorProvider(vectorProvider: any, vectorSurfaceOptions: any): void;
	getImageryProviders(): ImageryProvider[];
	/**
	 * @protected
	 * 创建瓦片加载器
	*/
	protected createTileLoader(): void;
	/**
	 * @protected
	 */
	protected createGrid(engine: any): void;
	/**
	 * @protected
	 * 添加到engine中时创建瓦片加载器和格网
	 */
	protected afterAddToEngine(engine: any): void;
	beforeRemoveFromEngine(engine: any): void;
	/**
	 * @protected
	 * 每次渲染前判断瓦片加载器是否准备好及能否更新瓦片，重新获取可见瓦片并刷新视图
	 * @param {Engine} engine
	 * @param {Object3D} scene
	 * @param {Camera} camera
	 * @param {object} renderState
	 * @returns
	 */
	protected onBeforeScenePrepareRender(engine: Engine, scene: Object3D, camera: Camera, renderState: object): void;
	onBeforeSceneRender(engine: any, scene: any, camera: any, renderState: any): void;
	onAfterColorPass: (engine: any) => void;
	onAfterMainPass: (engine: any) => void;
	/**
	 * 刷新瓦片数据，用于更新一些瓦片状态，如路况图层
	 */
	refresh(): void;
	getKeyByValue: (obj: any, value: any) => string;
	/**
	 * @protected
	 */
	protected onTileAdded(tile: any): void;
	/**
	 * @protected
	 */
	protected onTileRemoved(tile: any): void;
	/**
	 * @protected
	 */
	protected onTileDisposed(tile: any): void;
	getTileProvidersByName(name: any): any[];
	/**
	 * 销毁mapView
	 */
	dispose(): void;
	printSurfacesStatistics(): void;
	showCameraFrustum(): void;
	destroyCameraHelper(): void;
	isInStableRenderState(): boolean;
	/**
	 * 设置是否允许瓦片更新
	 */
	set freezeUpdate(value: boolean);
	/**
	 * 是否允许瓦片更新
	 */
	get freezeUpdate(): boolean;
	/**
	 * 设置细节层次缩放值
	 */
	set lodScaleFactor(value: number);
	/**
	 * 细节层次缩放值
	 */
	get lodScaleFactor(): number;
	set cameraFarRatio(value: number);
	get cameraFarRatio(): number;
	/**
	 * 获取地形瓦片数据加载的surface
	 */
	get rasterSurface(): RasterSurface;
	/**
	 * 获取矢量瓦片数据加载的surface
	 */
	get vectorSurface(): VectorSurface;
	/**
	 * 获取所有surface
	 */
	get surfaces(): any[];
}
declare const TILELOADER_STRATEGY_FAST: "fast";
declare const TILELOADER_STRATEGY_HIERARCHICAL: "hierarchical";
declare const MAP_GRID_NAME_GEO: "geo";
declare const MAP_GRID_NAME_WEB_MERCATOR: "web_mercator";
declare const MAP_GRID_NAME_BD_VECTOR_ONLINE: "bd_vector_online";
declare const MAP_GRID_NAME_BD_VECTOR_OFFLINE: "bd_vector_offline";
declare const MAP_GRID_NAME_BD_LANE_VECTOR: "bd_lane_vector";
declare const BING_MAP_STYLE_AERIAL: "Aerial";
declare const BING_MAP_STYLE_AERIAL_WITH_LABELS: "AerialWithLabels";
declare const BING_MAP_STYLE_ROAD: "Road";
declare const STADIA_MAP_STYLE_STAMEN_WATERCOLOR: "StamenWatercolor";
declare const STADIA_MAP_STYLE_STAMEN_TONER: "StamenToner";
declare const STADIA_MAP_STYLE_ALIDE_SMOOTH: "AlidadeSmooth";
declare const STADIA_MAP_STYLE_ALIDE_SMOOTH_DARK: "AlidadeSmoothDark";
declare const STADIA_MAP_STYLE_OUTDOORS: "Outdoors";
declare class Strategy {
	constructor(options?: {});
	endFrame(): void;
	computeTiles(engine: any, cameraPosition: any, frustum: any, renderState: any, focusPosition: any): {
		selectedTiles: any[];
		requestTilesQueue: any[];
	};
	get surface(): any;
}
declare class MapTileRenderState {
	static STATE_IN_FRUSTUM: number;
	static STATE_NOT_READY: number;
	static STATE_RENDERED: number;
	static STATE_CHILD_RENDERED: number;
	static STATE_FORCE_KEEP: number;
	static STATE_RENDER_READY: number;
	state: number;
	setInFrustum(): void;
	setNotReady(): void;
	setRendered(): void;
	setChildRendered(): void;
	setForceKeep(): void;
	setRenderReady(): void;
	clearInFrustum(): void;
	clearNotReady(): void;
	clearRendered(): void;
	clearChildRendered(): void;
	clearForceKeep(): void;
	clearRenderReady(): void;
	isInFrustum(): boolean;
	isNotReady(): boolean;
	isRendered(): boolean;
	isChildRendered(): boolean;
	isForceKeep(): boolean;
	isRenderReady(): boolean;
}
export class FastTileLoaderStrategy extends Strategy {
	isFastTileLoaderStrategy: boolean;
	initDebugMeshes(): void;
	mesh: Mesh<SphereGeometry, MeshBasicMaterial, import("three").Object3DEventMap>;
	mesh1: Mesh<SphereGeometry, MeshBasicMaterial, import("three").Object3DEventMap>;
	mesh2: Mesh<SphereGeometry, MeshBasicMaterial, import("three").Object3DEventMap>;
	/**
	 * 判断当前瓦片是否是指定祖先瓦片的子瓦片
	 * @param {MapTile} currentTile 当前待检测瓦片
	 * @param {MapTile} ancestorTile 祖先瓦片
	 * @returns {boolean} 是否是子瓦片
	 */
	/**
	 * 获取主视野区域的地理坐标范围，比 engine.map 的方式更激进
	 * @returns {Box3} 地理坐标范围，坐标为投影坐标
	 */
	getViewportBounds(engine: any): Box3;
	/**
	 * 根据俯仰角计算NDC坐标的Y值因子，用于调整视角倾斜时的屏幕空间坐标。
	 * @param {number} pitch 俯仰角度，单位为度
	 * @param {number} threshold 俯仰角度的阈值，默认值为30度
	 * @param {number} scaleFactor 控制主视野区域往近衰减速度，默认值为0.3
	 * @returns {number} NDC坐标的Y值因子
	 */
	getNdcYFactor(pitch: number, threshold?: number, scaleFactor?: number): number;
	computeTiles(engine: any, cameraPosition: any, frustum: any, renderState: any): {
		selectedTiles: any[];
		requestTilesQueue: any[][];
		placeholderTiles: any[];
	};
	/**
	 * 计算主视口区域内瓦片的加权层级
	 * @param {Array} tiles 主视口内的瓦片
	 * @param {Map} viewportTilesMap 存储瓦片权重信息的Map
	 * @returns {number} 返回加权后的目标层级
	 */
	calcViewportWeightedZLevel(tiles: any[], viewportTilesMap: Map<any, any>): number;
	/**
	 * 计算主视野区域内的瓦片
	 * @param {Box3} projectionBounds 主视野区域的地理坐标范围
	 * @param {Frustum} frustum 视锥体
	 * @param {Vector3} cameraPosition 相机位置
	 * @param {Array} tiles 瓦片数组
	 * @param {Array} viewportTiles 主视野内的瓦片数组
	 */
	/**
	 * 使用 Sutherland-Hodgman 算法将多边形裁剪到视口范围 [-1, 1]
	 * @param {Array<[number, number]>} vertices 输入顶点数组
	 * @returns {Array<[number, number]>|null} 裁剪后的顶点数组，如果完全在视口外则返回null
	 */
	clipPolygonToViewport(vertices: Array<[
		number,
		number
	]>): Array<[
		number,
		number
	]> | null;
	getPolygonArea(vertices: any): number;
	set showDebug(value: boolean);
	get showDebug(): boolean;
	set restrictViewportLevel(value: any);
	get restrictViewportLevel(): any;
}
export class HierarchicalTileLoaderStrategy extends Strategy {
	isHierarchicalTileLoaderStrategy: boolean;
	computeTiles(engine: any, cameraPosition: any, frustum: any, renderState: any): {
		selectedTiles: any[];
		requestTilesQueue: any[][];
		placeholderTiles: any[];
	};
	/**
	 * @param {*} cameraPosition
	 * @param {*} frustum
	 * @param {*} tile
	 * @param {*} selectedTiles
	 * @param {*} requestTiles
	 * @param {*} requestSiblingTiles
	 * @param {*} renderState
	 * @returns true 瓦片可渲染， false 瓦片不可渲染 undefined 瓦片不在视野里
	 */
}
/**
 * 瓦片提供者，负责瓦片数据的请求和缓存 <br/>
 * 该类是所有瓦片提供者的**抽象基类，不可直接使用，需要使用子类。**
 *
 * @category Internal
 */
export class TileProvider {
	/**
	 * @param {object} options 配置
	 * @param {Projection} options.targetProjection 目标投影
	 * @param {number} options.minLevel 瓦片最小展示层级
	 * @param {number} options.maxLevel 瓦片最大展示层级
	 * @param {number} options.startLevel 网格的初始层级
	 * @param {number} options.maxCacheSize 最大缓存大小
	 */
	constructor(options?: {
		targetProjection: Projection;
		minLevel: number;
		maxLevel: number;
		startLevel: number;
		maxCacheSize: number;
	});
	name: string;
	/**
	 * 是否可见
	 */
	visible: boolean;
	statistics: {
		loading: number;
		cached: number;
	};
	/**
	 * 初始化网格和投影，可根据需要在子类中重写
	 */
	initProjectionAndGrid(): void;
	beginFrame(renderState: any): void;
	endFrame(renderState: any): void;
	isReady(): boolean;
	onTileDispose(tile: any): void;
	handleRemove: (tile: any, key: any) => void;
	requestTileData(tile: any, stateListenerObject: any): Promise<void>;
	getGroundTileData(tile: any): any;
	getTile(z: any, x: any, y: any, targetTile: any, surfaceTile: any): any;
	markTileUsed(tile: any): void;
	computeCoverageTilesCoord(targetTile: any): any;
	get id(): number;
	set maxCacheSize(value: number);
	get maxCacheSize(): number;
	set desiredUpperSampleLevel(value: number);
	get desiredUpperSampleLevel(): number;
	set loadingUpperSampleLevel(value: number);
	get loadingUpperSampleLevel(): number;
	get grid(): Grid;
	get compatible(): boolean;
	get projection(): any;
	/**
	 * 获取源投影
	 */
	get sourceProjection(): any;
	/**
	 * 设置目标投影
	 */
	set targetProjection(value: any);
	/**
	 * 获取目标投影
	 */
	get targetProjection(): any;
	get initState(): number;
	/**
	 * 设置瓦片最大展示层级
	 * @param {number} value 瓦片最大展示层级
	 */
	set maxLevel(value: number);
	/**
	 * 获取瓦片最大展示层级
	 */
	get maxLevel(): number;
	/**
	 * 设置瓦片最小展示层级
	 * @param {number} value 瓦片最小展示层级
	 */
	set minLevel(value: number);
	/**
	 * 获取瓦片最小展示层级
	 */
	get minLevel(): number;
	set maxParallelRequestNum(value: number);
	get maxParallelRequestNum(): number;
	set cacheMaxSize(value: any);
	get cacheMaxSize(): any;
}
declare class BaseImageryTileProvider extends TileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	 * @param {number[]} [options.colorTint] 色彩调整值，RGB分量，默认为[1, 1, 1]
	 * @param {boolean} [options.randomColorTint] 是否使用随机色彩调整，默认为false
	 * @param {Color} [options.placeholderColor] 占位符颜色
	 */
	constructor(options?: {
		opacity?: number;
		colorTint?: number[];
		randomColorTint?: boolean;
		placeholderColor?: Color;
	});
	/**
	 * 是否为基础影像瓦片提供者
	 * @readonly
	 */
	readonly isBaseImageryTileProvider: true;
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "BaseImageryTileProvider";
	/**
	 * 请求瓦片数据
	 * 子类需要重写doRequestImageTileData方法
	 * @param {object} tile 瓦片对象
	 * @param {object} surfaceTile 表面瓦片对象
	 * @returns {Promise<Texture>} 瓦片纹理
	 * @abstract
	 */
	doRequestTileData(tile: object, surfaceTile: object): Promise<Texture>;
	/**
	 * 设置不透明度
	 * @param {number} opacity 不透明度，取值范围0-1
	 */
	set opacity(opacity: number);
	/**
	 * 获取不透明度
	 * @type {number}
	 */
	get opacity(): number;
	/**
	 * 设置色彩调整值
	 * @param {number[]} colorTint 色彩调整值，RGB分量
	 */
	set colorTint(colorTint: number[]);
	/**
	 * 获取色彩调整值
	 * @type {number[]}
	 */
	get colorTint(): number[];
	/**
	 * 设置是否使用随机色彩调整
	 * @param {boolean} randomColorTint 是否使用随机色彩调整
	 */
	set randomColorTint(randomColorTint: boolean);
	/**
	 * 获取是否使用随机色彩调整
	 * @type {boolean}
	 */
	get randomColorTint(): boolean;
	/**
	 * 设置是否绘制调试标签
	 * @param {boolean} addDebugLabel 是否绘制调试标签
	 */
	set addDebugLabel(addDebugLabel: boolean);
	/**
	 * 获取是否绘制调试标签
	 * @type {boolean}
	 */
	get addDebugLabel(): boolean;
	/**
	 * 占位符颜色（瓦片加载完成前显示的背景色）
	 * @type {Color}
	 */
	set placeholderColor(value: Color);
	/**
	 * @type {Color}
	 */
	get placeholderColor(): Color;
}
/**
 * 影像瓦片提供者，负责影像瓦片数据的请求和缓存。<br/>
 * 该类是所有影像瓦片提供者的**抽象基类，不可直接使用，需要使用子类。**
 *
 * @category Internal
 */
export class ImageryTileProvider extends BaseImageryTileProvider {
	/**
	 * @param {object} [options] 配置选项（继承自 {@link BaseImageryTileProvider}）
	 * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	 */
	constructor(options?: {
		opacity?: number;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "ImageryTileProvider";
	/**
	 * 是否为影像瓦片提供者
	 * @readonly
	 */
	readonly isImageryTileProvider: true;
	/**
	 * 获取瓦片URL
	 * 子类必须重写此方法以提供具体的瓦片URL
	 * @param {number} z 缩放级别
	 * @param {number} x 瓦片X坐标
	 * @param {number} y 瓦片Y坐标
	 * @param {object} tile 瓦片对象
	 * @returns {string} 瓦片URL
	 * @abstract
	 */
	getTileURL(z: number, x: number, y: number, tile: object): string;
	/**
	 * 判断是否需要进行投影变换
	 * 取中心点的像素坐标，计算变换后的像素坐标，判断是否有明显的偏移
	 * @param {object} sourceProjection 源投影
	 * @param {object} targetProjection 目标投影
	 * @param {object} tile 瓦片对象
	 * @param {object} terrainTile 地形瓦片对象
	 * @returns {boolean} 是否需要重投影
	 */
	shouldReproject(sourceProjection: object, targetProjection: object, tile: object, terrainTile: object): boolean;
	/**
	 * 请求瓦片数据
	 * 加载影像瓦片纹理，并根据需要进行投影变换
	 * @param {object} tile 瓦片对象
	 * @param {object} surfaceTile 表面瓦片对象
	 * @returns {Promise<Texture>} 瓦片纹理
	 */
	doRequestImageTileData(tile: object, surfaceTile: object): Promise<Texture>;
	/**
	 * 错误回退处理
	 * 当瓦片加载失败时返回透明纹理
	 * @returns {DataTexture} 透明纹理
	 */
	errorFallback(): DataTexture;
	/**
	 * 瓦片销毁时的回调
	 * 释放瓦片纹理资源
	 * @param {object} tile 瓦片对象
	 */
	onTileDispose(tile: object): void;
}
/**
 * 地形瓦片提供者，负责地形瓦片数据的请求和缓存。<br/>
 * 该类是所有地形瓦片提供者的**抽象基类，不可直接使用，需要使用子类。**
 *
 * @category Internal
 */
export class TerrainTileProvider extends TileProvider {
	/**
	 * @param {*} tile
	 * @returns
	 * geometry
	 * @desc 请求瓦片数据
	 */
	doRequestTileData(tile: any): Promise<void>;
}
export namespace TerrainTileProvider {
	let heightmapTerrainQuality: number;
	function getEstimatedLevelZeroGeometricErrorForAHeightmap(ellipsoid: Ellipsoid, tileImageWidth: number, numberOfTilesAtLevelZero: number): number;
}
/**
 * 矢量瓦片提供者，负责矢量瓦片数据的请求和缓存。<br/>
 * 该类是所有矢量瓦片提供者的**抽象基类，不可直接使用，需要使用子类。**
 *
 * @category Internal
 */
export class VectorTileProvider extends BaseImageryTileProvider {
	isVectorTileProvider: boolean;
	name: string;
	supportsMask: boolean;
	errorFallback(): any[];
	/**
	 * @param {*} tile
	 * @returns
	 * Array[object, groundObject]：包含对象的完整transform
	 * object: 在3D场景中渲染的对象
	 * groundObject: 在地面上渲染的对象
	 * @desc 请求瓦片数据
	 */
	doRequestImageTileData(tile: any, surfaceTile: any): Promise<any>;
	addToMask(data: any): void;
	getGroundTileData(tile: any): Mesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, MeshBasicMaterial, import("three").Object3DEventMap>[];
}
/**
 * Stamen影像瓦片提供者，用于加载和渲染Stamen地图的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式。
 *
 * 主要功能：
 * - 支持Stamen地图影像瓦片加载
 * - 支持Web墨卡托和地理坐标投影
 * - 支持瓦片URL的自动生成
 * - 支持动态切换地图样式
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建Stamen影像瓦片提供者
 * const provider = new mapvthree.StadiaImageryTileProvider({
 *     style: mapvthree.mapViewConstants.STADIA_MAP_STYLE_STAMEN_WATERCOLOR,
 * });
 *
 * // 动态切换地图样式
 * provider.style = mapvthree.mapViewConstants.STADIA_MAP_STYLE_STAMEN_TONER;
 * ```
 */
export class StadiaImageryTileProvider extends ImageryTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	 * @param {string} [options.style] 地图样式，支持 {@link mapViewConstants.STADIA_MAP_STYLE_STAMEN_WATERCOLOR}、{@link mapViewConstants.STADIA_MAP_STYLE_STAMEN_TONER}、{@link mapViewConstants.STADIA_MAP_STYLE_ALIDE_SMOOTH}、{@link mapViewConstants.STADIA_MAP_STYLE_ALIDE_SMOOTH_DARK}、{@link mapViewConstants.STADIA_MAP_STYLE_OUTDOORS}，默认为 {@link mapViewConstants.STADIA_MAP_STYLE_STAMEN_WATERCOLOR}
	 */
	constructor(options?: {
		opacity?: number;
		style?: string;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "StadiaImageryTileProvider";
	set style(style: string);
	/**
	 * 获取或设置地图样式，支持 {@link mapViewConstants.STADIA_MAP_STYLE_STAMEN_WATERCOLOR}、{@link mapViewConstants.STADIA_MAP_STYLE_STAMEN_TONER}、{@link mapViewConstants.STADIA_MAP_STYLE_ALIDE_SMOOTH}、{@link mapViewConstants.STADIA_MAP_STYLE_ALIDE_SMOOTH_DARK}、{@link mapViewConstants.STADIA_MAP_STYLE_OUTDOORS}
	 * @type {string}
	 */
	get style(): string;
}
/**
 * Bing影像瓦片提供者，用于加载和渲染Bing地图的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式。
 *
 * 主要功能：
 * - 支持Bing地图影像瓦片加载
 * - 支持Web墨卡托和地理坐标投影
 * - 支持瓦片URL的自动生成
 * - 支持动态切换地图样式
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建Bing影像瓦片提供者
 * const provider = new mapvthree.BingImageryTileProvider({
 *     style: mapvthree.mapViewConstants.BING_MAP_STYLE_AERIAL,
 * });
 *
 * // 动态切换地图样式
 * provider.style = mapvthree.mapViewConstants.BING_MAP_STYLE_ROAD;
 * ```
 */
export class BingImageryTileProvider extends ImageryTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	 * @param {string} [options.style] 地图样式，支持 {@link mapViewConstants.BING_MAP_STYLE_AERIAL}、{@link mapViewConstants.BING_MAP_STYLE_AERIAL_WITH_LABELS}、{@link mapViewConstants.BING_MAP_STYLE_ROAD}，默认为 {@link mapViewConstants.BING_MAP_STYLE_AERIAL}
	 */
	constructor(options?: {
		opacity?: number;
		style?: string;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "BingImageryTileProvider";
	set style(style: string);
	/**
	 * 获取或设置地图样式，支持 {@link mapViewConstants.BING_MAP_STYLE_AERIAL}、{@link mapViewConstants.BING_MAP_STYLE_AERIAL_WITH_LABELS}、{@link mapViewConstants.BING_MAP_STYLE_ROAD}
	 * @type {string}
	 */
	get style(): string;
}
/**
 * OpenStreetMap影像瓦片提供者，用于加载和渲染OSM地图的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式。
 *
 * 主要功能：
 * - 支持OpenStreetMap影像瓦片加载
 * - 支持Web墨卡托和地理坐标投影
 * - 支持瓦片URL的自动生成
 * - 支持多服务器负载均衡
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建OSM影像瓦片提供者
 * const provider = new OSMImageryTileProvider({
 *     // 配置选项
 * });
 * ```
 */
export class OSMImageryTileProvider extends ImageryTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	 */
	constructor(options: {
		opacity?: number;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "OSMImageryTileProvider";
}
/**
 * 天地图影像瓦片提供者，用于加载和渲染天地图的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式。
 *
 * 主要功能：
 * - 支持天地图影像瓦片加载
 * - 支持Web墨卡托和地理坐标投影
 * - 支持瓦片URL的自动生成
 *
 * 需要使用天地图的TK，请在{@link TiandituConfig}中设置。
 * @category MapView
 * @example
 * ```javascript
 * // 创建天地图影像瓦片提供者
 * const provider = new TiandituImageryTileProvider({
 *     // 配置选项
 *     tk: 'your_tianditu_token',
 * });
 * ```
 */
export class TiandituImageryTileProvider extends ImageryTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	 * @param {string} [options.tk] 天地图密钥，如果不提供则使用 TiandituMapConfig.tk
	 */
	constructor(options?: {
		opacity?: number;
		tk?: string;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "TiandituImageryTileProvider";
}
/**
 * XYZ影像瓦片提供者，用于加载和渲染符合XYZ瓦片规范的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式，兼容标准的XYZ瓦片服务。
 *
 * 主要功能：
 * - 支持标准XYZ瓦片服务
 * - 支持Web墨卡托和地理坐标投影
 * - 自动处理Y坐标反转（TMS vs Google瓦片规范）
 * - 支持自定义瓦片URL模板
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建XYZ影像瓦片提供者（Web墨卡托投影）
 * const provider = new mapvthree.XYZImageryTileProvider({
 *     url: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
 *     projection: mapvthree.constants.PROJECTION_WEB_MERCATOR
 * });
 *
 * // 创建XYZ影像瓦片提供者（地理坐标投影）
 * const geoProvider = new mapvthree.XYZImageryTileProvider({
 *     url: 'https://example.com/tiles/{z}/{x}/{y}.png',
 *     projection: mapvthree.constants.PROJECTION_GEO
 * });
 * ```
 */
export class XYZImageryTileProvider extends ImageryTileProvider {
	/**
	  * @param {object} options 配置选项
	  * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	  * @param {string} options.url 瓦片URL模板，必须包含 {x}、{y}或{reverseY}、{z} 占位符
	  * @param {string} [options.projection] 投影方式，支持 {@link PROJECTION_WEB_MERCATOR} 和
	  * {@link PROJECTION_GEO}，默认为 {@link PROJECTION_WEB_MERCATOR}
	  * @param {number} [options.maxLevel] 瓦片最大展示层级，默认为18
	  */
	constructor(options?: {
		opacity?: number;
		url: string;
		projection?: string;
		maxLevel?: number;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "XYZImageryTileProvider";
}
/**
 * 百度09影像瓦片提供者，用于加载和渲染百度地图的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式，提供卫星影像和普通影像两种类型。
 *
 * 主要功能：
 * - 支持百度地图影像瓦片加载
 * - 支持Web墨卡托和地理坐标投影
 * - 支持卫星影像和普通影像切换
 * - 自动处理百度地图坐标转换
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建百度09影像瓦片提供者（普通影像）
 * const provider = new mapvthree.Baidu09ImageryTileProvider({
 *     ak: 'your_baidu_ak',
 *     type: 'normal'
 * });
 *
 * // 创建百度09影像瓦片提供者（卫星影像）
 * const satelliteProvider = new mapvthree.Baidu09ImageryTileProvider({
 *     ak: 'your_baidu_ak',
 *     type: 'satellite'
 * });
 * ```
 */
export class Baidu09ImageryTileProvider extends ImageryTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {number} [options.opacity] 不透明度，取值范围0-1，默认为1
	 * @param {string} [options.ak] 百度地图API密钥，如果不提供则使用全局配置
	 * @param {string} [options.type] 影像类型，支持 'satellite'（卫星影像）和 'normal'（普通影像），默认为 'normal'
	 */
	constructor(options?: {
		opacity?: number;
		ak?: string;
		type?: string;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "Baidu09ImageryTileProvider";
	/**
	 * 是否为百度地图提供者
	 * @readonly
	 */
	readonly isBaiduProvider: true;
	/**
	 * 获取瓦片URL
	 * @param {number} z 缩放级别
	 * @param {number} x 瓦片X坐标
	 * @param {number} y 瓦片Y坐标
	 * @param {object} tile 瓦片对象
	 * @returns {string|boolean} 瓦片URL或false（如果缩放级别小于3）
	 */
	getTileURL(z: number, x: number, y: number, tile: object): string | boolean;
}
/**
 * WMS影像瓦片提供者，用于加载和渲染WMS服务的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式。
 *
 * 主要功能：
 * - 支持WMS 1.1.1和1.3.0版本
 * - 支持多种投影系统
 * - 自动处理BBOX坐标顺序
 * - 支持透明度和样式设置
 * - 支持不同服务器类型的HiDPI处理
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建WMS影像瓦片提供者
 * const provider = new WMSImageryTileProvider({
 *     url: 'https://example.com/geoserver/wms',
 *     params: {
 *         LAYERS: 'layer1,layer2',
 *         SRS: 'EPSG:3857',
 *         VERSION: '1.1.0',
 *     },
 * });
 * ```
 */
export class WMSImageryTileProvider extends ImageryTileProvider {
	name: string;
	/**
	 * 拼接params到url
	 * @param {string} uri 基础URL
	 * @param {Object} params 参数对象
	 * @returns {string} 拼接后的URL
	 */
	appendParams(uri: string, params: any): string;
	/**
	 * 解析URL参数
	 * @param {string} url URL字符串
	 * @returns {Object} 参数对象
	 */
	getUrlParams(url: string): any;
	/**
	 * 设置WMS参数
	 * @param {Object} params 新的参数对象
	 */
	setParams(params: any): void;
	/**
	 * 获取当前WMS参数
	 * @returns {Object} 当前参数对象
	 */
	getParams(): any;
}
/**
 * WMTS影像瓦片提供者，用于加载和渲染WMTS服务的影像瓦片数据。
 * 支持Web墨卡托和地理坐标两种投影方式。
 *
 * 主要功能：
 * - 支持WMTS 1.0.0版本
 * - 支持多种投影系统和TileMatrixSet
 * - 自动处理瓦片坐标转换
 * - 支持透明度和样式设置
 * - 支持不同服务器类型的HiDPI处理
 * - 支持RESTful和KVP两种请求方式
 * - 支持自定义瓦片矩阵ID映射
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建WMTS影像瓦片提供者 - 使用默认TILEMATRIX模板
 * const provider1 = new WMTSImageryTileProvider({
 *     url: 'https://example.com/geoserver/gwc/service/wmts',
 *     params: {
 *         LAYER: 'layer1',
 *         TILEMATRIXSET: 'EPSG:900913',
 *         TILEMATRIX: 'EPSG:900913:{z}',
 *         VERSION: '1.0.0',
 *     },
 * });
 *
 * // 创建WMTS影像瓦片提供者 - 使用自定义matrixIds
 * const provider2 = new WMTSImageryTileProvider({
 *     url: 'https://example.com/geoserver/gwc/service/wmts',
 *     params: {
 *         LAYER: 'layer1',
 *         TILEMATRIXSET: 'EPSG:3857',
 *         VERSION: '1.0.0',
 *     },
 *     matrixIds: ['EPSG:3857:0', 'EPSG:3857:1', 'EPSG:3857:2'],
 * });
 *
 * // 创建WMTS影像瓦片提供者 - 使用REST请求方式
 * const provider3 = new WMTSImageryTileProvider({
 *     url: 'https://example.com/wmts/{layer}/{style}/{tilematrixset}/{tilematrix}/{tilerow}/{tilecol}.png',
 *     params: {
 *         LAYER: 'layer1',
 *         STYLE: 'default',
 *         TILEMATRIXSET: 'EPSG:3857',
 *     },
 *     requestEncoding: 'REST',
 * });
 * ```
 */
export class WMTSImageryTileProvider extends ImageryTileProvider {
	name: string;
	/**
	 * 拼接params到url
	 * @param {string} uri 基础URL
	 * @param {Object} params 参数对象
	 * @returns {string} 拼接后的URL
	 */
	appendParams(uri: string, params: any): string;
	/**
	 * 解析URL参数
	 * @param {string} url URL字符串
	 * @returns {Object} 参数对象
	 */
	getUrlParams(url: string): any;
	/**
	 * 设置WMTS参数
	 * @param {Object} params 新的参数对象
	 */
	setParams(params: any): void;
	/**
	 * 获取当前WMTS参数
	 * @returns {Object} 当前参数对象
	 */
	getParams(): any;
}
declare class WorkerTaskScheduler {
	constructor(workerClass: any, size: any);
	getResponseMessageId(data: any, message: any): any;
	/**
	 * 初始化workers
	 */
	initWorkers(): void;
	/**
	 * 向所有可用工作者发送消息。
	 *
	 * @param {*} message 消息对象。
	 * @param {Transferable[]} transferableData 可传递数据的数组。
	 * @param {string} id 请求的唯一标识符，如果未提供则将根据消息生成一个。
	 */
	postMessage(message: any, transferableData: Transferable[], id: string): Promise<any>;
	/**
	 * hook
	 * @param {*} messagedata
	 * @param {*} message
	 * @returns
	 */
	/**
	 * hook
	 * @param {*} messagedata
	 * @param {*} message
	 * @returns
	 */
	onMessageCompleted(messagedata: any, message: any): Promise<any>;
	isMessageCompleted(messagedata: any, message: any): boolean;
	isMessageRefreshed(messagedata: any, message: any): boolean;
	/**
	 * 将消息发送给所有工作线程。
	 * @param message 要发送的消息。
	 * @param transferableData 可传输的数据，用于传递给接收者。
	 */
	postMessageToAll(message: any, transferableData: any): void;
	get size(): number;
}
declare class AsyncDataTileLoader {
	constructor(provider: any, workerClass: any, size: any);
	provider: any;
	isMessageCompleted(data: any, message: any): boolean;
	isMessageRefreshed(data: any, message: any): boolean;
	getResponseMessageId(data: any, message: any): any;
	/**
	 * 请求瓦片
	 *
	 * @param {Tile} tile 待请求的瓦片对象
	 * @returns {Promise<void>} 返回一个Promise，处理完成后返回void类型的数据
	 */
	requestTile(tile: Tile): Promise<void>;
	refreshTile(tile: any): Promise<any>;
	cancelTiles(tiles: any): void;
	/**
	 * 向所有 worker 发送消息。
	 *
	 * @param message 消息内容
	 * @param transferableData 可移动数据
	 */
	postMessageToAll(message: any, transferableData: any): void;
}
export class GeoJSONVectorTileProvider extends VectorTileProvider {
	constructor(options?: {});
	/**
	 * 异步初始化方法
	 * @protected
	 */
	/**
	 * 获取瓦片URL
	 * @param {number} z 缩放级别
	 * @param {number} x 瓦片X坐标
	 * @param {number} y 瓦片Y坐标
	 * @param {object} tile 瓦片对象
	 * @returns {string} 瓦片URL或标识符
	 */
	getTileURL(z: number, x: number, y: number, tile: object): string;
}
/**
 * 平面地形瓦片提供者，用于生成和渲染平面地形瓦片。支持多种投影方式，包括Web墨卡托、ECEF和地理坐标系统。
 * 主要功能：
 * - 支持多种投影方式的地形瓦片生成
 * - 提供基础的地形几何数据
 * - 支持瓦片数据的请求和处理
 *
 * @category MapView
 * @example
 * ```javascript
 * const provider = new PlaneTerrainTileProvider({
 *     // 配置选项
 * });
 * ```
 */
export class PlaneTerrainTileProvider extends TerrainTileProvider {
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "PlaneTerrainTileProvider";
	rasterProjection: any;
}
declare class QuantizedMeshTerrainData {
	static createQuantizedMeshTerrainData(provider: any, buffer: any): QuantizedMeshTerrainData;
	constructor(options: any);
}
declare class AsyncCesiumTerrainDataLoader {
	constructor(provider: any, workerClass: any, size: any);
	provider: any;
	isMessageCompleted(data: any, message: any): boolean;
	getResponseMessageId(data: any, message: any): any;
	/**
	 * 上采样瓦片
	 */
	upsample(quantizedMesh: any, parentKey: any, tile: any): Promise<QuantizedMeshTerrainData>;
	/**
	 * 请求瓦片
	 *
	 * @param {Tile} tile 待请求的瓦片对象
	 * @returns {Promise<void>} 返回一个Promise，处理完成后返回void类型的数据
	 */
	requestTile(tile: Tile): Promise<void>;
	createMesh(terrainData: any, tile: any, options: any): Promise<any>;
	/**
	 * 向所有 worker 发送消息。
	 *
	 * @param message 消息内容
	 * @param transferableData 可移动数据
	 */
	postMessageToAll(message: any, transferableData: any): void;
}
/**
 * Cesium地形瓦片提供者，用于加载和渲染Cesium地形数据。支持从Cesium ion服务器或自定义服务器加载地形数据，提供高质量的地形渲染。主要功能：
 * - 支持Cesium ion地形数据加载
 * - 支持自定义地形服务器
 * - 支持地形数据的上采样
 * - 支持多种投影方式（ECEF、Web墨卡托、地理坐标）
 *
 * 需要使用Cesium ion的Access Token，请在{@link CesiumConfig}中设置。
 * @category MapView
 * @example
 * ```javascript
 * // 使用默认Cesium ion服务器
 * const provider = new CesiumTerrainTileProvider({
 *     accessToken: 'your_access_token'
 * });
 * // 使用自定义地形服务器
 * const customProvider = new CesiumTerrainTileProvider({
 *     url: 'https://your-terrain-server'
 * });
 * ```
 */
export class CesiumTerrainTileProvider extends PlaneTerrainTileProvider {
	/**
	 * 创建Cesium地形瓦片提供者
	 * @param {object} options 配置选项
	 * @param {string} [options.accessToken] Cesium ion访问令牌
	 * @param {string} [options.url] 自定义地形服务器URL
	 */
	constructor(options?: {
		accessToken?: string;
		url?: string;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "CesiumTerrainTileProvider";
	/**
	 * 异步初始化
	 * @protected
	 */
	hasVertexNormals: any;
	littleEndianExtensionSize: boolean;
}
/**
 * 百度矢量瓦片提供者，用于加载和渲染百度地图的矢量瓦片数据。
 * 支持在线和离线两种模式，可以处理多种投影方式。
 *
 * 主要功能：
 * - 支持百度地图在线矢量瓦片加载
 * - 支持离线矢量瓦片加载
 * - 支持多种投影方式（Web墨卡托、百度墨卡托、地理坐标）
 * - 支持矢量数据的样式配置
 * - 支持POI标签的显示
 *
 * 需要使用百度地图的AK，请在{@link BaiduMapConfig}中设置。
 * @category MapView
 * @example
 * ```javascript
 * // 创建在线矢量瓦片提供者
 * const provider = new BaiduVectorTileProvider({
 *     ak: 'your_ak_here',
 *     displayOptions: {
 *         // 显示配置
 *     }
 * });
 *
 * // 创建DuGIS离线矢量瓦片提供者
 * const offlineProvider = new BaiduVectorTileProvider({
 *     isOffline: true,
 *     url: 'http://dugis-offline-server',
 * });
 * ```
 */
export class BaiduVectorTileProvider extends VectorTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {string} [options.ak] 百度地图AK，在线模式必填
	 * @param {string} [options.styleId] 百度地图个性化地图，设置样式StyleId
	 * @param {string} [options.styleJson] 百度地图个性化地图，设置样式StyleJson
	 * @param {boolean} [options.isOffline=false] 是否为离线dugis模式
	 * @param {string} [options.url] 离线模式下的瓦片dugis服务器地址
	 * @param {string} [options.staticUrl] 离线模式下的静态资源服务器地址
	 * @param {string} [options.projection] 离线模式下的投影方式，默认为'mapvthree.PROJECTION_WEB_MERCATOR'
	 * @param {object} [options.displayOptions] 显示配置选项
	 * @param {boolean} [options.displayOptions.base=true] 是否显示基础面
	 * @param {boolean} [options.displayOptions.link=true] 是否显示道路
	 * @param {boolean} [options.displayOptions.building=true] 是否显示3D建筑物
	 * @param {boolean} [options.displayOptions.poi=true] 是否显示POI
	 * @param {boolean} [options.displayOptions.flat=true] 是否显示成压平模式
	 * @param {Color} [options.placeholderColor] 占位符颜色（瓦片加载中的底板色）
	 */
	constructor(options?: {
		ak?: string;
		styleId?: string;
		styleJson?: string;
		isOffline?: boolean;
		url?: string;
		staticUrl?: string;
		projection?: string;
		displayOptions?: {
			base?: boolean;
			link?: boolean;
			building?: boolean;
			poi?: boolean;
			flat?: boolean;
		};
		placeholderColor?: Color;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "BaiduVectorTileProvider";
	/**
	 * 是否为百度地图提供者
	 * @readonly
	 */
	readonly isBaiduProvider: true;
	/**
	 * 是否支持掩膜功能
	 * @readonly
	 */
	readonly supportsMask: true;
	sourceCoordType: string;
	/**
	 * 设置地图样式，通过 https://lbsyun.baidu.com/index.php?title=open/custom 获取个性化样式配置
	 * @param {Object} config 样式配置
	 * @param {string} config.styleId 样式ID
	 * @param {string} config.styleJson 样式JSON
	 */
	setMapStyle(config: {
		styleId: string;
		styleJson: string;
	}): Promise<void>;
	/**
	 * 异步初始化方法
	 * @protected
	 */
	getTileURL(z: any, x: any, y: any, tile: any): string;
	updateDisplayOptions(displayOptions: any): void;
	/**
	 * @protected
	 */
	protected onSurfaceTileAdded(surfaceTile: any, engine: any): void;
	/**
	 * @protected
	 */
	protected onSurfaceTileRemoved(surfaceTile: any, engine: any): void;
	onSurfaceTileSSEChanged(surfaceTile: any, engine: any): void;
	addAllSymbols(): void;
	removeAllSymbols(): void;
}
/**
 * 百度路况瓦片提供者，用于加载和渲染百度地图的路况数据。
 * 支持在线和离线两种模式，可以处理多种投影方式。
 *
 * 主要功能：
 * - 支持百度地图在线路况瓦片加载
 * - 支持DuGIS离线环境的路况瓦片加载
 * - 支持多种投影方式（Web墨卡托、百度墨卡托）
 * - 支持路况数据的自动刷新，可配置关闭
 * - 支持路况线条的样式配置
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建在线路况瓦片提供者
 * const provider = new BaiduTrafficTileProvider({
 *     autoRefresh: true,
 *     refreshInterval: 60000
 * });
 *
 * // 创建离线路况瓦片提供者
 * const offlineProvider = new BaiduTrafficTileProvider({
 *     isOffline: true,
 *     url: 'http://offline-traffic-server',
 *     projection: 'mapvthree.PROJECTION_WEB_MERCATOR'
 * });
 * ```
 */
export class BaiduTrafficTileProvider extends VectorTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {string} [options.url] 离线模式下的路况服务器地址
	 * @param {object} [options.params] 请求参数
	 * @param {boolean} [options.isOffline=false] 是否为离线模式
	 * @param {string} [options.projection] 离线模式下的投影方式，默认为'mapvthree.PROJECTION_WEB_MERCATOR'
	 * @param {boolean} [options.autoRefresh=true] 是否启用自动刷新
	 * @param {number} [options.refreshInterval=60000] 自动刷新间隔，单位毫秒，最小60秒
	 * @param {object} [options.colors] 路况颜色配置
	 * @param {number} [options.lineWidth] 路况线条宽度
	 * @param {boolean} [options.transparent=false] 材质是否透明
	 * @param {number} [options.height=0] 额外的高度偏移
	 */
	constructor(options?: {
		url?: string;
		params?: object;
		isOffline?: boolean;
		projection?: string;
		autoRefresh?: boolean;
		refreshInterval?: number;
		colors?: object;
		lineWidth?: number;
		transparent?: boolean;
		height?: number;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "BaiduTrafficTileProvider";
	/**
	 * 是否为百度地图提供者
	 * @readonly
	 */
	readonly isBaiduProvider: true;
	params: any;
	/**
	 * 异步初始化方法
	 * @protected
	 */
	/**
	 * 设置自动刷新间隔
	 * @param {number} interval 刷新间隔，单位毫秒，最小60000ms
	 */
	set refreshInterval(interval: number);
	/**
	 * 自动刷新间隔
	 * @type {number}
	 */
	get refreshInterval(): number;
	/**
	 * 获取瓦片URL
	 * @param {number} z 缩放级别
	 * @param {number} x 瓦片X坐标
	 * @param {number} y 瓦片Y坐标
	 * @param {object} tile 瓦片对象
	 * @returns {string} 瓦片URL
	 */
	getTileURL(z: number, x: number, y: number, tile: object): string;
	/**
	 * 设置是否启用自动刷新
	 * @param {boolean} enabled 是否启用
	 */
	set autoRefresh(enabled: boolean);
	/**
	 * 是否启用自动刷新
	 * @type {boolean}
	 */
	get autoRefresh(): boolean;
	/**
	 * 销毁资源
	 * @protected
	 */
	protected dispose(): void;
	/**
	 * 瓦片销毁时的回调
	 * @param {object} tile 瓦片对象
	 * @protected
	 */
	protected onTileDispose(tile: object): void;
}
type SpriteDataItem = {
	width: number;
	height: number;
	data: Uint8Array;
	pixelRatio: number;
	stretchX?: Array<Array<number>> | undefined;
	stretchY?: Array<Array<number>> | undefined;
	content?: number[] | undefined;
	sdf?: any | undefined;
	uvs: number[];
};
/**
 * Mapbox矢量瓦片提供者，用于加载和渲染Mapbox矢量瓦片数据。
 * 支持Mapbox样式规范，提供完整的矢量瓦片渲染功能。
 *
 * 主要功能：
 * - 支持Mapbox矢量瓦片加载和解析
 * - 支持Mapbox样式规范（version 8）
 * - 支持多种图层类型（填充、线条、符号、挤压等）
 * - 支持自定义样式和访问令牌
 * - 支持POI标签渲染
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建Mapbox矢量瓦片提供者
 * const provider = new mapvthree.MapboxVectorTileProvider({
 *     style: 'mapbox://styles/mapbox/streets-v11',
 *     accessToken: 'your_mapbox_access_token'
 * });
 *
 * // 使用自定义样式
 * const customProvider = new mapvthree.MapboxVectorTileProvider({
 *     style: 'path/to/custom-style.json',
 * });
 * ```
 */
export class MapboxVectorTileProvider extends VectorTileProvider {
	/**
	 * @param {object} options 配置选项
	 * @param {string} [options.style] Mapbox样式URL或本地样式文件路径，默认为 'mapbox://styles/mapbox/streets-v11'
	 * @param {string} [options.accessToken] Mapbox访问令牌，如果不提供则使用全局配置
	 * @param {object} [options.defaultStyle] 默认样式配置
	 * @param {object} [options.displayOptions] 显示选项
	 * @param {boolean} [options.displayOptions.background=true] 是否显示背景
	 * @param {boolean} [options.displayOptions.base=true] 是否显示基础面
	 * @param {boolean} [options.displayOptions.link=true] 是否显示道路
	 * @param {boolean} [options.displayOptions.building=true] 是否显示3D建筑物
	 * @param {boolean} [options.displayOptions.poi=true] 是否显示POI
	 * @param {Color} [options.placeholderColor] 占位符颜色，未传入时使用 Mapbox 风格默认浅灰底
	 */
	constructor(options?: {
		style?: string;
		accessToken?: string;
		defaultStyle?: object;
		displayOptions?: {
			background?: boolean;
			base?: boolean;
			link?: boolean;
			building?: boolean;
			poi?: boolean;
		};
		placeholderColor?: Color;
	});
	/**
	 * 瓦片提供者名称
	 * @readonly
	 */
	readonly name: "MapboxVectorTileProvider";
	spriteTexture: Texture;
	/**
	 * 获取瓦片URL
	 * @param {number} z 缩放级别
	 * @param {number} x 瓦片X坐标
	 * @param {number} y 瓦片Y坐标
	 * @param {object} tile 瓦片对象
	 * @returns {string} 瓦片URL
	 */
	getTileURL(z: number, x: number, y: number, tile: object): string;
	/**
	 * 获取Worker选项
	 * @returns {object} Worker选项配置
	 */
	getWorkerOptions(): object;
	/**
	 * 获取瓦片数据并返回对应的Group对象
	 * @param {object} tile 瓦片对象
	 * @returns {Promise<Object3D>} 返回一个包含瓦片数据的Group对象
	 */
	doRequestVectorTileData(tile: object): Promise<Object3D>;
	/**
	 * 取消瓦片请求
	 * @param {Array} tiles 要取消的瓦片数组
	 */
	cancelTiles(tiles: any[]): void;
	/**
	 * 表面瓦片添加时的回调
	 * @param {object} surfaceTile 表面瓦片对象
	 * @param {object} engine 引擎对象
	 */
	onSurfaceTileAdded(surfaceTile: object, engine: object): void;
	/**
	 * 表面瓦片移除时的回调
	 * @param {object} surfaceTile 表面瓦片对象
	 * @param {object} engine 引擎对象
	 */
	onSurfaceTileRemoved(surfaceTile: object, engine: object): void;
	/**
	 * 添加所有符号
	 * 显示所有隐藏的符号标签
	 */
	addAllSymbols(): void;
	/**
	 * 移除所有符号
	 * 隐藏所有显示的符号标签
	 */
	removeAllSymbols(): void;
	/**
	 * 瓦片销毁时的回调
	 * @param {object} tile 瓦片对象
	 */
	onTileDispose(tile: object): void;
	/**
	 * 设置材质管理器
	 * @param {object} materialManager 材质管理器对象
	 */
	set materialManager(materialManager: object);
	/**
	 * 材质管理器
	 * @type {object}
	 */
	get materialManager(): object;
}
/**
 * 单体模型，简易加载方式，兼容多种投影方式。用于加载单个3D模型并设置其位置、旋转和缩放。
 *
 * @category Model
 * @example
 * ```javascript
 * let model = engine.add(new mapvthree.SimpleModel({
 *  name: '模型名称',
 *  url: '模型路径',
 *  point: [lng, lat, z],
 *  scale: [1, 1, 1],
 *  rotation: [0, 0, 0],
 * }))
 * ```
 *
 * @example
 * ```javascript
 * // 监听模型加载完成事件
 * model.addEventListener('loaded', e => {
 *     console.log('模型加载完成:', e.value);
 * });
 * ```
 */
export class SimpleModel extends Object3D<import("three").Object3DEventMap> {
	/**
	 * 构造函数
	 * @param {Object} parameters 配置参数
	 * @param {string} [parameters.name=''] 模型名称
	 * @param {string} [parameters.object] 模型URL文件路径或Object3D实例，URL模型支持glb/gltf格式
	 * @param {Array<number>|Vector3} [parameters.point=[0,0,0]] 模型位置，格式为[经度,纬度,高度]
	 * @param {Array<number>|Vector3|number} [parameters.scale=[1,1,1]] 模型缩放
	 * @param {Array<number>|Vector3} [parameters.rotation=[0,0,0]] 模型旋转,x,y,z三个分量分别代表roll,pitch,heading，单位为弧度
	 * @param {boolean} [parameters.autoYUpToZUp=true] 是否自动将Y轴向上转换为Z轴向上,默认true,仅对通过URL加载的模型有效
	 */
	constructor(parameters: {
		name?: string;
		object?: string;
		point?: Array<number> | Vector3;
		scale?: Array<number> | Vector3 | number;
		rotation?: Array<number> | Vector3;
		autoYUpToZUp?: boolean;
	});
	afterAddToEngine(engine: any): void;
	beforeRemoveFromEngine(): void;
	dispose(): void;
	/**
	 * 设置模型的变换参数
	 * @param {Object} transform 变换参数对象
	 * @param {Array<number>|Vector3} [transform.point] 位置坐标[经度,纬度,高度]
	 * @param {Array<number>|Vector3} [transform.rotation] 旋转角度，x,y,z三个分量分别代表roll,pitch,heading (单位为弧度)
	 * @param {Array<number>|Vector3|number} [transform.scale] 缩放比例
	 *
	 * @example
	 * ```javascript
	 * // 设置位置、旋转和缩放
	 * model.setTransform({
	 *     point: [116.404, 39.915, 100],
	 *     rotation: [Math.PI/2, 0, 0],
	 *     scale: [2, 2, 2]
	 * });
	 *
	 * // 只设置位置
	 * model.setTransform({
	 *     point: [116.404, 39.915, 100]
	 * });
	 *
	 * // 使用Vector3设置
	 * model.setTransform({
	 *     point: new Vector3(116.404, 39.915, 100),
	 *     scale: new Vector3(2, 2, 2)
	 * });
	 * ```
	*/
	setTransform(transform?: {
		point?: Array<number> | Vector3;
		rotation?: Array<number> | Vector3;
		scale?: Array<number> | Vector3 | number;
	}): void;
	/**
	 * 设置模型位置
	 * @param {Array<number>|Vector3} value 位置坐标[经度,纬度,高度]
	 * @example
	* ```javascript
	* model.point = [116.404, 39.915, 100];
	* ```
	*/
	set point(value: Array<number> | Vector3);
	/**
	 * 是否自动将Y轴向上转换为Z轴向上，仅对通过URL加载的模型有效
	 * @type {boolean}
	 */
	get autoYUpToZUp(): boolean;
}
/**
 * 动画模型，支持GLTF/GLB等格式的骨骼动画播放与控制。
 * 继承自 {@link SimpleModel}，可用于加载带有动画的3D模型，并提供动画的播放、停止、速度、循环等控制接口。
 *
 * @category Model
 * @example
 * ```javascript
 * // 加载带动画的模型
 * let model = engine.add(new mapvthree.AnimationModel({
 *   url: 'assets/models/animated.glb',
 *   autoPlay: true
 * }));
 * // 播放第1个动画
 * model.play(0);
 * // 停止所有动画
 * model.stopAll();
 * // 设置动画速度为2倍
 * model.setSpeed(2);
 * ```
 */
export class AnimationModel extends SimpleModel {
	/**
	 * 构造函数
	 * @param {Object} params 配置参数，参考SimpleModel
	 */
	constructor(params: any);
	mixer: AnimationMixer;
	animationActions: any[];
	/**
	 * 播放指定索引的动画
	 * @param {number} [actionIndex=0] 动画索引，默认播放第一个
	 * @example
	 * ```javascript
	 * model.play(1); // 播放第2个动画
	 * ```
	 */
	play(actionIndex?: number): void;
	/**
	 * 停止指定索引的动画
	 * @param {number} [actionIndex=0] 动画索引，默认停止第一个
	 * @example
	 * ```javascript
	 * model.stop(0); // 停止第1个动画
	 * ```
	 */
	stop(actionIndex?: number): void;
	/**
	 * 播放所有动画
	 * @example
	 * ```javascript
	 * model.playAll();
	 * ```
	 */
	playAll(): void;
	/**
	 * 停止所有动画
	 * @example
	 * ```javascript
	 * model.stopAll();
	 * ```
	 */
	stopAll(): void;
	/**
	 * 设置动画播放速度
	 * @param {number} speed 播放速度，1为正常速度
	 * @param {number} [actionIndex] 动画索引，若不传则设置所有动画
	 * @example
	 * ```javascript
	 * model.setSpeed(2); // 所有动画2倍速
	 * model.setSpeed(0.5, 0); // 第1个动画0.5倍速
	 * ```
	 */
	setSpeed(speed: number, actionIndex?: number): void;
	/**
	 * 设置动画循环模式
	 * @param {boolean} loop 是否循环，true为循环，false为只播放一次
	 * @param {number} [actionIndex] 动画索引，若不传则设置所有动画
	 * @example
	 * ```javascript
	 * model.setLoop(true); // 所有动画循环
	 * model.setLoop(false, 0); // 第1个动画只播放一次
	 * ```
	 */
	setLoop(loop: boolean, actionIndex?: number): void;
}
declare class PromisedSingleton {
	get(key: any): Promise<any>;
	get keys(): string[];
	delete(key: any): void;
	clear(): void;
}
/**
 * LOD(Level of Detail)模型类，用于加载和管理不同细节层级的3D模型。
 * 根据相机距离自动切换不同精度的模型，优化渲染性能。
 *
 * @category Model
 * @extends Object3D
 * @example
 * ```javascript
 * const lodModel = new LODModel({
 *     hysteresis: 0.1,
 *     levels: [
 *         { distance: 100, file: 'models/high.glb' },
 *         { distance: 500, file: 'models/medium.glb' },
 *         { distance: 1000, file: 'models/low.glb' }
 *     ]
 * });
 * engine.add(lodModel);
 * ```
 *
 * @example
 * ```javascript
* // 监听单个模型加载完成事件
* lodModel.addEventListener('loaded', (event) => {
*     console.log('模型加载完成:', event.value);
* });
*
* // 监听所有层级加载完成事件
* lodModel.addEventListener('complete', (event) => {
*     console.log('所有层级加载完成');
* });
 * ```
*/
export class LODModel extends Object3D<import("three").Object3DEventMap> {
	/**
	 * LOD模型构造函数
	 * @param {Object} parameters 配置参数
	 * @param {number} parameters.hysteresis 缩进与拉远的缓冲参数，防止在临界点缩放时抖动，范围 0~1, 默认 0.1
	 * @param {Array} parameters.levels levels 层级数据 [{distance: 1000, hysteresis: 0.1, file: 'a/b/c.glb'}]
	 */
	constructor(parameters: {
		hysteresis: number;
		levels: any[];
	});
	/**
	 * 设置缩进与拉远的缓冲参数，防止在临界点缩放时抖动
	 * @type {number}
	 * @example
	* ```javascript
	* lodModel.hysteresis = 0.2; // 设置20%的缓冲区间
	* ```
	*/
	set hysteresis(value: number);
	/**
	 * 获取缩进与拉远的缓冲参数
	 * @return {number}
	 */
	get hysteresis(): number;
	/**
	 * 设置LOD层级配置数组
	 * @type {Array<Object>}
	 * @example
	 * ```javascript
	 * lodModel.levels = [
	 *     { distance: 100, file: 'high.glb' },
	 *     { distance: 500, file: 'medium.glb' },
	 *     { distance: 1000, file: 'low.glb' }
	 * ];
	 * ```
	*/
	set levels(levels: Array<any>);
	/**
	 * 获取LOD层级配置数组
	 * @return {Array<Object>}
	 */
	get levels(): Array<any>;
	afterAddToEngine(engine: any): void;
	beforeRemoveFromEngine(engine: any): void;
	/**
	 * 添加一个LOD层级
	 * @param {string} file 模型文件路径
	 * @param {number} distance 切换距离
	 * @param {number} hysteresis 该层级的缓冲参数
	 * @returns {LODModel} 返回this
	 * @example
	* ```javascript
	* lodModel.addLevel('models/detail.glb', 200, 0.1)
	*         .addLevel('models/simple.glb', 800, 0.1);
	* ```
	*/
	addLevel(file: string, distance?: number, hysteresis?: number): LODModel;
	/**
	 * 移除指定文件的LOD层级
	 * @param {string} file 要移除的模型文件路径
	 * @returns {LODModel} 返回this以支持链式调用
	 * @example
	 * ```javascript
	 * lodModel.removeLevel('models/detail.glb');
	 * ```
	*/
	removeLevel(file: string): LODModel;
	/**
	 * 获取当前层级
	 * @return {number} 当前层级
	 */
	getCurrentLevel(): number;
	/**
	 * 获取当前模型
	 * @return {Promise<Object3D>} 当前模型
	 */
	getCurrentModel(): Promise<Object3D>;
	/**
	 * 获取指定层级的模型
	 * @param {number} level 层级索引
	 * @return {Promise<Object3D>} 模型
	 */
	getModel(level: number): Promise<Object3D>;
	update: () => Promise<void>;
	handleLoaded(model: any): void;
	dispose(): void;
	/**
	 * 获取模型是否初始化
	 * @return {boolean}
	 */
	get isInit(): boolean;
	destroyModel(): void;
	/**
	 * 设置模型变换参数
	 * @type {Object}
	 * @example
	 * ```javascript
	 * lodModel.transform = {
	 *     translate: [100, 0, 100],
	 *     rotation: [0, Math.PI/2, 0],
	 *     scale: 2
	 * };
	 * ```
	*/
	set transform(value: any);
	/**
	 * 获取模型变换参数
	 * @return {Object}
	*/
	get transform(): any;
}
declare function Empty3DTileContent(tileset: any, tile: any): void;
declare class Empty3DTileContent {
	featurePropertiesDirty: boolean;
	/**
	 * Part of the {@link Cesium3DTileContent} interface.  <code>Empty3DTileContent</code>
	 * always returns <code>false</code> since a tile of this type does not have any features.
	 */
	hasProperty(batchId: any, name: any): boolean;
	/**
	 * Part of the {@link Cesium3DTileContent} interface.  <code>Empty3DTileContent</code>
	 * always returns <code>undefined</code> since a tile of this type does not have any features.
	 */
	getFeature(batchId: any): any;
	applyDebugSettings(enabled: any, color: any): void;
	applyStyle(style: any): void;
	update(tileset: any, frameState: any): void;
	pick(ray: any, frameState: any, result: any): any;
	isDestroyed(): boolean;
	destroy(): any;
}
declare class OBB {
	constructor(box?: Box3, transform?: Matrix4);
	box: Box3;
	absoluteBox: Box3;
	transform: Matrix4;
	inverseTransform: Matrix4;
	points: Vector3[];
	planes: Plane[];
	/**
	 * Clamps the given point within the bounds of this OBB
	 * @param {Vector3} point
	 * @param {Vector3} result
	 * @returns {Vector3}
	 */
	clampPoint(point: Vector3, result: Vector3): Vector3;
	/**
	 * Returns the distance from any edge of this OBB to the specified point.
	 * If the point lies inside of this box, the distance will be 0.
	 * @param {Vector3} point
	 * @returns {number}
	 */
	distanceToPoint(point: Vector3): number;
	containsPoint(point: any): boolean;
	intersectsRay(ray: any): boolean;
	intersectRay(ray: any, target: any): any;
	update(): void;
	updatePlanes(): void;
	intersectsFrustum(frustum: any): boolean;
}
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>;
}
declare class EllipsoidRegion extends Ellipsoid {
	constructor(x: any, y: any, z: any, latStart?: number, latEnd?: number, lonStart?: number, lonEnd?: number, heightStart?: number, heightEnd?: number);
	latStart: number;
	latEnd: number;
	lonStart: number;
	lonEnd: number;
	heightStart: number;
	heightEnd: number;
	getBoundingBox(box: any, matrix: any): void;
	getBoundingSphere(sphere: any, center: any): void;
}
declare class TileBoundingVolume {
	sphere: Sphere;
	obb: OBB;
	region: EllipsoidRegion;
	regionObb: OBB;
	intersectsRay(ray: any): boolean;
	intersectRay(ray: any, target?: any): any;
	distanceToPoint(point: any): number;
	intersectsFrustum(frustum: any, isIntersectWithBox: any): boolean;
	getOBB(targetBox: any, targetMatrix: any): void;
	getAABB(target: any): void;
	getSphere(target: any): void;
	setObbData(data: any, transform: any): void;
	setSphereData(x: any, y: any, z: any, radius: any, transform: any): void;
	setRegionData(west: any, south: any, east: any, north: any, minHeight: any, maxHeight: any): void;
}
declare class TileMetadata {
	constructor(options: any);
}
declare class Cesium3DTile {
	constructor(tileset: any, baseResource: any, header: any, parent: any);
	hasTilesetContent: boolean;
	hasImplicitContent: boolean;
	hasImplicitContentMetadata: boolean;
	/**
	 * The local transform of this tile.
	 * @type {Matrix4}
	 */
	transform: Matrix4;
	computedTransform: Matrix4;
	metadata: TileMetadata;
	geometricError: any;
	hasEmptyContent: boolean;
	hasMultipleContents: boolean;
	refine: any;
	children: any[];
	parent: any;
	priorityDeferred: boolean;
	contentExpired: boolean;
	boundingVolume: TileBoundingVolume;
	updatePriority(): void;
	updateContent(content: any): void;
	/**
	 *  Processes the tile's content, e.g., create WebGL resources, to move from the PROCESSING to READY state.
	 */
	process(tileset: any): void;
	lastStyleTime: number;
	update(tileset: any): void;
	cancelRequests(): void;
	unloadContent(): void;
	requestContent(): any;
	visibility(): void;
	computeVisibility(boundingVolume: any, engine: any): void;
	intersectBoundingVolume(boundingVolume: any, frustum: any): void;
	updateVisibility(renderState: any): void;
	updateTransform(): void;
	distanceToTile(): number;
	distanceToTileCenter(renderState: any): number;
	getScreenSpaceError(useParentGeometricError: any, progressiveResolutionHeightFraction: any): number;
	getDistance(): number;
	isDestroyed(): boolean;
	get contentReady(): boolean;
	get contentAvailable(): boolean;
	get hasRenderableContent(): boolean;
	get isVisible(): boolean;
	get tileset(): any;
	get hasUnloadedRenderableContent(): boolean;
	get contentUnLoaded(): boolean;
	get content(): Empty3DTileContent;
	get cached(): Empty3DTileContent;
	get __visible(): boolean;
	get boundingVolumeCenter(): any;
}
declare class DoublyLinkedList {
	head: DoublyLinkedListNode;
	tail: any;
	add(item: any): any;
	remove(node: any): void;
	/**
	 * Moves nextNode after node
	 * @param {DoublyLinkedListNode} node
	 * @param {DoublyLinkedListNode} nextNode
	 */
	splice(node: DoublyLinkedListNode, nextNode: DoublyLinkedListNode): void;
	get length(): number;
}
declare class DoublyLinkedListNode {
	constructor(item: any, previous: any, next: any);
	item: any;
	previous: any;
	next: any;
}
declare class Cesium3DTilesetCache {
	trimTiles: boolean;
	reset(): void;
	touch(tile: any): void;
	add(tile: any): void;
	unloadTile(tileset: any, tile: any, unloadCallback: any): void;
	unloadTiles(tileset: any, unloadCallback: any): void;
	trim(): void;
}
declare class Cesium3DTilesetStatistics {
	selected: number;
	visited: number;
	numberOfAttemptedRequests: number;
	numberOfPendingRequests: number;
	numberOfTilesProcessing: number;
	numberOfTilesWithContentReady: number;
	numberOfTilesTotal: number;
	numberOfLoadedTilesTotal: number;
	numberOfTilesCulledWithChildrenUnion: number;
	totalByteLength: number;
	clear(): void;
	incrementSelectionCounts(): void;
	incrementLoadCounts(content: any): void;
	decrementLoadCounts(content: any): void;
}
declare class ElementsManager {
	constructor(parent: any);
	unregisterElement(element: any): void;
	shouldIgnoreTile: (tile: any) => boolean;
	parseElements: (tile: any) => void;
	getInterleavedBufferValue2: (attribute: any, index: any) => any[];
	getInterleavedBufferValue3: (attribute: any, index: any) => any[];
	findElementInMesh: (mesh: any, matchedBatchIdMap: any, matchedElementMap: any) => void;
	onTileLoad: (tile: any, scene: any) => void;
	onTileDispose: (tile: any, scene: any) => void;
	onTileShow: (tile: any) => void;
	onTileHide: (tile: any) => void;
	parseTileInfo: (tile: any) => void;
	refreshTile: (tile: any) => void;
	refreshTiles: () => void;
	tick(time: any): void;
	set subscribedMaxLodLevel(value: number);
	get subscribedMaxLodLevel(): number;
}
declare class TileInstancedElementManager {
	markNeedsUpdate: () => void;
	getIconUrl(mapUrl: any): string;
	createInstanceComponent(mesh: any, tile: any, instanceCollectionConfig: any, instanceConfig: any): Promise<void>;
	remapBatchValueToNumber: (value: any) => any;
	parseBatchTableAttribute: (tile: any, property: any, attributeName: any) => void;
	parsePOIData: (object: any, tile: any, instanceInfo: any, sourceType?: string) => void;
	parseLabelData: (object: any, tile: any) => void;
	onTileLoad: (tile: any, scene: any) => void;
	onTileDispose: (tile: any, scene: any) => void;
	onTileShow: (tile: any) => void;
	onTileHide: (tile: any) => void;
	resetTile: (tile: any) => void;
	refreshTile: (tile: any) => void;
	refreshTiles: () => void;
	getInstanceCollectionConfig(type: any): any;
	setInstanceCollectionConfig(type: any, config: any): this;
	getInstanceConfig(type: any, subtype: any): any;
	setInstanceConfig(type: any, subtype: any, config: any): this;
	getLabelType: (label: any) => any;
	addLabels(labels: any): void;
	removeLabels(labels: any): void;
	/**
	 * 用于避免移除从未被添加的隐藏数据
	 * @param {Array} labels - POI标签数组（需要有dataType属性）
	 */
	addLabel(label: any, instance: any): void;
	removeLabel(label: any, instance: any): void;
	/**
	 * 设置POI配置
	 * @param {Object} poiConfig - POI配置对象
	 * @param {Object} poiConfig.poi - POI配置
	 * @param {boolean} poiConfig.poi.enabled - 是否启用POI
	 * @param {Object} poiConfig.label - 标签配置
	 * @param {boolean} poiConfig.label.enabled - 是否启用标签
	 * @example
	 * manager.setPoiConfig({
	 *   poi: { enabled: true },
	 *   label: { enabled: false },
	 *   restaurant: { enabled: true },
	 *   hotel: { enabled: false }
	 * });
	 */
	setPoiConfig(poiConfig: {
		poi: {
			enabled: boolean;
		};
		label: {
			enabled: boolean;
		};
	}): this;
	/**
	 * 获取当前POI配置
	 * @returns {Object} 当前POI配置
	 */
	getPoiConfig(): any;
	/**
	 * 启用指定类型的POI
	 * @param {string} type - POI类型
	 * @example
	 * manager.enablePoiType('poi');
	 * manager.enablePoiType('restaurant');
	 */
	enablePoiType(type: string): this;
	/**
	 * 禁用指定类型的POI
	 * @param {string} type - POI类型
	 * @example
	 * manager.disablePoiType('poi');
	 * manager.disablePoiType('restaurant');
	 */
	disablePoiType(type: string): this;
	/**
	 * 切换指定类型POI的显示状态
	 * @param {string} type - POI类型
	 * @returns {boolean} 切换后的状态
	 * @example
	 * const isEnabled = manager.togglePoiType('poi');
	 */
	togglePoiType(type: string): boolean;
	/**
	 * 检查指定类型的POI是否启用
	 * @param {string} type - POI类型
	 * @returns {boolean} 是否启用
	 */
	isPoiTypeEnabled(type: string): boolean;
	/**
	 * 获取所有可用的POI类型
	 * @returns {string[]} POI类型数组
	 */
	getAvailablePoiTypes(): string[];
	/**
	 * 隐藏指定的dataType
	 * @param {string|number} dataType - 要隐藏的数据类型
	 */
	hideDataType(dataType: string | number): this;
	/**
	 * 从所有已加载的瓦片中移除指定dataType的标签
	 * @param {string|number} dataType - 要移除的数据类型
	 */
	/**
	 * 显示指定的dataType
	 * @param {string|number} dataType - 要显示的数据类型
	 */
	showDataType(dataType: string | number): this;
	/**
	 * 重置指定dataType相关的添加状态标记
	 * @param {string|number} dataType - 数据类型
	 */
	/**
	 * 切换dataType的显示状态
	 * @param {string|number} dataType - 数据类型
	 * @returns {boolean} 切换后是否可见（true=可见，false=隐藏）
	 */
	toggleDataType(dataType: string | number): boolean;
	/**
	 * 检查dataType是否可见
	 * @param {string|number} dataType - 数据类型
	 * @returns {boolean} 是否可见
	 */
	isDataTypeVisible(dataType: string | number): boolean;
	/**
	 * 获取所有隐藏的dataType列表
	 * @returns {Array} 隐藏的dataType数组
	 */
	getHiddenDataTypes(): any[];
	set config(config: {
		tree: {
			enabled: boolean;
			isFoliage: boolean;
			isBox: boolean;
			scaleByZ: boolean;
			instances: ({
				subtype: string;
				diffuseTexture: string;
				normalDepthTexture: string;
				ormTexture: string;
				imposterScale: number;
				uvOffset: number;
			} | {
				subtype: string;
				imposterScale: number;
				uvOffset: number;
				diffuseTexture?: undefined;
				normalDepthTexture?: undefined;
				ormTexture?: undefined;
			})[];
		};
	});
	get config(): {
		tree: {
			enabled: boolean;
			isFoliage: boolean;
			isBox: boolean;
			scaleByZ: boolean;
			instances: ({
				subtype: string;
				diffuseTexture: string;
				normalDepthTexture: string;
				ormTexture: string;
				imposterScale: number;
				uvOffset: number;
			} | {
				subtype: string;
				imposterScale: number;
				uvOffset: number;
				diffuseTexture?: undefined;
				normalDepthTexture?: undefined;
				ormTexture?: undefined;
			})[];
		};
	};
	set labelEnabled(enabled: boolean);
	get labelEnabled(): boolean;
	set poiEnabled(enabled: boolean);
	get poiEnabled(): boolean;
	/**
	 * 设置POI配置的getter/setter
	 */
	set poiConfig(config: any);
	get poiConfig(): any;
}
declare class EditableElementManager {
	addDeletedIds(ids: any): void;
	removeDeletedId(id: any): void;
	removeDeletedIds(ids: any): void;
	hasDeletedId(id: any): boolean;
	updateEditableAttribute: (tile: any) => void;
	shouldBeHidden: (batchTable: any, batchId: any) => boolean;
	onTileLoad: (tile: any, scene: any) => void;
	onTileDispose: (tile: any, scene: any) => void;
	onTileShow: (tile: any) => void;
	onTileHide: (tile: any) => void;
	refreshTile: (tile: any) => void;
	refreshTiles: () => void;
	requestUpdate(): void;
}
declare class Cesium3DTilesetSkipTraversal {
}
declare class GroupMetadata {
	constructor(options?: {});
}
declare class TilesetMetadata {
	constructor(options: any);
	hasProperty(propertyId: any): boolean;
	hasPropertyBySemantic(semantic: any): boolean;
	getPropertyIds(results: any): string[];
	getProperty(propertyId: any): any;
	setProperty(propertyId: any, value: any): boolean;
	getPropertyBySemantic(semantic: any): any;
	setPropertyBySemantic(semantic: any, value: any): boolean;
	get class(): any;
	get extra(): any;
	get extensions(): any;
}
declare class Cesium3DTilesetMetadata {
	constructor(options: any);
	get schema(): any;
	get groups(): GroupMetadata[];
	get groupIds(): any[];
	get tileset(): TilesetMetadata;
	get statistics(): any;
	get extras(): any;
	get extensions(): any;
}
declare class DebugTilesPlugin {
	constructor(options: any);
	name: string;
	tiles: any;
	extremeDebugDepth: number;
	extremeDebugError: number;
	boxGroup: Group<import("three").Object3DEventMap>;
	sphereGroup: Group<import("three").Object3DEventMap>;
	regionGroup: Group<import("three").Object3DEventMap>;
	displayBoxBounds: any;
	displaySphereBounds: any;
	displayRegionBounds: any;
	colorMode: any;
	maxDebugDepth: any;
	maxDebugDistance: any;
	maxDebugError: any;
	customColorCallback: any;
	getDebugColor: (value: any, target: any) => void;
	init(tileset: any): void;
	tileset: any;
	dispose(): void;
}
declare class Cesium3DTileset extends Object3D<import("three").Object3DEventMap> {
	static RAYCAST_NONE: number;
	static RAYCAST_DEFAULT: number;
	static RAYCAST_BVH: number;
	static supportedExtensions: {
		"3DTILES_metadata": boolean;
		"3DTILES_implicit_tiling": boolean;
		"3DTILES_content_gltf": boolean;
		"3DTILES_multiple_contents": boolean;
		"3DTILES_bounding_volume_S2": boolean;
		"3DTILES_batch_table_hierarchy": boolean;
		"3DTILES_draco_point_compression": boolean;
		MAXAR_content_geojson: boolean;
	};
	static checkSupportedExtensions: (extensionsRequired: any) => void;
	static fromAssetId(assetId: any, options: any): Promise<Cesium3DTileset>;
	static fromUrl(url: any, options: any): Cesium3DTileset;
	static fromUrlAsync(url: any, options: any): Promise<Cesium3DTileset>;
	static loadJson(tilesetUrl: any): Promise<any>;
	constructor(options: any);
	isEventEntitySupported: boolean;
	is3DTiles: boolean;
	plugins: any[];
	preferLeaves: any;
	dynamicScreenSpaceError: any;
	dynamicScreenSpaceErrorDensity: any;
	dynamicScreenSpaceErrorFactor: any;
	dynamicScreenSpaceErrorHeightFalloff: any;
	foveatedScreenSpaceError: any;
	foveatedInterpolationCallback: any;
	loadSiblings: any;
	dynamicScreenSpaceHeightScale: any;
	cullRequestsWhileMoving: any;
	cullRequestsWhileMovingMultiplier: any;
	progressiveResolutionHeightFraction: number;
	optimizeRaycast: any;
	set forceUnlit(value: boolean);
	get forceUnlit(): boolean;
	group: Group<import("three").Object3DEventMap>;
	set debug(value: any);
	get debug(): any;
	getBounds(): Box3;
	isEntityVisible(entity: any): boolean;
	handleLoadTileset(): void;
	handleLoadTile(e: any): void;
	handleDisposeTile(e: any): void;
	handleTileVisibleChanged(e: any): void;
	updateCustomLoaders(): void;
	afterAddToEngine(engine: any): void;
	setCamera(camera: any): void;
	hasCamera(): boolean;
	deleteCamera(): void;
	getCamera(): any;
	handleBeforeRender: (engine: any) => void;
	getEntityByIntersection(intersection: any): {
	};
	updateInfo(): void;
	prePassesUpdate(renderState: any): void;
	parseBatchTableAttribute: (content: any, property: any) => void;
	traversalLoadedTile: (callback: any) => void;
	forEachLoadedModel(callback: any): void;
	update(renderState: any): void;
	trimLoadedTiles(): void;
	postPassesUpdate(renderState: any): void;
	beforeRemoveFromEngine(engine: any): void;
	dispose(): void;
	disposePlugins(): void;
	resetQueue(): void;
	getTraversal(): typeof Cesium3DTilesetSkipTraversal;
	isDestroyed(): boolean;
	setTilesetProperties(tilesetJson: any, resource: any, options: any): Promise<void>;
	getBoundingBox(target: any): boolean;
	loadTileset(resource: any, tilesetJson: any, parentTile: any): Cesium3DTile;
	registerPlugin(plugin: any): any;
	raycast(raycaster: any, intersects: any): void;
	set raycastMethod(value: number);
	get raycastMethod(): number;
	get root(): Cesium3DTile;
	get modelMatrix(): Matrix4;
	get screenSpaceError(): any;
	set cacheBytes(value: any);
	get cacheBytes(): any;
	set maximumCacheOverflowBytes(value: any);
	get maximumCacheOverflowBytes(): any;
	get gltfUpMatrix(): Matrix4;
	get metadataExtension(): Cesium3DTilesetMetadata;
	get schema(): any;
	get metadata(): TilesetMetadata;
	set foveatedConeSize(value: any);
	get foveatedConeSize(): any;
	get totalMemoryUsageInBytes(): number;
	get statistics(): Cesium3DTilesetStatistics;
	set foveatedMinimumScreenSpaceErrorRelaxation(value: any);
	get foveatedMinimumScreenSpaceErrorRelaxation(): any;
	set maximumScreenSpaceError(value: any);
	get maximumScreenSpaceError(): any;
	get debugTilesPlugin(): DebugTilesPlugin;
	set displayBoxBounds(value: any);
	get displayBoxBounds(): any;
	set displayRegionBounds(value: any);
	get displayRegionBounds(): any;
	set displaySphereBounds(value: any);
	get displaySphereBounds(): any;
	set freezeUpdate(freezeUpdate: boolean);
	get freezeUpdate(): boolean;
	set materialManager(materialManager: any);
	get materialManager(): any;
	set castShadow(value: any);
	get castShadow(): any;
	set receiveShadow(value: any);
	get receiveShadow(): any;
	get instancedElementManager(): TileInstancedElementManager;
	get editableElementManager(): EditableElementManager;
	get elementsManager(): ElementsManager;
}
/**
 * 3D Tiles加载器，用于加载和渲染3D Tiles数据。
 * 支持从URL或Cesium Ion asset ID加载3D Tiles，并提供坐标转换、相机视角锁定等功能。
 *
 * @category 3DTiles
 * @example
 * ```javascript
 * // 从URL加载3D Tiles
 * const tileset = engine.add(new mapvthree.Default3DTiles({
 *     url: 'path/to/tileset.json',
 *     errorTarget: 16
 * }));
 *
 * // 从Cesium Ion asset ID加载
 * const tileset = await mapvthree.Default3DTiles.fromAssetId('assetId', {
 *     errorTarget: 16
 * });
 * ```
 */
export class Default3DTiles extends Cesium3DTileset {
	/**
	 * 从Cesium Ion asset ID创建3D Tiles实例
	 * @param {number} assetId Cesium Ion asset ID
	 * @param {Object} [options={}] 配置参数
	 * @returns {Promise<Default3DTiles>} 返回3D Tiles实例
	 * @example
	 * ```javascript
	 * const tileset = await mapvthree.Default3DTiles.fromAssetId('assetId', {
	 *     errorTarget: 16
	 * });
	 * ```
	 */
	static fromAssetId(assetId: number, options?: any): Promise<Default3DTiles>;
	/**
	 * 构造函数
	 * @param {Object} options 配置参数
	 * @param {string} [options.url] 3D Tiles的URL地址
	 * @param {number} [options.assetId] Cesium Ion asset ID
	 * @param {number} [options.errorTarget=64] 屏幕空间误差目标值
	 * @param {boolean} [options.forceUnlit=false] 是否强制使用无光照模式
	 * @param {boolean} [options.cullWithChildrenBounds=true] 是否使用子节点边界进行剔除
	 * @param {boolean} [options.cullRequestsWhileMoving=true] 移动时是否剔除请求
	 * @param {number} [options.cullRequestsWhileMovingMultiplier=60] 移动时剔除请求的乘数
	 * @param {boolean} [options.dynamicScreenSpaceError=true] 是否使用动态屏幕空间误差
	 * @param {number} [options.dynamicScreenSpaceErrorHeightFalloff=0.25] 动态屏幕空间误差高度衰减
	 * @param {number} [options.dynamicScreenSpaceErrorDensity=0.00278] 动态屏幕空间误差密度
	 * @param {boolean} [options.foveatedScreenSpaceError=false] 是否使用注视点屏幕空间误差
	 * @param {number} [options.foveatedConeSize=0.3] 注视点锥体大小
	 * @param {number} [options.foveatedMinimumScreenSpaceErrorRelaxation=0.8] 注视点最小屏幕空间误差松弛值
	 * @param {number} [options.progressiveResolutionHeightFraction=0.5] 渐进式分辨率高度分数
	 * @param {number} [options.cacheBytes] 缓存字节数
	 * @param {number} [options._maximumCacheOverflowBytes] 最大缓存溢出字节数
	 * @param {Object} [options.loaders] 加载器配置
	 */
	constructor(options: {
		url?: string;
		assetId?: number;
		errorTarget?: number;
		forceUnlit?: boolean;
		cullWithChildrenBounds?: boolean;
		cullRequestsWhileMoving?: boolean;
		cullRequestsWhileMovingMultiplier?: number;
		dynamicScreenSpaceError?: boolean;
		dynamicScreenSpaceErrorHeightFalloff?: number;
		dynamicScreenSpaceErrorDensity?: number;
		foveatedScreenSpaceError?: boolean;
		foveatedConeSize?: number;
		foveatedMinimumScreenSpaceErrorRelaxation?: number;
		progressiveResolutionHeightFraction?: number;
		cacheBytes?: number;
		loaders?: any;
	});
	/**
	 * 锁定相机视角
	 * @example
	 * ```javascript
	 * tileset.lockCameraViewport();
	 * ```
	 */
	lockCameraViewport: () => void;
	/**
	 * 释放相机视角锁定
	 * @example
	 * ```javascript
	 * tileset.releaseCameraViewport();
	 * ```
	 */
	releaseCameraViewport: () => void;
	/**
	 * 设置是否显示调试信息
	 * @param {boolean} value 是否显示调试信息
	 */
	set showDebug(value: boolean);
	/**
	 * 是否显示调试信息
	 * @type {boolean}
	 */
	get showDebug(): boolean;
	/**
	 * 设置屏幕空间误差目标值
	 * @param {number} value 误差目标值
	 */
	set errorTarget(value: number);
	/**
	 * 屏幕空间误差目标值
	 * @type {number}
	 */
	get errorTarget(): number;
	/**
	 * 设置是否使用子节点边界进行剔除
	 * @param {boolean} value 是否使用子节点边界进行剔除
	 */
	set cullWithChildrenBounds(value: boolean);
	/**
	 * 是否使用子节点边界进行剔除
	 * @type {boolean}
	 */
	get cullWithChildrenBounds(): boolean;
	/**
	 * 设置移动时是否剔除请求
	 * @param {boolean} value 移动时是否剔除请求
	 */
	set cullRequestsWhileMoving(value: boolean);
	/**
	 * 移动时是否剔除请求
	 * @type {boolean}
	 */
	get cullRequestsWhileMoving(): boolean;
	/**
	 * 设置注视点锥体大小
	 * @param {number} value 注视点锥体大小
	 */
	set foveatedConeSize(value: number);
	/**
	 * 注视点锥体大小
	 * @type {number}
	 */
	get foveatedConeSize(): number;
	/**
	 * 设置是否加载兄弟节点
	 * @param {boolean} value 是否加载兄弟节点
	 */
	set loadSiblings(value: boolean);
	/**
	 * 是否加载兄弟节点
	 * @type {boolean}
	 */
	get loadSiblings(): boolean;
}
/**
 * GeoJSON格式数据的数据源，支持加载标准GeoJSON对象或通过URL加载远程数据
 *
 * GeoJSONDataSource专门处理标准GeoJSON格式的地理数据，支持以下形式：
 * - FeatureCollection（特征集合）
 * - Feature（单个特征）
 * - Features数组（特征数组）
 *
 * 支持所有标准GeoJSON几何类型：
 * - Point（点）
 * - LineString（线）
 * - Polygon（面）
 * - MultiPoint（多点）
 * - MultiLineString（多线）
 * - MultiPolygon（多面）
 *
 * @category DataSource
 * @example
 * ```javascript
 * // 示例1: 从GeoJSON对象创建
 * const geojson = {
 *   type: 'FeatureCollection',
 *   features: [{
 *     type: 'Feature',
 *     geometry: {
 *       type: 'Point',
 *       coordinates: [116.39, 39.9]
 *     },
 *     properties: {
 *       name: '北京',
 *       value: 100
 *     }
 *   }]
 * };
 * const dataSource = GeoJSONDataSource.fromGeoJSON(geojson);
 *
 * // 示例2: 从URL加载
 * const dataSource = await GeoJSONDataSource.fromURL('path/to/data.geojson');
 * ```
 */
export class GeoJSONDataSource extends DataSource {
	/**
	 * 从GeoJSON对象创建数据源实例
	 * @param {object} geoJSONObject GeoJSON数据对象
	 * @param {object} [options] 配置选项，传递给{@link DataSource}构造函数
	 * @returns {GeoJSONDataSource} 新创建的数据源实例
	 * @example
	 * ```javascript
	 * const dataSource = GeoJSONDataSource.fromGeoJSON({
	 *   type: 'FeatureCollection',
	 *   features: [...]
	 * });
	 * ```
	 */
	static fromGeoJSON: (geoJSONObject: object, options?: object) => GeoJSONDataSource;
	/**
	 * 从URL异步加载GeoJSON数据
	 * @param {string} url 数据的URL路径
	 * @param {object} [options] 配置选项，传递给{@link DataSource}构造函数
	 * @returns {Promise<GeoJSONDataSource>} 包含数据源实例的Promise
	 * @example
	 * ```javascript
	 * const dataSource = await GeoJSONDataSource.fromURL('path/to/data.geojson');
	 * console.log(`加载了${dataSource.size}个数据项`);
	 * ```
	 */
	static fromURL: (url: string, options?: object) => Promise<GeoJSONDataSource>;
	/**
	 * 创建GeoJSONDataSource实例
	 * @param {object} [options] 配置选项，传递给{@link DataSource}构造函数
	 */
	constructor(options?: object);
	type: string;
}
/**
 * JSON格式数据的数据源，支持加载标准JSON对象或通过URL加载远程数据
 *
 * JSONDataSource适用于处理结构化的JSON数据，可以通过自定义解析器处理各种JSON格式。
 * 它提供了灵活的配置选项，允许定义：
 * - 坐标字段名（默认为'coordinates'）
 * - 自定义坐标解析函数
 * - 自定义特征解析函数
 *
 * 支持从多种来源加载数据：
 * - 从URL加载
 * - 直接传入JSON对象
 *
 * @category DataSource
 * @example
 * ```javascript
 * // 示例1: 从URL加载JSON数据
 * const dataSource = await JSONDataSource.fromURL('path/to/data.json');
 *
 * // 示例2: 从JSON对象创建
 * const jsonData = [
 *   { coordinates: 'POINT(116.39 39.9)', name: '北京', value: 100 },
 *   { coordinates: 'POINT(121.47 31.23)', name: '上海', value: 90 }
 * ];
 * const dataSource = JSONDataSource.fromJSON(jsonData);
 *
 * // 示例3: 自定义坐标字段和解析函数
 * const dataSource = new JSONDataSource({
 *   coordinatesKey: 'geometry',
 *   parseCoordinates: (item) => {
 *     return {
 *       type: 'Point',
 *       coordinates: [item.lon, item.lat]
 *     };
 *   }
 * });
 * ```
 */
export class JSONDataSource extends DataSource {
	/**
	 * 从URL异步加载JSON数据
	 * @param {string} url 数据的URL路径
	 * @param {object} [options] 配置选项，传递给{@link JSONDataSource}构造函数
	 * @returns {Promise<JSONDataSource>} 包含数据源实例的Promise
	 * @example
	 * ```javascript
	 * const dataSource = await JSONDataSource.fromURL('path/to/data.json');
	 * console.log(`加载了${dataSource.size}个数据项`);
	 * ```
	 */
	static fromURL: (url: string, options?: object) => Promise<JSONDataSource>;
	/**
	 * 从JSON对象创建数据源实例
	 * @param {object|Array} object JSON数据对象或数组
	 * @param {object} [options] 配置选项，传递给{@link JSONDataSource}构造函数
	 * @returns {JSONDataSource} 新创建的数据源实例
	 * @example
	 * ```javascript
	 * const jsonData = [
	 *   { coordinates: 'POINT(116.39 39.9)', name: '北京' },
	 *   { coordinates: 'POINT(121.47 31.23)', name: '上海' }
	 * ];
	 * const dataSource = JSONDataSource.fromJSON(jsonData);
	 * ```
	 */
	static fromJSON: (object: object | any[], options?: object) => JSONDataSource;
	/**
	 * 创建JSONDataSource实例
	 * @param {object} [options={}] 配置选项
	 * @param {string} [options.coordinatesKey='coordinates'] 指定JSON中表示坐标的字段名，默认是'coordinates'
	 * @param {Function} [options.parseCoordinates] 自定义坐标解析函数，参数为数据项，返回几何对象
	 * @param {Function} [options.parseFeature] 自定义特征解析函数，参数为数据项，返回DataItem实例
	 * @example
	 * ```javascript
	 * // 自定义坐标字段和解析方法
	 * const dataSource = new JSONDataSource({
	 *   coordinatesKey: 'loc',
	 *   parseCoordinates: (item) => {
	 *     const [lng, lat] = item.loc.split(',');
	 *     return {
	 *       type: 'Point',
	 *       coordinates: [parseFloat(lng), parseFloat(lat)]
	 *     };
	 *   }
	 * });
	 * ```
	 */
	constructor(options?: {
		coordinatesKey?: string;
		parseCoordinates?: Function;
		parseFeature?: Function;
	});
	type: string;
	/**
	 * 设置坐标字段的键名
	 * @param {string} value 新的键名
	 * @example
	 * ```javascript
	 * dataSource.coordinatesKey = 'geometryField';
	 * ```
	 */
	set coordinatesKey(value: string);
	/**
	 * 获取坐标字段的键名
	 * @type {string}
	 */
	get coordinatesKey(): string;
	/**
	 * 设置坐标解析函数
	 * @param {Function} value 解析函数，参数为数据项，返回几何对象
	 * @example
	 * ```javascript
	 * dataSource.parseCoordinates = (item) => {
	 *   return {
	 *     type: 'Point',
	 *     coordinates: [item.lon, item.lat]
	 *   };
	 * };
	 * ```
	 */
	set parseCoordinates(value: Function);
	/**
	 * 获取坐标解析函数
	 * @type {Function|undefined}
	 */
	get parseCoordinates(): Function | undefined;
	/**
	 * 设置特征解析函数
	 * @param {Function} value 解析函数，参数为数据项，返回DataItem实例
	 * @example
	 * ```javascript
	 * dataSource.parseFeature = (item) => {
	 *   return new DataItem({
	 *     geometry: {
	 *       type: 'Point',
	 *       coordinates: [item.lon, item.lat]
	 *     },
	 *     properties: {
	 *       name: item.name,
	 *       value: item.value
	 *     }
	 *   });
	 * };
	 * ```
	 */
	set parseFeature(value: Function);
	/**
	 * 获取特征解析函数
	 * @type {Function|undefined}
	 */
	get parseFeature(): Function | undefined;
}
/**
 * CSV格式数据的数据源，支持加载标准CSV文件或通过URL加载远程数据
 *
 * CSVDataSource继承自{@link JSONDataSource}，专门用于处理CSV格式的数据。
 * CSV数据会被解析为JSON对象数组，每行CSV数据对应一个对象，列名作为对象属性名。
 *
 * 支持两种方式创建数据源：
 * - 从CSV字符串创建
 * - 从URL异步加载
 *
 * @category DataSource
 * @example
 * ```javascript
 * // 示例1: 从CSV字符串创建
 * const csvString = `lat,lng,name,value
 * 39.9,116.39,北京,100
 * 31.23,121.47,上海,90
 * 23.13,113.26,广州,80`;
 * const dataSource = CSVDataSource.fromCSVString(csvString);
 *
 * // 示例2: 从URL加载
 * const dataSource = await CSVDataSource.fromURL('path/to/data.csv');
 * ```
 */
export class CSVDataSource extends JSONDataSource {
	/**
	 * 从URL异步加载CSV数据
	 * @param {string} url 数据的URL路径
	 * @param {object} [options] 配置选项，传递给{@link JSONDataSource}构造函数
	 * @returns {Promise<CSVDataSource>} 包含数据源实例的Promise
	 * @example
	 * ```javascript
	 * const dataSource = await CSVDataSource.fromURL('path/to/data.csv');
	 * console.log(`加载了${dataSource.size}个数据项`);
	 * ```
	 */
	static fromURL: (url: string, options?: object) => Promise<CSVDataSource>;
	/**
	 * 从CSV字符串创建数据源实例
	 * @param {string} csvString CSV格式的字符串
	 * @param {object} [options] 配置选项，传递给{@link JSONDataSource}构造函数
	 * @returns {CSVDataSource} 新创建的数据源实例
	 * @example
	 * ```javascript
	 * const csvString = `lat,lng,name,value
	 * 39.9,116.39,北京,100
	 * 31.23,121.47,上海,90`;
	 * const dataSource = CSVDataSource.fromCSVString(csvString);
	 * ```
	 */
	static fromCSVString: (csvString: string, options?: object) => CSVDataSource;
	/**
	 * 创建CSVDataSource实例
	 * @param {object} [options] 配置选项，传递给{@link JSONDataSource}构造函数
	 */
	constructor(options?: object);
}
declare class PointerLockControls extends EventDispatcher<any> {
	constructor(camera: any, domElement: any);
	domElement: any;
	camera: any;
	isLocked: boolean;
	minPolarAngle: number;
	maxPolarAngle: number;
	pointerSpeed: number;
	connect: () => void;
	disconnect: () => void;
	dispose: () => void;
	getObject: () => any;
	getDirection: (v: any) => any;
	moveForward: (distance: any) => void;
	moveRight: (distance: any) => void;
	moveUp: (distance: any) => void;
	lock: () => void;
	unlock: () => void;
}
declare class Scene3DController {
	constructor(ellipsoidCamera: any, pointerSpeed?: number);
	ellipsoidCamera: any;
	pointerSpeed: number;
	handleMouseMove(camera: any, event: any): void;
	moveForward(camera: any, distance: any): void;
	moveRight(camera: any, distance: any): void;
	moveUp(camera: any, distance: any): void;
}
declare class ColumbusController {
	constructor(pointerSpeed?: number);
	pointerSpeed: number;
	minPolarAngle: number;
	maxPolarAngle: number;
	handleMouseMove(camera: any, event: any): void;
	moveForward(camera: any, distance: any): void;
	moveRight(camera: any, distance: any): void;
	moveUp(camera: any, distance: any): void;
}
/**
 * 第一人称视角控制控件
 * 使用方法：激活控件后，通过键盘进行移动，可以开启lock进行视野旋转
 * - W：向前移动
 * - A：向左移动
 * - S：向后移动
 * - D：向右移动
 * - L：旋转视野
 * @category Camera
 * @example
 * ```javascript
 * const control = new mapvthree.PointerLockControl(engine);
 * // 开启鼠标控制
 * control.enableKeyboardEvent = true;
 * // 设置移动距离
 * control.forwardStepSize = 10;
 * control.rightStepSize = 20;
 * ```
 */
export class PointerLockControl extends PointerLockControls {
	constructor(engine: any);
	set stepSize(value: any);
	controller: Scene3DController | ColumbusController;
	createController(): Scene3DController | ColumbusController;
	set enableKeyboardEvent(value: any);
	animationMove: () => void;
	set forwardStepSize(value: any);
	/** 前后方向步进 */
	get forwardStepSize(): any;
	_forwardStepSize: any;
	set rightStepSize(value: any);
	/** 左右方向步进 */
	get rightStepSize(): any;
	set topStepSize(value: any);
	/** @public */ public onStart: any;
	/** @public */ public onFinish: any;
	onBeforeScenePrepareRender(engine: any, scene: any, camera: any, renderState: any): void;
	afterAddToEngine(engine: any): void;
	start(options?: {}): void;
	/**
	 * 暂停动画
	 * @returns 当前状态
	 */
	pause(): any;
	/**
	 * 停止动画
	 */
	stop(): void;
	/**
	 * @protected
	 * 更新动画状态
	 */
	protected update: () => void;
	dirUpToHPR(direction: any, position: any, up: any): {
		heading: any;
		pitch: any;
		roll: any;
	};
	updateObject(animationState: any): void;
	updateCamera(animationState: any): void;
	distanceToZoom(distance: any): any;
	set viewMode(value: any);
	get viewMode(): any;
	set lockView(value: boolean);
	get lockView(): boolean;
	set viewFollow(value: boolean);
	get viewFollow(): boolean;
	/**
	 * 获取当前状态
	 */
	get currentState(): any;
	/**
	 * 获取是否正在运行
	 */
	get isRunning(): boolean;
	/**
	 * 获取是否暂停
	 */
	get isPaused(): boolean;
	set object(value: any);
	get object(): any;
}
/**
 * 路径追踪器，用于沿指定路径进行相机或对象的动画追踪
 *
 * `PathTracker` 支持多种路径数据格式，包括坐标数组、GeoJSON和带帧信息的对象数组。
 * 可以设置不同的视图模式（跟随、锁定、关键帧等）来实现各种追踪效果。
 *
 * @category Camera
 * @extends TrackerAbstract
 * @example
 * ```javascript
 * // 基本用法 - 沿路径追踪相机
 * const tracker = engine.add(new mapvthree.PathTracker());
 *
 * // 设置路径数据（坐标数组格式）
 * tracker.track = [
 *     [112.368264, 23.176959, 38.553634],
 *     [112.370264, 23.178959, 40.553634],
 *     [112.372264, 23.180959, 42.553634]
 * ];
 *
 * // 开始追踪
 * tracker.start({
 *     duration: 10000,
 *     pitch: 60,
 *     range: 100
 * });
 * ```
 * @example
 * ```javascript
 * // 对象追踪 - 让3D模型沿路径移动
 * const model = engine.add(new mapvthree.SimpleModel({
 *     url: 'path/to/model.glb'
 * }));
 *
 * const tracker = engine.add(new mapvthree.PathTracker());
 * tracker.track = pathCoordinates;
 * tracker.object = model; // 设置要追踪的对象
 * tracker.start({
 *     duration: 8000,
 *     range: 50
 * });
 * ```
 */
export class PathTracker extends TrackerAbstract {
	/**
	 * 设置路径数据
	 *
	 * 支持多种数据格式：
	 * - ***坐标数组***：[[lng, lat, alt], [lng, lat, alt], ...]
	 * - ***GeoJSON***：{geometry: {type: 'LineString', coordinates: [...]}, properties: {frameInfo: [...]}}
	 * - ***帧信息数组***：[{x, y, z, yaw, pitch, speed, time}, ...]
	 *
	 * @param {Array|Object} target 路径数据
	 * @example
	 * ```javascript
	 * // 坐标数组格式
	 * tracker.track = [
	 *     [112.368264, 23.176959, 38.553634],
	 *     [112.370264, 23.178959, 40.553634]
	 * ];
	 * ```
	 */
	set track(target: any[] | any);
	/**
	 * 获取当前路径数据
	 * @returns {Array|null} 路径数据
	 */
	get track(): any[] | null;
	/**
	 * 设置插值直接阈值
	 * 用于控制路径插值的平滑程度，值越大路径拐角过渡越平滑，但也会越偏离实际路线
	 * @param {number} value 阈值
	 */
	set interpolateDirectThreshold(value: number);
	/**
	 * 获取插值直接阈值
	 * @returns {number} 当前阈值
	 */
	get interpolateDirectThreshold(): number;
	/**
	 * 设置轨迹点插值方式
	 * @param {string} value 插值方式，可选值：'curve'（曲线插值）
	 * @example
	 * ```javascript
	 * // 启用曲线插值，使路径更加平滑
	 * tracker.pointHandle = 'curve';
	 * ```
	 */
	set pointHandle(value: string);
	/**
	 * 获取轨迹点插值方式
	 * @returns {string} 当前插值方式
	 */
	get pointHandle(): string;
	curvePath: CatmullRomCurve3;
}
/**
 * 旋转追踪器，用于围绕指定对象或坐标点进行环绕追踪
 *
 * OrbitTracker 可以实现相机围绕目标对象的环绕动画，支持：
 * - 围绕3D对象旋转
 * - 围绕地理坐标点旋转
 * - 围绕投影坐标点旋转
 *
 * @category Camera
 * @extends TrackerAbstract
 * @example
 * ```javascript
 * // 基本用法 - 围绕3D模型旋转
 * const model = engine.add(new mapvthree.SimpleModel({
 *     url: 'path/to/model.glb'
 * }));
 *
 * const tracker = engine.add(new mapvthree.OrbitTracker());
 * tracker.start({
 *     object: model,
 *     radius: 100,
 *     duration: 10000,
 *     startAngle: 0,
 *     endAngle: 360
 * });
 * ```
 * @example
 * ```javascript
 * // 围绕地理坐标点旋转
 * const tracker = engine.add(new mapvthree.OrbitTracker());
 * tracker.start({
 *     center: [112.368264, 23.176959, 38.553634],
 *     radius: 200,
 *     duration: 15000,
 *     pitch: 60,
 *     heading: 45
 * });
 * ```
 */
export class OrbitTracker extends TrackerAbstract {
	/**
	 * 创建旋转追踪器
	 * @param {Object} options 配置选项
	 */
	constructor(options?: any);
	/**
	 * 开始旋转追踪
	 *
	 * @param {Object} options 配置选项
	 * @param {number} [options.duration=10000] 动画持续时间(毫秒)
	 * @param {number} [options.heading=0] 方位角(度)
	 * @param {number} [options.pitch=0] 俯仰角(度)
	 * @param {number} [options.range=0] 距离范围(米)
	 * @param {string|Function} [options.easing] 缓动函数，默认值'linear', 支持'linear'|'ease-in'|'ease-out'|'ease-in-out'
	 * @param {Object3D} [options.object] 要围绕的3D对象
	 * @param {Array} [options.center] 地理坐标 [lng, lat, alt]
	 * @param {Array} [options.projectedCenter] 投影坐标 [x, y, z]
	 * @param {number} [options.radius=100] 旋转半径
	 * @param {number} [options.startAngle=0] 起始角度（度）
	 * @param {number} [options.endAngle=360] 结束角度（度）
	 * @param {string} [options.loopMode='repeat'] 循环模式：'repeat'|'reverse'|'alternate',
	 * `repeat` 表示一直按同方向循环，`alternate` 表示往返循环，`reverse` 表示始终反向循环。
	 * @param {boolean} [options.keepRunning=true] 是否持续运行
	 * @param {boolean} [options.useWorldAxis=false] 是否使用世界轴
	 * @param {number} [options.repeatCount=1] 重复次数，默认值1
	 * @param {number} [options.height=0] 高度偏移(米)
	 * @example
	 * ```javascript
	 * // 围绕3D模型旋转
	 * tracker.start({
	 *     object: model,
	 *     radius: 100,
	 *     duration: 10000,
	 *     startAngle: 0,
	 *     endAngle: 360,
	 *     pitch: 60
	 * });
	 * ```
	 */
	start(options?: {
		duration?: number;
		heading?: number;
		pitch?: number;
		range?: number;
		easing?: string | Function;
		object?: Object3D;
		center?: any[];
		projectedCenter?: any[];
		radius?: number;
		startAngle?: number;
		endAngle?: number;
		loopMode?: string;
		keepRunning?: boolean;
		useWorldAxis?: boolean;
		repeatCount?: number;
		height?: number;
	}): void;
}
export class HorizontalOrbitTracker extends OrbitTracker {
	/**
	 * 旋转追踪器，围绕目标做水平旋转，使用更直观
	 *
	 * @param {Object} [options] 配置项
	 * @param {number} [options.duration=10000] 动画持续时间(毫秒)
	 * @param {Object3D} [options.object] 要围绕的3D对象
	 * @param {Array} [options.center] 地理坐标 [lng, lat, alt]
	 * @param {Array} [options.projectedCenter] 投影坐标 [x, y, z]
	 * @param {number} [options.range=100] 目标点到观察点的真实空间距离
	 * @param {number} [options.angle=0] 观察方向相对水平面的仰角，单位：度；正值表示向上
	 * @param {number} [options.startAngle=0] 起始水平角度（度）
	 * @param {number} [options.endAngle=360] 结束水平角度（度）
	 * @param {string} [options.loopMode='repeat'] 循环模式：'repeat'|'reverse'|'alternate'
	 * @param {boolean} [options.keepRunning=true] 是否持续运行
	 * @param {number} [options.repeatCount=1] 重复次数，默认值
	 * @param {string|Function} [options.easing] 缓动函数
	 * @param {number} [options.delay=0] 延迟启动时间 (毫秒)
	 * @param {'normal'|'reverse'|'alternate'|'alternate-reverse'} [options.direction='normal'] 循环方向
	 */
	start(options?: {
		duration?: number;
		object?: Object3D;
		center?: any[];
		projectedCenter?: any[];
		range?: number;
		angle?: number;
		startAngle?: number;
		endAngle?: number;
		loopMode?: string;
		keepRunning?: boolean;
		repeatCount?: number;
		easing?: string | Function;
		delay?: number;
		direction?: "normal" | "reverse" | "alternate" | "alternate-reverse";
	}): void;
}
/**
 * 对象追踪器，用于追踪指定的3D对象或坐标点
 *
 * `ObjectTracker`可以追踪各种Three.js `Object3D` 对象
 *
 * @category Camera
 * @extends TrackerAbstract
 * @example
 * ```javascript
 * // 基本用法 - 追踪3D模型
 * const model = engine.add(new mapvthree.SimpleModel({
 *     url: 'path/to/model.glb'
 * }));
 *
 * const tracker = engine.add(new mapvthree.ObjectTracker());
 * tracker.track(model, {
 *     range: 100,
 *     pitch: 60,
 * });
 * ```
 */
export class ObjectTracker extends TrackerAbstract {
	/**
	 * 开始追踪指定对象
	 *
	 * @param {Object3D} object 追踪的对象
	 *   - Object3D: Three.js 3D对象
	 * @param {Object} config 追踪配置
	 * @param {number} [config.range=0] 追踪距离
	 * @param {number} [config.pitch=0] 俯仰角
	 * @param {number} [config.heading=0] 方位角
	 * @param {number} [config.height=0] 高度偏移
	 * @param {number} [config.extraDir] 额外方向修正角度
	 * @param {number} [config.duration=0] 持续时间（0表示持续追踪）
	 * @example
	 * ```javascript
	 * // 追踪3D模型，设置相机距离和角度
	 * tracker.track(model, {
	 *     range: 100,    // 距离100米
	 *     pitch: 60,     // 俯仰角60
	 *     heading: 45,   // 方位角45
	 * });
	 * ```
	 */
	track(object: Object3D, config?: {
		range?: number;
		pitch?: number;
		heading?: number;
		height?: number;
		extraDir?: number;
		duration?: number;
	}): void;
	/**
	 * 追踪帧回调函数, 在每帧更新时调用
	 * @param {Object|null} lastState 上一帧状态
	 * @param {Object} currentState 当前帧状态
	 * @example
	 * ```javascript
	 * tracker.onTrackFrame = (lastState, currentState) => {
	 *     console.log('追踪状态更新:', currentState);
	 *     // 自定义逻辑
	 * };
	 * ```
	 */
	onTrackFrame(): void;
}
export namespace EasingFunction {
	function LINEAR(amount: number): number;
	function QUINTIC_IN_OUT(amount: number): number;
	function CUBIC_OUT(amount: number): number;
}
/**
 * 绘制器类型枚举（统一用于绘制和导出）
 */
export type DrawerType = string;
export namespace DrawerType {
	let POLYGON: string;
	let LINE: string;
	let CIRCLE: string;
	let POINT: string;
	let RECTANGLE: string;
}
/**
 * 测量类型枚举
 */
export type MeasureType = string;
export namespace MeasureType {
	export let DISTANCE: string;
	export let AREA: string;
	let POINT_1: string;
	export { POINT_1 as POINT };
}
/**
 * 地图编辑器类
 *
 * 提供地图要素绘制、编辑、测量、样式管理、数据导入导出等功能。支持多边形、线、点、圆、矩形等几何类型的操作。
 *
 * @category Controls
 * @extends THREE.Object3D
 *
 * @example
 * // 绘制模式示例
 * const editor = engine.add(new mapvthree.Editor({
 *     type: mapvthree.Editor.DrawerType.POLYGON,
 *     showLabel: false,
 *     enableMidpointHandles: true,
 *     continuousDrawing: false,
 *     renderOptions: {
 *         depthTest: false,
 *         transparent: true,
 *         renderOrder: 0
 *     }
 * }));
 *
 * editor.setStyle({
 *     fillColor: '#ff0000',
 *     strokeColor: '#00ff00'
 * });
 * editor.start();
 * editor.enableEdit();
 * const data = editor.exportData();
 */
export class Editor {
	/**
	 * 绘制器类型常量
	 *
	 * 包含所有支持的绘制类型：
	 * - `POLYGON` - 多边形绘制
	 * - `LINE` - 线段绘制
	 * - `CIRCLE` - 圆形绘制
	 * - `POINT` - 点绘制
	 * - `RECTANGLE` - 矩形绘制
	 *
	 * @type {Object}
	 * @readonly
	 * @property {string} POLYGON - 多边形，值为 'polygon'
	 * @property {string} LINE - 线段，值为 'line'
	 * @property {string} CIRCLE - 圆形，值为 'circle'
	 * @property {string} POINT - 点，值为 'point'
	 * @property {string} RECTANGLE - 矩形，值为 'rectangle'
	 * @example
	 * // 使用绘制器类型常量
	 * const editor = new mapvthree.Editor({
	 *     type: mapvthree.Editor.DrawerType.POLYGON
	 * });
	 * editor.type = mapvthree.Editor.DrawerType.LINE;
	 */
	static readonly DrawerType: any;
	/**
	 * 测量类型常量
	 *
	 * 包含所有支持的测量类型：
	 * - `DISTANCE` - 距离测量（基于线段）
	 * - `AREA` - 面积测量（基于多边形）
	 * - `POINT` - 点坐标测量
	 *
	 * @type {Object}
	 * @readonly
	 * @property {string} DISTANCE - 距离测量，值为 'distance'
	 * @property {string} AREA - 面积测量，值为 'area'
	 * @property {string} POINT - 点坐标测量，值为 'point'
	 * @example
	 * // 使用测量类型常量
	 * editor.showLabel = true;
	 * editor.type = mapvthree.Editor.DrawerType.LINE; // 对应距离测量
	 */
	static readonly MeasureType: any;
	/**
	 * 构造函数
	 * @param {Object} [options={}] 配置参数
	 * @param {string} [options.type=DrawerType.POLYGON] 默认绘制类型
	 * @param {boolean} [options.showLabel=false] 是否显示标签（测量模式）
	 * @param {boolean} [options.singleMode=false] 是否启用单要素模式
	 * @param {boolean} [options.enableMidpointHandles] 是否启用中点标记
	 * @param {boolean} [options.continuousDrawing] 是否启用连续绘制模式
	 * @param {Object} [options.renderOptions] 渲染选项配置
	 * @param {boolean} [options.renderOptions.depthTest=true] 是否启用深度测试
	 * @param {boolean} [options.renderOptions.transparent=true] 是否启用透明度
	 * @param {number} [options.renderOptions.renderOrder=0] 渲染顺序
	 * @param {Object} [options.controlPoints] 控制点样式配置
	 * @param {Object} [options.controlPoints.vertex] 顶点标记样式
	 * @param {string} [options.controlPoints.vertex.color='#ffffff'] 顶点颜色
	 * @param {number} [options.controlPoints.vertex.size=10] 顶点大小
	 * @param {Object} [options.controlPoints.midpoint] 中点标记样式
	 * @param {string} [options.controlPoints.midpoint.color='#ffff00'] 中点颜色
	 * @param {number} [options.controlPoints.midpoint.size=8] 中点大小
	 */
	constructor(options?: {
		type?: string;
		showLabel?: boolean;
		singleMode?: boolean;
		enableMidpointHandles?: boolean;
		continuousDrawing?: boolean;
		renderOptions?: {
			depthTest?: boolean;
			transparent?: boolean;
			renderOrder?: number;
		};
		controlPoints?: {
			vertex?: {
				color?: string;
				size?: number;
			};
			midpoint?: {
				color?: string;
				size?: number;
			};
		};
	});
	/**
	 * 当前编辑器类型
	 * @type {string}
	 * @default DrawerType.POLYGON
	 * @example
	 * editor.type = mapvthree.Editor.DrawerType.LINE;
	 */
	type: string;
	/**
	 * 是否显示标签（测量模式）
	 * @type {boolean}
	 * @default false
	 * @example
	 * editor.showLabel = true; // 启用测量模式
	 */
	showLabel: boolean;
	/**
	 * 是否为单要素模式
	 * @type {boolean}
	 * @default false
	 * @description
	 * 启用后，每次绘制新要素时会自动清除之前的要素
	 * @example
	 * editor.singleMode = true; // 启用单要素模式
	 */
	singleMode: boolean;
	/**
	 * 渲染选项配置
	 * @type {Object}
	 * @property {boolean} depthTest - 是否启用深度测试，默认true
	 * @property {boolean} transparent - 是否启用透明度，默认true
	 * @property {number} renderOrder - 渲染顺序，默认0
	 * @example
	 * editor.renderOptions = {
	 *     depthTest: false,
	 *     transparent: true,
	 *     renderOrder: 100
	 * };
	 */
	renderOptions: any;
	context: any;
	options: {
		type?: string;
		showLabel?: boolean;
		singleMode?: boolean;
		enableMidpointHandles?: boolean;
		continuousDrawing?: boolean;
		renderOptions?: {
			depthTest?: boolean;
			transparent?: boolean;
			renderOrder?: number;
		};
		controlPoints?: {
			vertex?: {
				color?: string;
				size?: number;
			};
			midpoint?: {
				color?: string;
				size?: number;
			};
		};
	};
	controlPoints: {
		vertex: {
			color: string;
			size: number;
		};
		midpoint: {
			color: string;
			size: number;
		};
	};
	/**
	 * @protected
	 * @ignore
	 */
	protected getContext(): any;
	/**
	 * @protected
	 * @ignore
	 */
	protected getOptions(): {
		type?: string;
		showLabel?: boolean;
		singleMode?: boolean;
		enableMidpointHandles?: boolean;
		continuousDrawing?: boolean;
		renderOptions?: {
			depthTest?: boolean;
			transparent?: boolean;
			renderOrder?: number;
		};
		controlPoints?: {
			vertex?: {
				color?: string;
				size?: number;
			};
			midpoint?: {
				color?: string;
				size?: number;
			};
		};
	};
	/**
	 * @protected
	 * @ignore
	 */
	protected setType(type: any): void;
	/**
	 * 清空所有数据
	 * @protected
	 * @ignore
	 */
	/**
	 * 开始绘制或测量操作
	 *
	 * 根据 showLabel 配置决定调用绘制功能还是测量功能。当 showLabel 为 true 时，会根据当前 type 自动判断测量类型。
	 *
	 * @param {Object} [options] 操作选项
	 * @param {boolean} [options.continuous] 是否启用连续绘制/测量模式
	 * @returns {boolean|Object} 操作结果
	 * @example
	 * // 开始绘制多边形
	 * editor.type = mapvthree.Editor.DrawerType.POLYGON;
	 * editor.start({ continuous: false });
	 *
	 * @example
	 * // 开始距离测量
	 * editor.showLabel = true;
	 * editor.type = mapvthree.Editor.DrawerType.LINE;
	 * editor.start();
	 */
	start(options?: {
		continuous?: boolean;
	}): boolean | any;
	/**
	 * 停止当前的绘制或测量操作
	 *
	 * 根据当前模式停止相应的操作。如果是测量模式，会同时停止底层的绘制操作。
	 *
	 * @example
	 * // 停止正在进行的绘制或测量
	 * editor.stop();
	 */
	stop(): void;
	/**
	 * 启用要素编辑功能
	 *
	 * 允许用户编辑已绘制的要素，支持通过要素ID或过滤函数指定要编辑的要素。在测量模式下，还可以选择是否为编辑的要素创建测量标签。
	 *
	 * @param {string|function} [featureIdOrFilter] 要素ID或过滤函数，用于指定要编辑的要素。
	 *                                        如果不指定，则编辑所有要素
	 * @param {boolean} [createMeasureLabels=false] 是否为编辑的要素创建测量标签
	 * @example
	 * // 编辑所有要素
	 * editor.enableEdit();
	 *
	 * @example
	 * // 编辑指定ID的要素
	 * editor.enableEdit('feature-123');
	 *
	 * @example
	 * // 编辑符合条件的要素
	 * editor.enableEdit((feature) => {
	 *     return feature.properties.type === 'polygon';
	 * });
	 *
	 * @example
	 * // 编辑要素并创建测量标签
	 * editor.enableEdit(null, true);
	 */
	enableEdit(featureIdOrFilter?: string | Function, createMeasureLabels?: boolean): void;
	/**
	 * 关闭编辑模式
	 *
	 * 停止所有要素的编辑操作，清除编辑控件和选中状态。
	 *
	 * @example
	 * // 退出编辑模式
	 * editor.disableEdit();
	 */
	disableEdit(): void;
	/**
	 * 导出编辑器中的所有数据
	 *
	 * 将编辑器中的要素数据导出为GeoJSON格式的数据，支持按类型筛选导出。
	 *
	 * @param {DrawerType|string} [type] 指定要导出的要素类型，不传则导出所有类型
	 * @returns {Object} GeoJSON格式的数据对象
	 * @example
	 * // 导出所有数据
	 * const allData = editor.exportData();
	 *
	 * @example
	 * // 导出多边形数据
	 * const polygonData = editor.exportData(mapvthree.Editor.DrawerType.POLYGON);
	 */
	exportData(type?: DrawerType | string): any;
	/**
	 * 导入GeoJSON格式数据到编辑器
	 *
	 * 支持导入标准的GeoJSON数据，并将其转换为编辑器可编辑的要素。
	 *
	 * @param {Object} data GeoJSON格式的数据对象
	 * @param {Object} [options] 导入选项配置
	 * @param {boolean} [options.clear=true] 是否清除现有数据
	 * @param {boolean} [options.fitBounds=true] 是否自动调整视图范围
	 * @returns {boolean} 导入是否成功
	 * @example
	 * const geojson = {
	 *     "type": "FeatureCollection",
	 *     "features": [
	 *         {
	 *             "type": "Feature",
	 *             "geometry": {
	 *                 "type": "Polygon",
	 *                 "coordinates": [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]]
	 *             }
	 *         }
	 *     ]
	 * };
	 * editor.importData(geojson);
	 */
	importData(data: any, options?: {
		clear?: boolean;
		fitBounds?: boolean;
	}): boolean;
	/**
	 * 删除指定类型的所有要素
	 *
	 * 根据要素类型删除对应的要素，同时会清理相关的测量标签数据。
	 *
	 * @param {DrawerType|string} [type] 指定要删除的要素类型，不传则删除所有要素
	 * @returns {number} 删除的要素数量
	 * @example
	 * // 删除所有要素
	 * const count = editor.delete();
	 *
	 * @example
	 * // 删除多边形要素
	 * const polygonCount = editor.delete(mapvthree.Editor.DrawerType.POLYGON);
	 */
	delete(type?: DrawerType | string): number;
	/**
	 * 根据 ID 删除要素（支持单个 ID 或 ID 数组）
	 * @param {string|string[]} featureIdOrIds 要素 ID 或 ID 数组
	 * @returns {number} 成功删除的要素数量
	 * @example
	 * // 删除单个要素
	 * editor.deleteById('feature-1');
	 *
	 * // 删除多个要素
	 * editor.deleteById(['feature-1', 'feature-2', 'feature-3']);
	 */
	deleteById(featureIdOrIds: string | string[]): number;
	/**
	 * 获取指定类型的默认样式
	 *
	 * 获取某种要素类型的默认样式配置，用于了解当前的样式设置或作为新样式的基础。
	 *
	 * @param {DrawerType|string} [type=DrawerType.POLYGON] 要素类型
	 * @returns {Object} 样式配置对象
	 * @example
	 * // 获取多边形默认样式
	 * const polygonStyle = editor.getStyle(mapvthree.Editor.DrawerType.POLYGON);
	 */
	getStyle(type?: DrawerType | string): any;
	/**
	 * 设置要素样式
	 *
	 * 为指定类型的要素设置样式配置，该样式将用于后续的绘制操作。
	 *
	 * @param {Object} style 样式配置对象
	 * @param {string} [style.fillColor] 填充颜色
	 * @param {string} [style.strokeColor] 边框颜色
	 * @param {number} [style.strokeWidth] 边框宽度
	 * @param {number} [style.opacity] 透明度
	 * @param {DrawerType|string} [type] 要素类型，不传则设置为所有类型的默认样式
	 * @example
	 * // 设置所有要素的默认样式
	 * editor.setStyle({
	 *     fillColor: '#ff0000',
	 *     strokeColor: '#00ff00',
	 *     strokeWidth: 2,
	 *     opacity: 0.8
	 * });
	 *
	 * @example
	 * // 设置多边形专用样式
	 * editor.setStyle({
	 *     fillColor: '#0000ff',
	 *     fillOpacity: 0.5
	 * }, mapvthree.Editor.DrawerType.POLYGON);
	 */
	setStyle(style: {
		fillColor?: string;
		strokeColor?: string;
		strokeWidth?: number;
		opacity?: number;
	}, type?: DrawerType | string): void;
	/**
	 * 获取默认样式（已废弃）
	 * @deprecated 请使用 getStyle() 方法代替
	 * @ignore
	 * @param {DrawerType|string} [type] 要素类型
	 * @returns {Object} 样式配置对象
	 */
	getDefaultStyle(type?: DrawerType | string): any;
	/**
	 * 设置默认样式（已废弃）
	 * @deprecated 请使用 setStyle() 方法代替
	 * @ignore
	 * @param {Object} style 样式配置对象
	 * @param {DrawerType|string} [type] 要素类型
	 */
	setDefaultStyle(style: any, type?: DrawerType | string): void;
	/**
	 * 更新指定要素的样式
	 *
	 * 为已存在的要素更新样式，支持单个要素或批量更新。
	 *
	 * @param {string|string[]} featureId 要素ID或ID数组
	 * @param {Object} style 新的样式配置
	 * @param {string} [style.fillColor] 填充颜色
	 * @param {string} [style.strokeColor] 边框颜色
	 * @param {number} [style.strokeWidth] 边框宽度
	 * @param {number} [style.opacity] 透明度
	 * @param {boolean} [replace=false] 是否完全替换样式，false表示合并样式
	 * @example
	 * // 更新单个要素样式（合并）
	 * editor.updateFeatureStyle('feature-123', {
	 *     fillColor: '#ff0000'
	 * });
	 *
	 * @example
	 * // 更新多个要素样式（替换）
	 * editor.updateFeatureStyle(['feature-1', 'feature-2'], {
	 *     fillColor: '#00ff00',
	 *     strokeColor: '#0000ff',
	 *     strokeWidth: 3
	 * }, true);
	 */
	updateFeatureStyle(featureId: string | string[], style: {
		fillColor?: string;
		strokeColor?: string;
		strokeWidth?: number;
		opacity?: number;
	}, replace?: boolean): void;
	/**
	 * 显示指定类型的要素
	 *
	 * 控制要素的可见性，可以选择显示所有要素或特定类型的要素。
	 *
	 * @param {DrawerType|string} [type] 指定要显示的要素类型，不传则显示所有类型
	 * @returns {number} 显示的要素数量
	 * @example
	 * // 显示所有要素
	 * const count = editor.show();
	 *
	 * @example
	 * // 只显示多边形要素
	 * const polygonCount = editor.show(mapvthree.Editor.DrawerType.POLYGON);
	 */
	show(type?: DrawerType | string): number;
	/**
	 * 隐藏指定类型的要素
	 *
	 * 控制要素的可见性，可以选择隐藏所有要素或特定类型的要素。
	 *
	 * @param {DrawerType|string} [type] 指定要隐藏的要素类型，不传则隐藏所有类型
	 * @returns {number} 隐藏的要素数量
	 * @example
	 * // 隐藏所有要素
	 * const count = editor.hide();
	 *
	 * @example
	 * // 只隐藏线段要素
	 * const lineCount = editor.hide(mapvthree.Editor.DrawerType.LINE);
	 */
	hide(type?: DrawerType | string): number;
	/**
	 * 获取当前是否处于绘制模式
	 *
	 * 只读属性，用于判断编辑器当前是否正在进行要素绘制操作。
	 *
	 * @type {boolean}
	 * @readonly
	 * @returns {boolean} 是否正在绘制
	 * @example
	 * if (editor.isDrawing) {
	 *     console.log('正在绘制要素...');
	 * }
	 */
	readonly get isDrawing(): boolean;
	/**
	 * 获取当前是否处于编辑模式
	 *
	 * 只读属性，用于判断编辑器当前是否正在进行要素编辑操作。
	 *
	 * @type {boolean}
	 * @readonly
	 * @returns {boolean} 是否正在编辑
	 * @example
	 * if (editor.isEditing) {
	 *     console.log('正在编辑要素...');
	 * }
	 */
	readonly get isEditing(): boolean;
	/**
	 * 添加到引擎时初始化管理器
	 * @protected
	 * @ignore
	 */
	protected afterAddToEngine(engine: any): void;
	/**
	 * 从引擎移除时清理资源
	 * @protected
	 * @ignore
	 */
	protected beforeRemoveFromEngine(): void;
	/**
	 * 释放所有资源
	 * @protected
	 * @ignore
	 */
	protected dispose(): void;
}
/**
 * 测量工具类
 *
 * 专门用于距离、面积、点坐标测量的工具类，继承自Editor类。默认启用标签显示，并提供丰富的测量功能定制选项。
 *
 * @category Controls
 * @extends Editor
 *
 * @example
 * // 距离测量示例
 * const distanceMeasure = engine.add(new mapvthree.Measure({
 *     type: mapvthree.Measure.MeasureType.DISTANCE
 * }));
 * distanceMeasure.setStyle({
 *     strokeColor: '#ffff00',
 *     strokeWidth: 3
 * });
 * distanceMeasure.start();
 *
 * @example
 * // 面积测量示例
 * const areaMeasure = engine.add(new mapvthree.Measure({
 *     type: mapvthree.Measure.MeasureType.AREA
 * }));
 * areaMeasure.start();
 *
 * @example
 * // 点坐标测量示例
 * const pointMeasure = engine.add(new mapvthree.Measure({
 *     type: mapvthree.Measure.MeasureType.POINT
 * }));
 * pointMeasure.start();
 *
 * @example
 * // 自定义标签样式
 * measure.setLabelRenderer((value) => {
 *     const div = document.createElement('div');
 *     div.innerText = value.attributes.text;
 *     div.style.backgroundColor = 'rgba(0, 0, 0, 0.7)';
 *     div.style.color = '#fff';
 *     div.style.padding = '5px 10px';
 *     div.style.borderRadius = '4px';
 *     return div;
 * });
 */
export class Measure extends Editor {
	/**
	 * 构造函数
	 *
	 * 创建测量工具实例，自动配置为测量模式（showLabel=true）和单要素模式。
	 *
	 * @param {Object} [options={}] 配置选项
	 * @param {MeasureType|string} [options.type=MeasureType.DISTANCE] 测量类型，支持距离、面积、点坐标测量
	 * @param {boolean} [options.continuousDrawing=false] 是否启用连续测量模式
	 * @param {boolean} [options.enableMidpointHandles=true] 是否启用中点标记
	 * @param {Object} [options.renderOptions] 渲染选项配置
	 * @param {boolean} [options.renderOptions.depthTest=false] 是否启用深度测试
	 * @param {boolean} [options.renderOptions.transparent=true] 是否启用透明度
	 * @param {number} [options.renderOptions.renderOrder=100] 渲染顺序
	 * @example
	 * // 创建距离测量工具
	 * const measure = new mapvthree.Measure({
	 *     type: mapvthree.Measure.MeasureType.DISTANCE,
	 *     enableMidpointHandles: true,
	 *     renderOptions: {
	 *         depthTest: false,
	 *         transparent: true
	 *     }
	 * });
	 */
	constructor(options?: {
		type?: MeasureType | string;
		continuousDrawing?: boolean;
		enableMidpointHandles?: boolean;
		renderOptions?: {
			depthTest?: boolean;
			transparent?: boolean;
			renderOrder?: number;
		};
	});
	/**
	 * 当前测量类型
	 * @type {string}
	 * @default MeasureType.DISTANCE
	 * @description
	 * 测量工具的当前类型，决定进行何种类型的测量操作
	 * @example
	 * measure.measureType = mapvthree.Measure.MeasureType.AREA;
	 */
	measureType: string;
	/**
	 * 设置测量类型
	 *
	 * 动态更改测量工具的类型，会将测量类型转换为对应的绘制器类型并更新内部状态。
	 *
	 * @param {MeasureType|string} measureType 测量类型，支持 DISTANCE、AREA、POINT
	 * @example
	 * // 切换为面积测量
	 * measure.setType(mapvthree.Measure.MeasureType.AREA);
	 *
	 * @example
	 * // 切换为点坐标测量
	 * measure.setType(mapvthree.Measure.MeasureType.POINT);
	 */
	setType(measureType: MeasureType | string): void;
	/**
	 * 清除所有测量结果
	 *
	 * 删除所有已创建的测量要素和标签，重置测量状态。通常在需要重新开始测量或清理测量结果时使用。
	 *
	 * @example
	 * // 清除所有测量结果
	 * measure.clear();
	 */
	clear(): void;
	/**
	 * 清除指定类型的测量结果
	 *
	 * 根据测量类型删除对应的测量结果和标签，保留其他类型的测量数据。
	 *
	 * @param {MeasureType|string} type 要清除的测量类型
	 * @example
	 * // 只清除距离测量结果
	 * measure.clearByType(mapvthree.Measure.MeasureType.DISTANCE);
	 *
	 * @example
	 * // 只清除面积测量结果
	 * measure.clearByType(mapvthree.Measure.MeasureType.AREA);
	 */
	clearByType(type: MeasureType | string): void;
	/**
	 * 获取所有测量结果
	 *
	 * 返回当前所有测量结果的数据数组，包含测量值、类型、几何信息等详细信息。
	 *
	 * @returns {Array<Object>} 测量结果数组，每个结果包含 id、type、value、geometry 等属性
	 * @example
	 * const results = measure.getMeasurements();
	 * console.log(`共有 ${results.length} 个测量结果`);
	 * results.forEach(result => {
	 *     console.log(`类型: ${result.type}, 值: ${result.value}`);
	 * });
	 */
	getMeasurements(): Array<any>;
	/**
	 * 获取指定类型的测量结果
	 *
	 * 根据测量类型筛选并返回对应的测量结果数据。
	 *
	 * @param {MeasureType|string} type 测量类型，支持 DISTANCE、AREA、POINT
	 * @returns {Array<Object>} 指定类型的测量结果数组
	 * @example
	 * // 只获取距离测量结果
	 * const distanceResults = measure.getMeasurementsByType(mapvthree.Measure.MeasureType.DISTANCE);
	 *
	 * @example
	 * // 只获取面积测量结果
	 * const areaResults = measure.getMeasurementsByType(mapvthree.Measure.MeasureType.AREA);
	 */
	getMeasurementsByType(type: MeasureType | string): Array<any>;
	/**
	 * 自定义测量标签渲染函数
	 *
	 * 设置自定义的标签渲染函数，用于创建个性化的测量结果显示标签。函数接收标签数据并返回DOM元素。
	 *
	 * @param {Function} renderFunction 标签渲染函数
	 * @param {Object} renderFunction.value 标签数据对象
	 * @param {Object} renderFunction.value.attributes 标签属性
	 * @param {string} renderFunction.value.attributes.text 标签文本内容
	 * @param {boolean} renderFunction.value.attributes.isMain 是否为主标签
	 * @param {HTMLElement} renderFunction.return - 返回渲染后的DOM元素
	 * @example
	 * // 自定义标签样式
	 * measure.setLabelRenderer((value) => {
	 *     const div = document.createElement('div');
	 *     div.innerText = value.attributes.text;
	 *     div.style.backgroundColor = 'rgba(0, 0, 0, 0.7)';
	 *     div.style.color = '#fff';
	 *     div.style.padding = '5px 10px';
	 *     div.style.borderRadius = '4px';
	 *     div.style.fontSize = '12px';
	 *     return div;
	 * });
	 *
	 * @example
	 * // 根据标签类型设置不同样式
	 * measure.setLabelRenderer((value) => {
	 *     const div = document.createElement('div');
	 *     div.innerText = value.attributes.text;
	 *     div.style.color = value.attributes.isMain ? 'red' : 'blue';
	 *     div.style.fontWeight = value.attributes.isMain ? 'bold' : 'normal';
	 *     return div;
	 * });
	 */
	setLabelRenderer(renderFunction: Function): void;
	/**
	 * 设置距离测量值格式化函数
	 *
	 * 自定义距离测量值的显示格式，可以添加单位、设置小数位数等。
	 *
	 * @param {Function} formatter 格式化函数
	 * @param {number} formatter.distance 原始距离值（单位：米）
	 * @returns {string} 格式化后的距离字符串
	 * @example
	 * // 简单格式化
	 * measure.setDistanceFormatter((distance) => `${distance.toFixed(1)} 米`);
	 *
	 * @example
	 * // 智能单位转换
	 * measure.setDistanceFormatter((distance) => {
	 *     if (distance < 1000) {
	 *         return `${distance.toFixed(1)} 米`;
	 *     } else {
	 *         return `${(distance / 1000).toFixed(2)} 公里`;
	 *     }
	 * });
	 */
	setDistanceFormatter(formatter: Function): string;
	/**
	 * 设置面积测量值格式化函数
	 *
	 * 自定义面积测量值的显示格式，可以添加单位、设置小数位数等。
	 *
	 * @param {Function} formatter 格式化函数
	 * @param {number} formatter.area 原始面积值（单位：平方米）
	 * @returns {string} 格式化后的面积字符串
	 * @example
	 * // 简单格式化
	 * measure.setAreaFormatter((area) => `${area.toFixed(1)} 平方米`);
	 *
	 * @example
	 * // 智能单位转换
	 * measure.setAreaFormatter((area) => {
	 *     if (area < 10000) {
	 *         return `${area.toFixed(1)} 平方米`;
	 *     } else if (area < 1000000) {
	 *         return `${(area / 10000).toFixed(2)} 公顷`;
	 *     } else {
	 *         return `${(area / 1000000).toFixed(2)} 平方公里`;
	 *     }
	 * });
	 */
	setAreaFormatter(formatter: Function): string;
	/**
	 * 设置点坐标格式化函数
	 *
	 * 自定义点坐标的显示格式，可以设置经纬度的小数位数、添加单位等。
	 *
	 * @param {Function} formatter 格式化函数
	 * @param {Array<number>} formatter.point 坐标点数组 [longitude, latitude]
	 * @param {number} formatter.point.0 经度
	 * @param {number} formatter.point.1 纬度
	 * @returns {string} 格式化后的坐标字符串
	 * @example
	 * // 简单格式化
	 * measure.setPointFormatter((point) => {
	 *     return `经度: ${point[0].toFixed(4)}, 纬度: ${point[1].toFixed(4)}`;
	 * });
	 *
	 * @example
	 * // 更简洁的格式
	 * measure.setPointFormatter((point) => {
	 *     return `${point[0].toFixed(6)}, ${point[1].toFixed(6)}`;
	 * });
	 *
	 * @example
	 * // 带方向的格式
	 * measure.setPointFormatter((point) => {
	 *     return `E: ${point[0].toFixed(4)}°, N: ${point[1].toFixed(4)}°`;
	 * });
	 */
	setPointFormatter(formatter: Function): string;
	/**
	 * 启用测量结果编辑功能
	 *
	 * 允许用户编辑已创建的测量结果，支持通过要素ID或过滤函数指定要编辑的测量要素。与Editor不同的是，测量模式下编辑时不会创建新的测量标签。
	 *
	 * @param {string|function} [featureIdOrFilter] 要素ID或过滤函数，用于指定要编辑的测量要素。
	 *                                        如果不指定，则编辑所有测量要素
	 * @example
	 * // 编辑所有测量结果
	 * measure.enableEdit();
	 *
	 * @example
	 * // 编辑指定ID的测量结果
	 * measure.enableEdit('measurement-123');
	 *
	 * @example
	 * // 编辑距离测量结果
	 * measure.enableEdit((feature) => {
	 *     return feature.properties.measureType === 'distance';
	 * });
	 */
	enableEdit(featureIdOrFilter?: string | Function): void;
}
declare class GeoMesh extends GeoObject {
	/**
	 * @readonly
	 * 类型为Mesh的标识
	 */
	readonly isMesh: true;
}
/**
 * 填充多边形（不含描边），可沿Z轴拉伸高度成多边形柱状体
 *
 * 支持以下功能：
 * - 基础多边形填充渲染
 * - Z轴拉伸创建3D柱状体
 * - 贴地渲染（Ground Primitive）
 * - 纹理贴图支持
 * - 顶点颜色和高度配置
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建基础多边形
 * const polygon = engine.add(new mapvthree.Polygon({
 *     vertexColors: true,
 *     extrude: true,
 *     extrudeValue: 100,
 * }));
 *
 * // 设置数据源
 * let data = mapvthree.GeoJSONDataSource.fromGeoJSON(data);
 * data.defineAttribute('color', 'color');
 * polygon.dataSource = data;
 * ```
 *
 * @example
 * ```javascript
 * // 创建贴地多边形
 * const groundPolygon = engine.add(new mapvthree.Polygon({
 *     isGroundPrimitive: true,
 *     color: 'rgba(255, 0, 0, 0.5)',
 *     opacity: 0.8
 * }));
 * ```
 * ![](media://polygon.png)
 */
export class Polygon extends GeoMesh {
	/**
	 * 创建多边形渲染对象
	 * @param {Object} parameters 传入参数对象
	 * @param {boolean} [parameters.extrude=false] 是否拉伸，默认否
	 * @param {number} [parameters.extrudeValue=100] 拉伸高度，默认100
	 * @param {boolean} [parameters.vertexHeights=false] 是否通过数据携带高度配置，默认否
	 * @param {boolean} [parameters.enableBottomFace=true] 是否封闭底面
	 * @param {string} [parameters.color='#ffffff'] 填充颜色
	 * @param {boolean} [parameters.vertexColors=false] 是否通过数据携带颜色配置，默认否
	 * @param {string} [parameters.emissive='#000000'] 自发光颜色
	 * @param {number} [parameters.opacity=1] 整体透明度系数，默认1
	 * @param {string} [parameters.mapSrc=''] 纹理贴图，默认''
	 * @param {number} [parameters.mapScale=1] 贴图的缩放大小，仅在使用纹理贴图时有效，默认1
	 * @param {number} [parameters.zOffset=0] 整体高度抬升
	 * @param {number} [parameters.normalOffset=0] 沿法线方向抬升
	 * @param {boolean} [parameters.perPositionHeight=true] 使用顶点高度，若不指定，则即使设置了高度也当0处理, 默认为true
	 * @param {boolean} [parameters.isGroundPrimitive=false] 是否为贴地渲染
	 * @param {boolean} [parameters.isDynamic=false] 是否需要动态调整数据源，贴地时使用
	 * @param {Array} [parameters.excludeElements=[]] 排除的元素列表
	 * @param {number} [parameters.renderOrder=0] 渲染顺序
	 * @param {number} [parameters.nearScale=5] 深度图near值缩放系数
	 * @example
	 * ```javascript
	 * const polygon = new mapvthree.Polygon({
	 *     extrude: true,
	 *     extrudeValue: 150,
	 *     color: 'rgba(255, 0, 0, 0.8)',
	 *     vertexColors: true,
	 *     opacity: 0.9
	 * });
	 * ```
	 */
	constructor(parameters?: {
		extrude?: boolean;
		extrudeValue?: number;
		vertexHeights?: boolean;
		enableBottomFace?: boolean;
		color?: string;
		vertexColors?: boolean;
		emissive?: string;
		opacity?: number;
		mapSrc?: string;
		mapScale?: number;
		zOffset?: number;
		normalOffset?: number;
		perPositionHeight?: boolean;
		isGroundPrimitive?: boolean;
		isDynamic?: boolean;
		excludeElements?: any[];
		renderOrder?: number;
		nearScale?: number;
	});
	/**
	 * 是否支持返回的事件参数中携带entity实体数据
	 * @type {boolean}
	 * @readonly
	 */
	readonly isEventEntitySupported: boolean;
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/**
	 * 是否拉伸多边形
	 * @type {boolean}
	 * @example
	 * ```javascript
	 * polygon.extrude = true;
	 * ```
	 */
	extrude: boolean;
	/**
	 * 拉伸高度值
	 * @type {number}
	 * @example
	 * ```javascript
	 * polygon.extrudeValue = 200;
	 * ```
	 */
	extrudeValue: number;
	/**
	 * 填充颜色
	 * @type {string}
	 * @example
	 * ```javascript
	 * polygon.color = 'rgba(255, 0, 0, 0.8)';
	 * ```
	 */
	color: string;
	/**
	 * 是否通过数据携带颜色配置
	 * @type {boolean}
	 * @example
	 * ```javascript
	 * polygon.vertexColors = true;
	 * ```
	 */
	vertexColors: boolean;
	/**
	 * 自发光颜色
	 * @type {string}
	 * @example
	 * ```javascript
	 * polygon.emissive = 'rgba(0, 255, 0, 0.5)';
	 * ```
	 */
	emissive: string;
	/**
	 * 整体透明度系数
	 * @type {number}
	 * @example
	 * ```javascript
	 * polygon.opacity = 0.7;
	 * ```
	 */
	opacity: number;
	/**
	 * 贴图的缩放大小，仅在使用纹理贴图时有效
	 * @type {number}
	 * @example
	 * ```javascript
	 * polygon.mapScale = 2.0;
	 * ```
	 */
	mapScale: number;
	isPolygon: boolean;
	parameters: {
		extrude?: boolean;
		extrudeValue?: number;
		vertexHeights?: boolean;
		enableBottomFace?: boolean;
		color?: string;
		vertexColors?: boolean;
		emissive?: string;
		opacity?: number;
		mapSrc?: string;
		mapScale?: number;
		zOffset?: number;
		normalOffset?: number;
		perPositionHeight?: boolean;
		isGroundPrimitive?: boolean;
		isDynamic?: boolean;
		excludeElements?: any[];
		renderOrder?: number;
		nearScale?: number;
	};
	isGroundPrimitive: boolean;
	isDynamic: boolean;
	needReMapUv: boolean;
	excludeElements: any[];
	depthRenderTarget: any;
	/**
	 * 场景渲染前的钩子函数，用于生成深度图
	 * @param {Engine} engine 引擎实例
	 * @param {Scene} scene 场景对象
	 * @param {Camera} camera 相机对象
	 * @param {Object} renderState 渲染状态
	 * @protected
	 */
	protected onBeforeSceneRenderHook(engine: Engine, scene: Scene, camera: Camera, renderState: any): void;
	getNormal(): Vector3;
	/**
	 * 几何体更新后的处理
	 * @protected
	 */
	protected afterGeometryUpdate(): void;
	/**
	 * 根据面索引和点索引获取实体索引
	 * @param {number} faceIndex 面索引
	 * @param {number} pointIndex 点索引
	 * @returns {number} 实体索引
	 * @protected
	 */
	protected getEntityIndexByFace(faceIndex: number, pointIndex: number): number;
	/**
	 * 设置near缩放值
	 * @param {number} value near缩放值
	 */
	set nearScale(value: number);
	/**
	 * 控制near的值，默认5，在一些对深度要求比较高的场景需要调整near的值
	 * @type {number}
	 * @example
	 * ```javascript
	 * polygon.nearScale = 10; // 提高深度精度
	 * ```
	 */
	get nearScale(): number;
	/**
	 * 设置纹理贴图路径
	 * @param {string} value 纹理贴图路径
	 */
	set mapSrc(value: string);
	/**
	 * 纹理贴图图片路径
	 * @type {string}
	 * @example
	 * ```javascript
	 * polygon.mapSrc = 'textures/ground.jpg';
	 * ```
	 */
	get mapSrc(): string;
	raycast: (raycaster: import("three").Raycaster, intersects: import("three").Intersection[]) => void;
	getVertexPosition: (index: number, target: Vector3) => Vector3;
}
/**
 * 瓦片掩膜，通过Stencil Buffer实现对瓦片图层的区域裁剪渲染。
 * 指定一个GeoJSON多边形区域作为掩膜范围，只显示该区域内的瓦片内容。
 *
 * 支持对{@link MapView}或单个TileProvider进行掩膜，
 * 目标TileProvider需要设置`supportsMask = true`才能被掩膜（如BaiduVectorTileProvider）。
 *
 * 需要通过{@link Engine}的`add`方法添加到场景中才能生效。
 *
 * @category MapView
 * @example
 * ```javascript
 * // 创建掩膜，只显示指定区域的地图内容
 * const geojson = {
 *     type: 'FeatureCollection',
 *     features: [{
 *         type: 'Feature',
 *         geometry: {
 *             type: 'Polygon',
 *             coordinates: [[[116.1, 39.7], [116.7, 39.7], [116.7, 40.1], [116.1, 40.1], [116.1, 39.7]]]
 *         }
 *     }]
 * };
 *
 * const tileMask = engine.add(new mapvthree.TileMask({
 *     targets: [vectorMap],
 *     region: geojson,
 * }));
 *
 * // 动态更新掩膜区域
 * tileMask.region = newGeoJSON;
 *
 * // 临时禁用掩膜
 * tileMask.enabled = false;
 * ```
 */
export class TileMask extends Object3D<import("three").Object3DEventMap> {
	/**
	 * 创建TileMask实例
	 * @param {Object} options - 配置选项
	 * @param {Array<MapView|TileProvider>} options.targets - 要应用掩膜的目标列表,支持MapView或TileProvider
	 * @param {Object|GeoJSONDataSource} options.region - 掩膜区域,GeoJSON格式或GeoJSONDataSource实例
	 */
	constructor(options?: {
		targets: Array<MapView | TileProvider>;
		region: any | GeoJSONDataSource;
	});
	/**
	 * @protected
	 */
	protected afterAddToEngine(engine: any): void;
	/**
	 * @protected
	 */
	protected beforeRemoveFromEngine(): void;
	/**
	 * 添加需要掩膜的3D对象
	 * @param {Object3D} object - 需要掩膜的3D对象
	 */
	addObject(object: Object3D, targetProvider: any): void;
	/**
	 * 移除需要掩膜的3D对象
	 * @param {Object3D} object
	 */
	removeObject(object: Object3D): void;
	/**
	 * 添加需要掩膜的材质
	 * @param {Material|Material[]} material - 需要掩膜的材质
	 */
	addMaterial(material: Material | Material[], targetProvider: any): void;
	/**
	 * 移除需要掩膜的材质
	 * @param {Material} material
	 */
	removeMaterial(material: Material): void;
	/**
	 * 设置掩膜区域
	 * @param {Object|GeoJSONDataSource} region - 新的掩膜区域
	 */
	set region(region: any | GeoJSONDataSource);
	/**
	 * 获取掩膜区域
	 * @returns {GeoJSONDataSource}
	 */
	get region(): GeoJSONDataSource;
	/**
	 * 设置是否启用掩膜
	 * @param {boolean} value
	 */
	set enabled(value: boolean);
	/**
	 * 是否启用掩膜
	 * @returns {boolean}
	 */
	get enabled(): boolean;
	/**
	 * 获取目标providers
	 * @returns {Array<TileProvider>}
	 */
	get targets(): Array<TileProvider>;
	/**
	 * 添加目标,支持MapView或TileProvider
	 * @param {MapView|TileProvider} target
	 */
	addTarget(target: MapView | TileProvider): void;
	/**
	 * 移除目标provider
	 * @param {TileProvider} target
	 */
	removeTarget(target: TileProvider): void;
	/**
	 * 清理资源
	 */
	dispose(): void;
}
/**
 * DOM覆盖物基类，用于在地图上添加HTML元素。支持自定义位置、偏移和拖拽功能。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础DOM覆盖物
 * const overlay = engine.add(new mapvthree.DOMOverlay({
 *     point: [116.404, 39.915, 0],
 *     dom: document.createElement('div'),
 *     offset: [0, 0],
 *     enableDragging: true
 * }));
 *
 * // 创建一个HTML字符串的覆盖物
 * const htmlOverlay = engine.add(new mapvthree.DOMOverlay({
 *     point: [116.404, 39.915, 0],
 *     dom: '<div class="custom-overlay">Hello World</div>'
 * }));
 * ```
 */
export class DOMOverlay extends Object3D<import("three").Object3DEventMap> {
	/**
	 * 创建DOM覆盖物
	 * @param {Object} parameters 配置参数
	 * @param {HTMLElement|string} parameters.dom DOM元素或HTML字符串
	 * @param {Array<number>} [parameters.point] 位置坐标 [经度,纬度,高度]
	 * @param {Array<number>} [parameters.offset=[0,0]] 像素偏移量, 默认值：[0, 0]
	 * @param {boolean} [parameters.visible=true] 是否可见，默认值：true
	 * @param {boolean} [parameters.enableDragging=false] 是否可拖拽，默认值：false
	 * @param {string} [parameters.className] CSS类名
	 */
	constructor(parameters?: {
		dom: HTMLElement | string;
		point?: Array<number>;
		offset?: Array<number>;
		visible?: boolean;
		enableDragging?: boolean;
		className?: string;
	});
	engine: any;
	/**
	 * 设置DOM元素
	 * @param {HTMLElement|string} value DOM元素或HTML字符串
	 * @example
	 * ```javascript
	 * const dom = document.createElement('div');
	 * dom.className = 'custom-overlay';
	 * dom.innerHTML = 'Hello World';
	 * overlay.dom = dom;
	 * ```
	 * @example
	 * ```javascript
	 * const domString = `
	 *     <div class="dom-overlay-custom">
	 *         <div class="overlay-body">
	 *             <div class="overlay-title">Hello World</div>
	 *         </div>
	 *      </div>
	 * `
	 * overlay.dom = domString
	 * ```
	 */
	set dom(value: HTMLElement | string);
	/**
	 * 获取DOM元素
	 * @type {HTMLElement}
	*/
	get dom(): HTMLElement;
	/**
	 * 设置坐标位置
	 * @param {Array<number>|THREE.Vector2|THREE.Vector3} value 坐标位置 [经度, 纬度, 高度] 或 THREE.Vector2/Vector3 对象
	 * @example
	 * ```javascript
	 * // 使用数组
	 * overlay.point = [116.404, 39.915, 0];
	 *
	 * // 使用 THREE.Vector2
	 * overlay.point = new THREE.Vector2(116.404, 39.915);
	 *
	 * // 使用 THREE.Vector3
	 * overlay.point = new THREE.Vector3(116.404, 39.915, 0);
	 * ```
	 */
	set point(value: Array<number> | THREE.Vector2 | THREE.Vector3);
	/**
	 * 坐标位置 [经度, 纬度, 高度]
	 * @type {Array<number>}
	 */
	get point(): Array<number>;
	/**
	 * 设置像素偏移量
	 * @param {Array<number>} value 像素偏移量 [x, y]
	 * @example
	 * ```javascript
	 * overlay.offset = [10, 10];
	 * ```
	 */
	set offset(value: Array<number>);
	/**
	 * 像素偏移量 [x, y]，默认值：[0, 0]
	 * @type {Array<number>}
	 */
	get offset(): Array<number>;
	/**
	 * 设置CSS类名
	 * @param {string} className CSS类名
	 * @example
	 * ```javascript
	 * overlay.className = 'custom-overlay';
	 * ```
	 */
	set className(className: string);
	/**
	 * CSS类名
	 * @type {string}
	 */
	get className(): string;
	/**
	 * 设置是否启用拖拽
	 * @param {boolean} value 是否启用拖拽
	 * @example
	 * ```javascript
	 * overlay.enableDragging = true;
	 * ```
	 */
	set enableDragging(value: boolean);
	/**
	 * 是否启用拖拽，默认值：false
	 * @type {boolean}
	 */
	get enableDragging(): boolean;
	beforeRemoveFromEngine(engine: any): void;
	afterInit(): void;
	onBeforeScenePrepareRender(engine: any, scene: any, camera: any): void;
	camera: any;
	renderer: any;
	onDispose(): void;
	/**
	 * 内存释放
	 */
	dispose(): void;
	/**
	 * 设置是否阻止事件冒泡
	 * @param {boolean} value 是否阻止事件冒泡
	 * @example
	 * ```javascript
	 * overlay.stopPropagation = true;
	 * ```
	 */
	set stopPropagation(value: boolean);
	/**
	 * 是否阻止事件冒泡，默认值：false
	 * @type {boolean}
	 */
	get stopPropagation(): boolean;
	handleMouseDown: (e: any) => void;
	handleMouseUp: (e: any) => void;
	handleMouseMove: (e: any) => void;
	handleWheel: (e: any) => void;
}
/**
 * 信息弹窗覆盖物，用于在地图上显示标题和内容信息。继承自{@link DOMOverlay}。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础信息弹窗
 * const popup = engine.add(new mapvthree.Popup({
 *     point: [116.404, 39.915, 0],
 *     title: '位置信息',
 *     content: '北京市天安门广场',
 *     offset: [0, -20],  // 向上偏移20像素
 * }));
 *
 * // 动态更新内容
 * popup.content = '新的内容';
 * popup.title = '新的标题';
 * ```
 */
export class Popup extends DOMOverlay {
	constructor(parameters: any);
	/**
	 * 设置标题
	 * @param {string|HTMLElement} value 标题，支持HTML字符串或HTMLElement
	 */
	set title(value: string | HTMLElement);
	/**
	 * 获取标题
	 * @returns {string} 标题
	 */
	get title(): string;
	/**
	 * 设置内容
	 * @param {string|HTMLElement} value 内容，支持HTML字符串或HTMLElement
	 */
	set content(value: string | HTMLElement);
	/**
	 * 获取内容
	 * @returns {string} 内容
	 */
	get content(): string;
	click: () => void;
}
/**
 * 图片标注覆盖物，用于在地图上添加图片标记。继承自{@link DOMOverlay}。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个图片标注
 * const marker = engine.add(new mapvthree.Marker({
 *     point: [116.404, 39.915, 0],
 *     icon: 'path/to/icon.png',
 *     width: 32,
 *     height: 32,
 *     offset: [0, -16]  // 将锚点设置到图片底部中心
 * }));
 * ```
 */
export class Marker extends DOMOverlay {
	/**
	 * 创建图片标注
	 * @param {Object} parameters 配置参数
	 * @param {string} [parameters.icon='https://webmap0.bdimg.com/image/api/marker_red.png'] 图标URL
	 * @param {number} [parameters.width=25] 图标宽度, 默认值：25
	 * @param {number} [parameters.height=25] 图标高度, 默认值：25
	 * @param {Array<number>|THREE.Vector2|THREE.Vector3} [parameters.point] 位置坐标 [经度,纬度,高度] 或 THREE.Vector2/Vector3 对象, 默认值：[0,0,0]
	 * @param {Array<number>} [parameters.offset=[0,0]] 像素偏移量, 默认值：[0,0]
	 * @param {boolean} [parameters.enableDragging=false] 是否可拖拽, 默认值：false
	 */
	constructor(parameters?: {
		icon?: string;
		width?: number;
		height?: number;
		point?: Array<number> | THREE.Vector2 | THREE.Vector3;
		offset?: Array<number>;
		enableDragging?: boolean;
	});
	/**
	 * 设置图片路径
	 * @param {string} value 图片路径
	 * @example
	 * ```javascript
	 * marker.icon = 'path/to/icon.png';
	 * ```
	 */
	set icon(value: string);
	/**
	 * 获取图片路径
	 * @returns {string} 图片路径
	 */
	get icon(): string;
	/**
	 * 设置图片宽度
	 * @param {number} value 图片宽度
	 */
	set width(value: number);
	/**
	 * 获取图片宽度
	 * @returns {number} 图片宽度
	 */
	get width(): number;
	/**
	 * 设置图片高度
	 * @param {number} value 图片高度
	 */
	set height(value: number);
	/**
	 * 获取图片高度
	 * @returns {number} 图片高度
	 */
	get height(): number;
	set title(value: any);
	get title(): any;
}
declare class Geocoder_Bd {
	constructor(options?: {});
	options: {};
	getPoint(address: any, callback: any, city: any): Promise<any>;
	getLocation(point: any, callback: any, opts: any): Promise<{
		point: any;
		address: any;
		addressComponents: {};
		surroundingPois: {
			title: any;
			uid: any;
			point: any;
			city: any;
			type: number;
			address: any;
			postcode: any;
			phoneNumber: any;
		}[];
		business: any;
		content: any;
	}>;
}
declare class Geocoder_Tdt {
	constructor(options?: {});
	options: {};
	getPoint(address: any, callback: any, city: any): Promise<Vector3>;
	getLocation(point: any, callback: any): Promise<{
		address: any;
		addressComponents: any;
		point: Vector3;
	}>;
}
declare class Geocoder {
	/**
	 * 创建地理编码服务实例
	 * @param {Object} options 配置参数
	 * @param {string} [options.apiSource] API数据源。
	 * 可以配置为{@link services.API_SOURCE_BAIDU}或{@link services.API_SOURCE_TIANDITU}，默认使用配置的数据源
	 */
	constructor(options?: {
		apiSource?: string;
	});
	options: {
		apiSource?: string;
	};
	apiSource: string;
	/**
	 * 地址转坐标（地理编码）
	 * @param {string} address 地址字符串
	 * @param {Function} callback 回调函数，返回地理编码结果
	 * @param {Object} callback.result 地理编码结果
	 * @param {Array<number>} callback.result.point 坐标点 [lng, lat]
	 * @param {string} callback.result.address 地址信息
	 * @param {string} [city] 城市名称，用于限定搜索范围
	 * @example
	 * ```javascript
	 * geocoder.getPoint('北京市朝阳区', (result) => {
	 *     console.log('坐标:', result.point); // [116.404, 39.915]
	 *     console.log('地址:', result.address);
	 * }, '北京市');
	 * ```
	 */
	getPoint(address: string, callback: Function, city?: string): Promise<any>;
	/**
	 * 坐标转地址（逆地理编码）
	 * @param {Array<number>} point 坐标点 [lng, lat]
	 * @param {Function} callback 回调函数，返回逆地理编码结果
	 * @param {Object} callback.result 逆地理编码结果
	 * @param {string} callback.result.address 地址信息
	 * @param {Array<number>} callback.result.point 坐标点 [lng, lat]
	 * @param {Object} [opts] 额外选项
	 * @example
	 * ```javascript
	 * geocoder.getLocation([116.404, 39.915], (result) => {
	 *     console.log('地址:', result.address);
	 *     console.log('坐标:', result.point);
	 * });
	 * ```
	 */
	getLocation(point: Array<number>, callback: Function, opts?: any): Promise<{
		point: any;
		address: any;
		addressComponents: {};
		surroundingPois: {
			title: any;
			uid: any;
			point: any;
			city: any;
			type: number;
			address: any;
			postcode: any;
			phoneNumber: any;
		}[];
		business: any;
		content: any;
	}> | Promise<{
		address: any;
		addressComponents: any;
		point: import("three").Vector3;
	}>;
}
declare class LocalSearch {
	static DEFAULT_PAGE_CAPACITY: number;
	static MIN_PAGE_CAPACITY: number;
	static MAX_PAGE_CAPACITY: number;
	static DEFAULT_RADIUS: number;
	static MAX_RADIUS: number;
	static DEFAULT_PAGE_NUM: number;
	/**
	 * 创建本地搜索服务实例
	 * @param {Object} options 配置参数
	 * @param {number} [options.pageCapacity=10] 每页结果数，默认10
	 * @param {number} [options.pageNum=0] 页码，默认0
	 * @param {string} [options.apiSource] API数据源。
	 * 可以配置为{@link services.API_SOURCE_BAIDU}或{@link services.API_SOURCE_TIANDITU}，默认使用配置的数据源
	 * @param {Object} [options.renderOptions] 渲染配置
	 * @param {Engine} options.renderOptions.engine 地图引擎实例
	 * @param {boolean} [options.renderOptions.autoViewport=true] 是否自动调整地图视图以包含所有搜索结果
	 * @param {boolean} [options.renderOptions.enableRender=true] 是否启用自动渲染，设为 false 可禁用渲染但保留 engine 用于其他功能
	 */
	constructor(options?: {
		pageCapacity?: number;
		pageNum?: number;
		apiSource?: string;
		renderOptions?: {
			engine: Engine;
			autoViewport?: boolean;
			enableRender?: boolean;
		};
	});
	result: any;
	options: {
		pageCapacity?: number;
		pageNum?: number;
		apiSource?: string;
		renderOptions?: {
			engine: Engine;
			autoViewport?: boolean;
			enableRender?: boolean;
		};
	};
	apiSource: string;
	/**
	 * 搜索POI（兴趣点）
	 * @param {string} keyword 搜索关键词
	 * @param {Object} [opts={}] 搜索选项
	 * @param {number} [opts.pageCapacity] 每页结果数
	 * @param {number} [opts.pageNum] 页码
	 * @returns {Promise<Object>} 搜索结果
	 * @param {Array<Object>} result.pois POI列表
	 * @param {Array<number>} result.pois[].point POI坐标 [lng, lat]
	 * @param {string} result.pois[].title POI标题
	 * @param {string} result.pois[].address POI地址
	 * @example
	 * ```javascript
	 * const result = await localSearch.search('餐厅', {
	 *     pageCapacity: 20,
	 *     pageNum: 0,
	 * });
	 * console.log('找到', result.pois.length, '个餐厅');
	 * ```
	 */
	search(keyword: string, opts?: {
		pageCapacity?: number;
		pageNum?: number;
	}): Promise<any>;
	/**
	 * 范围检索
	 * @param {string|Array<string>} keyword 搜索关键词，支持多关键字
	 * @param {Object} bounds 搜索范围
	 * @param {Array<number>} bounds.sw 西南角坐标 [lng, lat]
	 * @param {Array<number>} bounds.ne 东北角坐标 [lng, lat]
	 * @param {Object} [opts={}] 搜索选项
	 * @returns {Promise<Object>} 搜索结果
	 * @example
	 * ```javascript
	 * const result = await localSearch.searchInBounds('餐厅', {
	 *     sw: [116.274625, 39.961627],
	 *     ne: [116.367474, 39.988609],
	 * });
	 * ```
	 */
	searchInBounds(keyword: string | Array<string>, bounds: {
		sw: Array<number>;
		ne: Array<number>;
	}, opts?: any): Promise<any>;
	/**
	 * 周边检索
	 * @param {string|Array<string>} keyword 搜索关键词，支持多关键字
	 * @param {Array<number>} center 中心点坐标 [lng, lat]
	 * @param {number} radius 检索半径（米）
	 * @param {Object} [opts={}] 搜索选项
	 * @returns {Promise<Object>} 搜索结果
	 * @example
	 * ```javascript
	 * const result = await localSearch.searchNearby('餐厅', [116.404, 39.915], 2000);
	 * ```
	 */
	searchNearby(keyword: string | Array<string>, center: Array<number>, radius: number, opts?: any): Promise<any>;
	/**
	 * 跳转到指定页码
	 * @param {number} pageNum 页码
	 */
	gotoPage(pageNum: number): void;
	/**
	 * 设置在索引为index的标注点处显示弹窗
	 * @param {number} index 索引
	 */
	setPopupByIndex(index: number): void;
	clearMap(): void;
	/**
	 * 设置检索结果每页容量
	 * @param {number} cap 每页容量，支持1-100
	 * @example
	 * ```javascript
	 * localSearch.setPageCapacity(20); // 设置每页显示20个结果
	 * ```
	 */
	setPageCapacity(cap: number): void;
	/**
	 * 获取当前每页容量
	 * @returns {number} 每页容量
	 * @example
	 * ```javascript
	 * const capacity = localSearch.getPageCapacity();
	 * console.log('当前每页容量:', capacity);
	 * ```
	 */
	getPageCapacity(): number;
	/**
	 * 设置页码
	 * @param {number} num 页码，从0开始
	 * @example
	 * ```javascript
	 * localSearch.setPageNum(1); // 设置第2页
	 * ```
	 */
	setPageNum(num: number): void;
	/**
	 * 获取当前页码
	 * @returns {number} 当前页码
	 * @example
	 * ```javascript
	 * const pageNum = localSearch.getPageNum();
	 * console.log('当前页码:', pageNum);
	 * ```
	 */
	getPageNum(): number;
	/**
	 * 获取搜索结果
	 * @returns {Object} 搜索结果
	 */
	getResult(): any;
	clearResult(): void;
}
declare class AutoComplete_Bd extends EventDispatcher<any> {
	constructor(options?: {});
	options: {
		debounceTime: number;
		minKeywordLength: number;
		maxResults: number;
		showSuggestion: boolean;
		containerClassName: string;
		customStyles: {};
	};
	oldValue: string;
	keyValue: string;
	pickValue: string;
	mousedownView: boolean;
	stopCircleTemporary: boolean;
	defaultIptValue: string;
	circleTimer: NodeJS.Timeout;
	requestTimer: number;
	TYPES_COLLECTION: {
		ALL: string;
		CITY: string;
	};
	/**
	 * 初始化组件
	 */
	initialize(): void;
	setPickValue(value: any): void;
	search(word: any): void;
	/**
	 * 获取结果
	 * @public
	 */
	public getResults(): {
		keyword: string;
		total: number;
		pois: any[];
	} | {
		keyword: any;
		total: any;
		pois: any;
	};
	/**
	 * 销毁组件
	 * @public
	 */
	public dispose(): void;
	/**
	 * 设置搜索类型
	 * @param {string|Array} types 搜索类型
	 */
	setTypes(types: string | any[]): void;
}
declare class AutoComplete extends EventDispatcher<any> {
	/**
	 * 创建自动完成服务实例
	 * @param {Object} options 配置参数
	 * @param {string|HTMLElement} options.input 输入框DOM元素或ID
	 * @param {Array<string>} [options.types=[]] 搜索类型，如['ALL', 'CITY']
	 * @param {Array<number>} [options.location] 搜索区域限制 [lng, lat]
	 * @param {number} [options.maxResults=10] 最大结果数量
	 * @param {number} [options.debounceTime=100] 防抖时间(ms)
	 * @param {Function} [options.onSearchComplete] 搜索完成回调
	 * @param {Function} [options.onError] 错误回调
	 * @param {Function} [options.onNeedData] 需要数据回调
	 * @param {string} [options.apiSource] API数据源，目前支持'baidu'
	 */
	constructor(options?: {
		input: string | HTMLElement;
		types?: Array<string>;
		location?: Array<number>;
		maxResults?: number;
		debounceTime?: number;
		onSearchComplete?: Function;
		onError?: Function;
		onNeedData?: Function;
		apiSource?: string;
	});
	options: {
		input: string | HTMLElement;
		types: Array<string>;
		location: Array<number>;
		maxResults: number;
		debounceTime: number;
		onSearchComplete?: Function;
		onError?: Function;
		onNeedData?: Function;
		apiSource: string;
	};
	apiSource: string;
	/**
	 * 初始化组件
	 * @returns {AutoComplete} 当前实例，支持链式调用
	 * @example
	 * ```javascript
	 * autoComplete.initialize();
	 * ```
	 */
	initialize(): AutoComplete;
	setPickValue(value: any): void;
	/**
	 * 执行搜索
	 * @param {string} keyword 搜索关键词
	 * @returns {AutoComplete} 当前实例，支持链式调用
	 * @example
	 * ```javascript
	 * autoComplete.search('北京');
	 * ```
	 */
	search(keyword: string): AutoComplete;
	/**
	 * 设置搜索类型
	 * @param {Array<string>|string} types 搜索类型，如['ALL', 'CITY']或'CITY'
	 * @returns {AutoComplete} 当前实例，支持链式调用
	 * @example
	 * ```javascript
	 * autoComplete.setTypes(['CITY', 'POI']);
	 * // 或者
	 * autoComplete.setTypes('CITY');
	 * ```
	 */
	setTypes(types: Array<string> | string): AutoComplete;
	/**
	 * 获取当前搜索结果
	 * @returns {Object|null} 搜索结果对象
	 * @example
	 * ```javascript
	 * const results = autoComplete.getResults();
	 * if (results) {
	 *     console.log('当前结果:', results);
	 * }
	 * ```
	 */
	getResults(): any | null;
	/**
	 * 销毁组件，释放资源
	 * @example
	 * ```javascript
	 * autoComplete.dispose();
	 * ```
	 */
	dispose(): void;
}
declare class Boundary_Bd {
	constructor(options?: {});
	options: {};
	/**
	 * 检查是否为渤海区域
	 * @param {Object} pt 坐标点
	 * @returns {boolean}
	 */
	/**
	 * 检查是否为澳门区域
	 * @param {Object} pt 坐标点
	 * @returns {boolean}
	 */
	/**
	 * 处理海南地区的特殊逻辑
	 * @param {Object} pt 当前坐标点
	 * @param {Object} nextpt 下一个坐标点
	 * @param {number} j 当前索引
	 * @param {Object} hainanInfo 海南信息对象
	 */
	/**
	 * 处理单个坐标记录
	 * @param {Array} rec 坐标记录
	 * @param {string} name 地区名称
	 * @returns {Array} 处理后的坐标数组
	 */
	/**
	 * 分割海南边界线
	 * @param {Array} coordinates 坐标数组
	 * @param {Object} hainanInfo 海南信息
	 * @returns {Array} 分割后的边界线数组
	 */
	/**
	 * 获取省、直辖市、县的轮廓线坐标
	 * @param {String} name 查询省、直辖市或县的名称
	 * @param {Function} cbk 回调函数，成功返回一个轮廓线的数组（有些地区由多部分构成）,失败数组长度为0
	 *                       数组形式如下：
	 *                       arr[0] = [[x1, y1], [x2, y2], [x3, y3], ...]
	 *                       arr[1] = [[x1, y1], [x2, y2], [x3, y3], ...]
	 *                       ....
	 */
	get(name: string, cbk: Function): void;
	/**
	 * 处理边界响应数据
	 * @param {Object} jsonBoundaries 边界响应数据
	 * @param {string} name 地区名称
	 * @param {Object} results 结果对象
	 */
	toString(): string;
}
declare class Boundary_Tdt {
	constructor(options?: {});
	options: {};
	/**
	 * 解析WKT边界为坐标数组
	 * @param {string} wkt WKT字符串
	 * @returns {Array} 坐标数组
	 */
	/**
	 * 获取行政区划边界
	 * @param {string} name 行政区划名称或adcode
	 * @param {function} cbk 回调函数，返回 {boundaries: [ [ [lng, lat], ... ], ... ]}
	 */
	get(name: string, cbk: Function): void;
	toString(): string;
}
declare class Boundary {
	/**
	 * 创建边界服务实例
	 * @param {Object} options 配置参数
	 * @param {string} [options.apiSource] API数据源。
	 * 可以配置为{@link services.API_SOURCE_BAIDU}或{@link services.API_SOURCE_TIANDITU}，默认使用配置的数据源
	 */
	constructor(options?: {
		apiSource?: string;
	});
	options: {
		apiSource?: string;
	};
	apiSource: string;
	/**
	 * 获取行政区划边界坐标
	 * @param {string} name 行政区划名称，如'山东省'、'北京市'、'台湾省'等
	 * @param {Function} cbk 回调函数，返回边界数据
	 * @param {Object} cbk.result 边界数据结果
	 * @param {Array<Array<Array<number>>>} cbk.result.boundaries 边界坐标数组，每个元素是一个坐标环
	 * @example
	 * ```javascript
	 * boundary.get('山东省', (result) => {
	 *     // result.boundaries 是一个数组，每个元素是一个坐标环
	 *     // 每个坐标环是一个坐标数组，每个坐标是 [lng, lat] 格式
	 *     console.log('边界数量:', result.boundaries.length);
	 *     console.log('第一个边界坐标:', result.boundaries[0]);
	 * });
	 * ```
	 */
	get(name: string, cbk: Function): void;
	/**
	 * 返回服务名称
	 * @returns {string} 服务名称
	 */
	toString(): string;
}
declare class DistrictLayer_Bd {
	constructor(options?: {});
	options: {};
	setOptions(options: any): void;
	setName(name: any): void;
	setKind(kind: any): void;
	/**
	 * 将GeoJSON数据转换为边界数组格式
	 * @param {Object} geojson GeoJSON数据
	 * @returns {Object} 边界数组格式数据 {boundaries: Array}
	 */
	geojson2boundaries(geojson: any): any;
	/**
	 * 搜索行政区划边界数据
	 * @param {Object} options 搜索选项
	 * @param {string} [options.name] 行政区划名称
	 * @param {number} [options.kind] 行政区划层级
	 * @param {Function} callback 回调函数，返回边界数据
	 */
	searchBoundary(options: {
		name?: string;
		kind?: number;
	}, callback: Function): void;
}
declare class DistrictLayer_Tdt {
	constructor(options?: {});
	options: {};
	setOptions(options: any): void;
	setName(name: any): void;
	setKind(kind: any): void;
	/**
	 * 将GeoJSON数据转换为边界数组格式
	 * @param {Object} geojson GeoJSON数据
	 * @returns {Object} 边界数组格式数据 {boundaries: Array}
	 */
	geojson2boundaries(geojson: any): any;
	/**
	 * 搜索行政区划边界数据
	 * @param {Object} options 搜索选项
	 * @param {string} [options.name] 行政区划名称
	 * @param {number} [options.kind] 行政区划层级
	 * @param {Function} callback 回调函数，返回边界数据
	 */
	searchBoundary(options: {
		name?: string;
		kind?: number;
	}, callback: Function): void;
}
declare class DistrictLayer extends EventDispatcher<any> {
	/**
	 * 创建行政区划聚合图层实例
	 * @param {Object} options 配置参数
	 * @param {string} options.name 行政区划名称，格式如'(山东省)'、'(北京市)'
	 * @param {number} options.kind 行政区划层级，0=省级，1=市级，2=区县级
	 * @param {string} [options.apiSource] API数据源。
	 * 可以配置为{@link services.API_SOURCE_BAIDU}或{@link services.API_SOURCE_TIANDITU}，默认使用配置的数据源
	 * @param {Object} [options.renderOptions] 渲染配置
	 * @param {Engine} options.renderOptions.engine 地图引擎实例
	 * @param {boolean} optiosn.renderOptiosn.autoViewport 自动跳转到区域中心
	 * @param {string|Array<string>} [options.renderOptions.fillColor='#ff0'] 填充颜色，支持单个颜色或颜色数组
	 * @param {number} [options.renderOptions.fillOpacity=0.6] 填充透明度，0-1之间
	 * @returns {DistrictLayer_Bd|DistrictLayer_Tdt} 行政区划图层实例
	 */
	constructor(options?: {
		name: string;
		kind: number;
		apiSource?: string;
		renderOptions?: {
			engine: Engine;
		};
	});
	renderOptions: {};
	apiSource: string;
	options: {
		name: string;
		kind: number;
		apiSource?: string;
		renderOptions?: {
			engine: Engine;
		};
	};
	autoViewport: any;
	/**
	 * 重置图层，移除当前渲染的行政区划
	 * @example
	 * ```javascript
	 * district.reset();
	 * ```
	 */
	reset(): void;
	/**
	 * 设置行政区划名称
	 * @param {string} name 行政区划名称，格式如'(山东省)'、'(北京市)'
	 * @example
	 * ```javascript
	 * district.setName('(广东省)');
	 * ```
	 */
	setName(name: string): void;
	/**
	 * 设置行政区划层级
	 * @param {number} kind 行政区划层级，0=省级，1=市级，2=区县级
	 * @example
	 * ```javascript
	 * district.setKind(1); // 设置为市级
	 * ```
	 */
	setKind(kind: number): void;
	/**
	 * 设置行政区划选项，支持同时更新名称和层级
	 * @param {Object} options 配置选项
	 * @param {string} [options.name] 行政区划名称
	 * @param {number} [options.kind] 行政区划层级
	 * @example
	 * ```javascript
	 * district.setOptions({
	 *     name: '(广东省)',
	 *     kind: 1,
	 * });
	 * ```
	 */
	setOptions(options: {
		name?: string;
		kind?: number;
	}): void;
	/**
	 * 搜索行政区划边界数据
	 * @param {Object} options 搜索选项
	 * @param {string} [options.name] 行政区划名称
	 * @param {number} [options.kind] 行政区划层级
	 * @param {Function} callback 回调函数，返回边界数据
	 * @example
	 * ```javascript
	 * district.searchBoundary({
	 *     name: '(山东省)',
	 *     kind: 1,
	 * }, (result) => {
	 *     console.log('边界数据:', result.boundaries);
	 * });
	 * ```
	 */
	searchBoundary(options: {
		name?: string;
		kind?: number;
	}, callback: Function): void;
}
declare class BaseRoute {
	/**
	 * 创建路线规划服务基类实例
	 * @param {object} options 配置选项
	 * @param {object} [options.renderOptions] 渲染选项
	 * @param {Engine} [options.renderOptions.engine] 渲染引擎实例
	 * @param {boolean} [options.renderOptions.autoViewport] 是否自动调整视野
	 * @param {string|HTMLElement} [options.renderOptions.panel] Panel 容器，可以是 DOM 元素或元素 ID
	 * @param {Function} [options.onSearchComplete] 搜索完成回调
	 * @param {Function} [options.onMarkersSet] 标记点设置完成回调
	 * @param {Function} [options.onPolylinesSet] 路线设置完成回调
	 * @param {Function} [options.onResultsHtmlSet] 结果面板渲染完成回调
	 */
	constructor(options?: {
		renderOptions?: {
			engine?: Engine;
			autoViewport?: boolean;
			panel?: string | HTMLElement;
		};
		onSearchComplete?: Function;
		onMarkersSet?: Function;
		onPolylinesSet?: Function;
		onResultsHtmlSet?: Function;
	});
	/**
	 * 路线搜索结果
	 * @type {Object|null}
	 */
	result: any | null;
	options: {
		renderOptions?: {
			engine?: Engine;
			autoViewport?: boolean;
			panel?: string | HTMLElement;
		};
		onSearchComplete?: Function;
		onMarkersSet?: Function;
		onPolylinesSet?: Function;
		onResultsHtmlSet?: Function;
	};
	/**
	 * 搜索路线
	 * 根据起点和终点计算最优路线
	 * @param {Array<number>|THREE.Vector3|THREE.Vector2} start 起点坐标 [lng, lat]
	 * @param {Array<number>|THREE.Vector3|THREE.Vector2} end 终点坐标 [lng, lat]
	 * @param {object} [opts] 搜索选项
	 * @param {Array<Array<number>|THREE.Vector3|THREE.Vector2>} [opts.waypoints] 途经点坐标数组，只有{@link DrivingRoute}支持途经点
	 * @returns {Promise<Object>} 路线搜索结果
	 * @example
	 * ```javascript
	 * const result = await route.search(
	 *     new THREE.Vector3(116.404, 39.915, 0), // 起点
	 *     new THREE.Vector3(116.414, 39.925, 0), // 终点
	 *     {
	 *         waypoints: [new THREE.Vector3(116.409, 39.920, 0)] // 途经点
	 *     }
	 * );
	 * console.log('路线距离:', result.distance);
	 * console.log('预计时间:', result.duration);
	 * ```
	 */
	search(start: Array<number> | THREE.Vector3 | THREE.Vector2, end: Array<number> | THREE.Vector3 | THREE.Vector2, opts?: {
		waypoints?: Array<Array<number> | THREE.Vector3 | THREE.Vector2>;
	}): Promise<any>;
	/**
	 * 获取路线搜索结果
	 * @returns {Object|null} 路线搜索结果
	 */
	getResult(): any | null;
	/**
	 * 清除路线搜索结果和地图覆盖物
	 */
	clearResults(): void;
	/**
	 * 在 Panel 容器中渲染路线详情（与 jsapi-webgl-1-0 一致的 DOM 结构和样式）
	 * @param {Object} result 路线搜索结果
	 */
	renderPanel(result: any): void;
	/**
	 * 获取路线类型名称，子类可重写
	 * @returns {string}
	 * @protected
	 */
}
declare class DrivingRoute extends BaseRoute {
	/**
	 * 创建驾车路线规划服务实例
	 * @param {object} options 配置选项
	 * @param {string} [options.apiSource] API数据源。
	 * 可以配置为{@link services.API_SOURCE_BAIDU}或{@link services.API_SOURCE_TIANDITU}，默认使用配置的数据源
	 * @param {object} [options.renderOptions] 渲染选项
	 * @param {Engine} [options.renderOptions.engine] 渲染引擎实例
	 * @param {boolean} [options.renderOptions.autoViewport] 是否自动调整视野
	 * @example
	 * ```javascript
	 * const drivingRoute = new DrivingRoute({
	 *     renderOptions: {
	 *         engine: engine,
	 *         autoViewport: true
	 *     }
	 * });
	 * ```
	 */
	constructor(options?: {
		apiSource?: string;
		renderOptions?: {
			engine?: Engine;
			autoViewport?: boolean;
		};
	});
	/**
	 * 查询类型：驾车路线规划
	 * @type {string}
	 * @readonly
	 */
	readonly QUERY_TYPE: string;
	/**
	 * 返回类型：驾车路线规划结果
	 * @type {number}
	 * @readonly
	 */
	readonly RETURN_TYPE: number;
	/**
	 * 路线类型：驾车路线
	 * @type {number}
	 * @readonly
	 */
	readonly ROUTE_TYPE: number;
	/**
	 * 服务名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
}
declare class RidingRoute extends BaseRoute {
	/**
	 * 创建骑行路线规划服务实例
	 * @param {object} options 配置选项
	 * @param {object} [options.renderOptions] 渲染选项
	 * @param {Engine} [options.renderOptions.engine] 渲染引擎实例
	 * @param {boolean} [options.renderOptions.autoViewport] 是否自动调整视野
	 * @example
	 * ```javascript
	 * const ridingRoute = new RidingRoute({
	 *     renderOptions: {
	 *         engine: engine,
	 *         autoViewport: true
	 *     }
	 * });
	 * ```
	 */
	constructor(options?: {
		renderOptions?: {
			engine?: Engine;
			autoViewport?: boolean;
		};
	});
	/**
	 * 查询类型：骑行路线规划
	 * @type {string}
	 * @readonly
	 */
	readonly QUERY_TYPE: string;
	/**
	 * 路线类型：骑行路线
	 * @type {number}
	 * @readonly
	 */
	readonly ROUTE_TYPE: number;
	/**
	 * 服务名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
}
declare class TransitRoute extends BaseRoute {
	/**
	 * 创建公交路线规划服务实例
	 * @param {object} options 配置选项
	 * @param {string} [options.apiSource] API数据源。
	 * 可以配置为{@link services.API_SOURCE_BAIDU}或{@link services.API_SOURCE_TIANDITU}，默认使用配置的数据源
	 * @param {object} [options.renderOptions] 渲染选项
	 * @param {Engine} [options.renderOptions.engine] 渲染引擎实例
	 * @param {boolean} [options.renderOptions.autoViewport] 是否自动调整视野
	 * @example
	 * ```javascript
	 * const transitRoute = new TransitRoute({
	 *     apiSource: mapvthree.services.API_SOURCE_BAIDU,
	 *     renderOptions: {
	 *         engine: engine,
	 *         autoViewport: true
	 *     }
	 * });
	 * ```
	 */
	constructor(options?: {
		apiSource?: string;
		renderOptions?: {
			engine?: Engine;
			autoViewport?: boolean;
		};
	});
	/**
	 * 查询类型：公交路线规划
	 * @type {string}
	 * @readonly
	 */
	readonly QUERY_TYPE: string;
	/**
	 * 返回类型：公交路线规划结果
	 * @type {number}
	 * @readonly
	 */
	readonly RETURN_TYPE: number;
	/**
	 * 路线类型：公交路线
	 * @type {number}
	 * @readonly
	 */
	readonly ROUTE_TYPE: number;
	/**
	 * 服务名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
	renderMkr(result: any): void;
}
declare class WalkingRoute extends BaseRoute {
	/**
	 * 创建步行路线规划服务实例
	 * @param {object} options 配置选项
	 * @param {object} [options.renderOptions] 渲染选项
	 * @param {Engine} [options.renderOptions.engine] 渲染引擎实例
	 * @param {boolean} [options.renderOptions.autoViewport] 是否自动调整视野
	 * @example
	 * ```javascript
	 * const walkingRoute = new WalkingRoute({
	 *     renderOptions: {
	 *         engine: engine,
	 *         autoViewport: true
	 *     }
	 * });
	 * ```
	 */
	constructor(options?: {
		renderOptions?: {
			engine?: Engine;
			autoViewport?: boolean;
		};
	});
	/**
	 * 查询类型：步行路线规划
	 * @type {string}
	 * @readonly
	 */
	readonly QUERY_TYPE: string;
	/**
	 * 返回类型：步行路线规划结果
	 * @type {number}
	 * @readonly
	 */
	readonly RETURN_TYPE: number;
	/**
	 * 路线类型：步行路线
	 * @type {number}
	 * @readonly
	 */
	readonly ROUTE_TYPE: number;
	/**
	 * 服务名称
	 * @type {string}
	 * @readonly
	 */
	readonly name: string;
}
declare const API_SOURCE_BAIDU: "baidu";
declare const API_SOURCE_TIANDITU: "tdt";
declare function setApiSource(source: string): void;
declare function getApiSource(): string;
declare class DynamicInstancedMesh extends Object3D<import("three").Object3DEventMap> {
	constructor(meshes: any);
	/**
	 * 是否支持返回的事件参数中携带entity实体数据
	 */
	isEventEntitySupported: boolean;
	afterAddToEngine(engine: any): void;
	engine: any;
	set isGlobe(value: boolean);
	get isGlobe(): boolean;
	beforeRemoveFromEngine(engine: any): void;
	updateRenderingMesh: () => void;
	/** @protected */
	protected getEntityByIndex(index: any): {
		id: any;
		index: any;
	};
	has(id: any): boolean;
	resetBufferAttribute(size: any): void;
	clear(): void;
	/**
	 *
	 * @param {*} data
	 * .instanceMatrix
	 * .translation, .scale, .rotation
	 * .id 必须要有，这是增删数据的唯一主键
	 * @param {*} level
	 */
	setBufferData(bufferData: any): void;
	setColor(id: any, color: any): void;
	expandInstanceArray: (count: any, dataExtend?: boolean) => void;
	/**
	 * 添加数据
	 * @param {*} bufferData
	 */
	addInstances(bufferData: any): void;
	computeTempMatrix(bufferData: any, startNum: any, count: any): any;
	copyArrayData: (target: any, targetOffset: any, source: any, sourceOffset: any, length: any) => void;
	removeInstance(id: any): void;
	removeInstances(bufferData: any): void;
	update(): void;
	set meshes(value: any[]);
	get meshes(): any[];
	/**
	 * 更新所有的几何，根据相机位置计算缩放比例
	 * @param {Number} projectionRadius projected radius
	 * @param {Vector3} cameraPosition camera position
	 */
	dispose(): void;
	raycast(raycaster: any, intersects: any): void;
	set needsUpdate(value: any);
	set enableColor(value: boolean);
	get enableColor(): boolean;
	set enableColorList(value: any);
	set keepSize(value: boolean);
	get keepSize(): boolean;
}
declare class DataProvider {
	provide(data: any): any;
	process(name: any, callback: any): this;
}
/**
 * 车辆数字孪生，用于在3D地图上实时渲染和管理大量移动车辆模型。
 * 通过定时推送位置数据驱动车辆平滑移动，支持多种内置车辆模型（写实风格和极简风格），
 * 并提供车辆追踪、颜色设置、可见性控制等交互能力。
 *
 * 需要通过{@link Engine}的`add`方法添加到场景中才能生效。
 *
 * 推送数据默认需要包含id、lng、lat、time字段，如果原始数据字段名不同，
 * 可通过{@link Twin#dataProvider|dataProvider}自定义映射。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建Twin实例并配置模型
 * const twin = engine.add(new mapvthree.Twin({
 *     modelConfig: {
 *         3: mapvthree.twinConstants.REALISTIC_TEMPLATE_MODEL.CAR,
 *         6: mapvthree.twinConstants.REALISTIC_TEMPLATE_MODEL.BUS,
 *         10: mapvthree.twinConstants.REALISTIC_TEMPLATE_MODEL.MAN,
 *     },
 *     delay: 2000,
 * }));
 *
 * // 定时推送车辆数据
 * setInterval(() => {
 *     twin.push([
 *         { id: 'car_1', lng: 116.39, lat: 39.9, dir: 90, time: Date.now(), modelType: 3 },
 *         { id: 'car_2', lng: 116.40, lat: 39.91, dir: 180, time: Date.now(), modelType: 6 },
 *     ]);
 * }, 2000);
 *
 * // 追踪某辆车
 * twin.trackById('car_1', { radius: 200, pitch: 1.0 });
 *
 * // 设置车辆颜色
 * twin.setColorById('car_1', '#ff0000');
 *
 * // 监听点击事件
 * twin.addEventListener('click', (e) => {
 *     console.log('点击的车辆:', e.clickInfo);
 * });
 * ```
 */
export class Twin extends Object3D<import("three").Object3DEventMap> {
	/**
	 * 写实风格的配色，详见 {@link twinConstants.REALISTIC_TEMPLATE_COLOR}
	 */
	static REALISTIC_TEMPLATE_COLOR: {
		white: string;
		black: string;
		gray: string;
		blue: string;
		red: string;
		green: string;
		brown: string;
		yellow: string;
		orange: string;
		purple: string;
		cyanl: string;
		pink: string;
	};
	/**
	 * 写实风格模型，详见 {@link twinConstants.REALISTIC_TEMPLATE_MODEL}
	 */
	static REALISTIC_TEMPLATE_MODEL: {
		MAN: string;
		WOMAN: string;
		BICYCLE: string;
		TRICYCLE: string;
		MOTORCYCLE: string;
		ELECTRICBICYCLE: string;
		CAR: string;
		BUS: string;
		SUV: string;
		MPV: string;
		TAXI: string;
		TOUR: string;
		TRUCK: string;
		AMBULANCE: string;
		BIGTRUCK: string;
		DANGEROUS: string;
		FIRETRUCK: string;
		LARGETRUCK: string;
		MINIBUS: string;
		POLICECAR: string;
		SMALLBUS: string;
		SMALLTRUCK: string;
		WATERCAR: string;
		TRAFFICCONE: string;
	};
	/**
	 * 极简风格模型，详见 {@link twinConstants.MINIMALIST_TEMPLATE_MODEL}
	 */
	static MINIMALIST_TEMPLATE_MODEL: {
		MAN: string;
		WOMAN: string;
		BICYCLE: string;
		TRICYCLE: string;
		MOTORCYCLE: string;
		ELECTRICBICYCLE: string;
		CAR: string;
		BUS: string;
		SUV: string;
		MPV: string;
		TAXI: string;
		TOUR: string;
		TRUCK: string;
		AMBULANCE: string;
		BIGTRUCK: string;
		DANGEROUS: string;
		FIRETRUCK: string;
		LARGETRUCK: string;
		MINIBUS: string;
		POLICECAR: string;
		SMALLBUS: string;
		SMALLTRUCK: string;
		WATERCAR: string;
		TRAFFICCONE: string;
		MAN_ANIMATE: string;
		WOMAN_ANIMATE: string;
		BICYCLE_ANIMATE: string;
	};
	/**
	 * 默认type字段的对应模型，详见 {@link twinConstants.SERVICE_TEMPLATE_MODEL}
	 */
	static SERVICE_TEMPLATE_MODEL: {
		3: string;
		4: string;
		5: string;
		6: string;
		7: string;
		8: string;
		9: string;
		10: string;
		11: string;
		12: string;
		13: string;
		14: string;
		15: string;
		17: string;
		18: string;
		19: string;
		20: string;
		21: string;
		22: string;
		23: string;
		24: string;
		25: string;
		26: string;
		27: string;
	};
	/**
	 * 构造函数，用于创建Twin
	 * @param {Object} options 配置选项
	 * @param {{ [modelType: number]: string }} [options.modelConfig] - 模型配置，key为modelType，value为模型地址
	 * @param {number} [options.delay=2000] - 数据刷新的时间间隔，默认为2000毫秒
	 * @param {{ [key: string]: string }} [options.objectAttributes] - 附加物体所需数据，对应key值
	 * @param {Array<Object3D>} [options.objects] - 车辆额外伴随物体
	 * @param {number} [options.extraDir=0] - 模型额外旋转角度
	 * @param {boolean} [options.keepSize] - 模型是否保持大小不变
	 * @param {number} [options.maxScale=20] - 模型最大缩放倍数
	 * @param {Array<string>} [options.enableColorList=['body']] - 允许修改颜色的模型子网格名称列表
	 * @param {boolean} [options.autoClearTrack=true] - 追踪目标消失时是否自动清除追踪
	 */
	constructor(options?: {
		modelConfig?: {
			[modelType: number]: string;
		};
		delay?: number;
		objectAttributes?: {
			[key: string]: string;
		};
		objects?: Array<Object3D>;
		extraDir?: number;
		keepSize?: boolean;
		maxScale?: number;
		enableColorList?: Array<string>;
		autoClearTrack?: boolean;
	});
	/**
	 * @protected
	 */
	protected afterAddToEngine(engine: any): void;
	onBeforeScenePrepareRender(engine: any, scene: any, camera: any, renderState: any): void;
	/**
	 * 推送车辆数据
	 * @param {Array<Object>} data 车辆数据数组，每个元素需包含id、lng、lat、time数据，dir和modelType可选
	 * @example
	 * ```javascript
	 * twin.push([
	 *     { id: 'car_1', lng: 116.39, lat: 39.9, dir: 90, time: Date.now(), modelType: 3 },
	 * ]);
	 * ```
	 */
	push(data: Array<any>): void;
	/**
	 * 暂停播放
	 */
	pause(): void;
	/**
	 * 恢复播放
	 */
	start(): void;
	/**
	 * 重置状态
	 */
	reset(): void;
	/**
	 * 设置车辆颜色
	 * @param {string|number} id 车辆ID
	 * @param {string|number} color 色值
	 */
	setColorById(id: string | number, color: string | number): void;
	/**
	 * @protected
	 */
	/**
	 * 追踪车辆
	 * @param {string|number} id 车辆ID
	 * @param {Object} option 配置
	 * @param {number} option.radius 距离
	 * @param {number} option.pitch 俯仰角
	 * @param {number} option.height 高度
	 * @param {boolean} option.inside 是否车内视角
	 * @returns {boolean} 当前帧是否存在该车辆
	 */
	trackById(id: string | number, option?: {
		radius: number;
		pitch: number;
		height: number;
		inside: boolean;
	}): boolean;
	/**
	 * 清除通过 trackById 设置的追踪
	 */
	clearTrack(): void;
	/**
	 * 销毁实例，释放资源
	 */
	dispose(): void;
	/**
	 * 获取模型实例
	 * @param {number} modelType 模型类型
	 * @returns {DynamicInstancedMesh}
	 */
	getModelInstance(modelType: number): DynamicInstancedMesh;
	/**
	 * 根据模型类型设置可见性
	 *
	 * @param {number} modelType 模型类型
	 * @param {boolean} status 可见性状态
	 */
	setVisibleByType(modelType: number, status: boolean): void;
	/**
	 * 设置所有附加物可见性
	 *
	 * @param {boolean} status 可见性状态
	 */
	setObjectVisible(status: boolean): void;
	/**
	 * 根据模型类型设置附加物可见性
	 *
	 * @param {number} modelType 模型类型
	 * @param {boolean} status 可见性状态
	 */
	setObjectVisibleByType(modelType: number, status: boolean): void;
	/**
	 * 数据处理器，用于自定义推送数据的字段映射，将原始数据转换为Twin所需的标准格式
	 * @type {DataProvider}
	 * @readonly
	 * @example
	 * ```javascript
	 * twin.dataProvider
	 *     .process('time', 'timestamp')
	 *     .process('point', item => [item.longitude, item.latitude, item.altitude])
	 *     .process('dir', item => item.heading / 180 * Math.PI)
	 *     .process('modelType', 'vehicleType');
	 * ```
	 */
	readonly get dataProvider(): DataProvider;
	/**
	 * 所有模型实例的映射，key为modelType
	 * @type {Object<number, DynamicInstancedMesh>}
	 * @readonly
	 */
	readonly get models(): {
		[x: number]: DynamicInstancedMesh;
	};
}
/**
 * 基于路径线数据模拟车辆孪生，在给定线段上按间隔和速度自动生成并驱动车辆沿路径移动。
 * 内部使用 {@link Twin} 渲染车辆，通过路径插值计算每辆车的位置并定时 push 到 Twin，
 * 适用于演示、测试或无需真实轨迹数据时的车辆流效果。
 *
 * 需要通过 {@link Engine} 的 `add` 方法添加到场景中，再调用 {@link MockTwin#start|start} 开始模拟。
 *
 * @category Objects
 * @example
 * ```javascript
 * const mockTwin = engine.add(new mapvthree.MockTwin(
 *     { modelConfig: { 3: mapvthree.twinConstants.REALISTIC_TEMPLATE_MODEL.CAR } },
 *     [[116.39, 39.9], [116.40, 39.91], [116.41, 39.92]],
 *     { color: { red: 0.3, blue: 0.7 }, modelType: { 3: 0.5, 6: 0.5 } }
 * ));
 * mockTwin.start({ speed: 60, gap: 20, initialCount: 5 });
 * ```
 */
export class MockTwin extends Object3D<import("three").Object3DEventMap> {
	/**
	 * 构造函数，用于创建 MockTwin
	 *
	 * @param {Object} [twinConfig={}] - 孪生配置，与 {@link Twin} 的 options 一致，如 modelConfig、delay 等
	 * @param {GeoJSON.LineString|Array<Array<number>>} [data] - 路径数据：GeoJSON 线或 [[lng, lat], ...] 点数组
	 * @param {Object} [probabilityConfig={}] - 概率配置，用于随机颜色和模型类型
	 */
	constructor(twinConfig?: any, data?: GeoJSON.LineString | Array<Array<number>>, probabilityConfig?: any);
	/**
	 * 每帧渲染前根据 visibleCallback 同步内部 Twin 的可见性
	 * @protected
	 */
	protected onBeforeSceneRender(): void;
	/**
	 * 将准备渲染前的逻辑转发给内部 Twin
	 * @protected
	 * @param {Engine} engine - 地图引擎
	 * @param {Scene} scene - 场景
	 * @param {Camera} camera - 相机
	 * @param {Object} renderState - 渲染状态
	 */
	protected onBeforeScenePrepareRender(engine: Engine, scene: Scene, camera: Camera, renderState: any): void;
	/**
	 * 开始沿路径模拟车辆：按间隔在路径上生成车辆，并按速度沿路径移动并推送给内部 Twin
	 * @param {Object} [options={}] - 启动选项
	 * @param {number} [options.speed] - 车辆速度（km/h），不传则使用默认速度80km/h
	 * @param {number} [options.gap] - 路径上相邻车辆间距（米），不传则使用默认间距10米
	 * @param {number} [options.initialCount=0] - 启动时在路径上预先放置的车辆数量
	 */
	start(options?: {
		speed?: number;
		gap?: number;
		initialCount?: number;
	}): void;
	/**
	 * 停止模拟并清空所有车辆，清除定时器，内部 Twin 状态重置
	 */
	clear(): void;
	/**
	 * 用于每帧决定内部 Twin 是否可见，可被子类覆盖；默认返回当前 Twin 的 visible
	 * @returns {boolean} 是否显示车辆孪生
	 */
	visibleCallback(): boolean;
	/**
	 * 销毁实例：先 clear 再释放内部 Twin 并移出场景
	 */
	dispose(): void;
	/** @param {GeoJSON.LineString|Array<Array<number>>|null} value */
	set data(value: GeoJSON.LineString | Array<Array<number>> | null);
	/**
	 * 路径数据：GeoJSON 线或 [[lng, lat], ...] 点数组
	 * @type {GeoJSON.LineString|Array<Array<number>>|null}
	 */
	get data(): GeoJSON.LineString | Array<Array<number>> | null;
	/** @param {number} value */
	set speed(value: number);
	/**
	 * 车辆沿路径移动速度，单位 km/h
	 * @type {number}
	 */
	get speed(): number;
	/** @param {number} value */
	set gap(value: number);
	/**
	 * 路径上相邻车辆间距，单位米
	 * @type {number}
	 */
	get gap(): number;
	/** @param {Object} value */
	set probabilityConfig(value: any);
	/**
	 * 随机概率配置，用于 start 时随机颜色和模型类型。格式如 `{ color: { red: 0.3 }, modelType: { 3: 0.5, 6: 0.5 } }`
	 * @type {Object}
	 */
	get probabilityConfig(): any;
}
declare namespace REALISTIC_TEMPLATE_COLOR {
	let white: string;
	let black: string;
	let gray: string;
	let blue: string;
	let red: string;
	let green: string;
	let brown: string;
	let yellow: string;
	let orange: string;
	let purple: string;
	let cyanl: string;
	let pink: string;
}
declare namespace REALISTIC_TEMPLATE_MODEL {
	let MAN: string;
	let WOMAN: string;
	let BICYCLE: string;
	let TRICYCLE: string;
	let MOTORCYCLE: string;
	let ELECTRICBICYCLE: string;
	let CAR: string;
	let BUS: string;
	let SUV: string;
	let MPV: string;
	let TAXI: string;
	let TOUR: string;
	let TRUCK: string;
	let AMBULANCE: string;
	let BIGTRUCK: string;
	let DANGEROUS: string;
	let FIRETRUCK: string;
	let LARGETRUCK: string;
	let MINIBUS: string;
	let POLICECAR: string;
	let SMALLBUS: string;
	let SMALLTRUCK: string;
	let WATERCAR: string;
	let TRAFFICCONE: string;
}
declare namespace MINIMALIST_TEMPLATE_MODEL {
	let MAN_1: string;
	export { MAN_1 as MAN };
	let WOMAN_1: string;
	export { WOMAN_1 as WOMAN };
	let BICYCLE_1: string;
	export { BICYCLE_1 as BICYCLE };
	let TRICYCLE_1: string;
	export { TRICYCLE_1 as TRICYCLE };
	let MOTORCYCLE_1: string;
	export { MOTORCYCLE_1 as MOTORCYCLE };
	let ELECTRICBICYCLE_1: string;
	export { ELECTRICBICYCLE_1 as ELECTRICBICYCLE };
	let CAR_1: string;
	export { CAR_1 as CAR };
	let BUS_1: string;
	export { BUS_1 as BUS };
	let SUV_1: string;
	export { SUV_1 as SUV };
	let MPV_1: string;
	export { MPV_1 as MPV };
	let TAXI_1: string;
	export { TAXI_1 as TAXI };
	let TOUR_1: string;
	export { TOUR_1 as TOUR };
	let TRUCK_1: string;
	export { TRUCK_1 as TRUCK };
	let AMBULANCE_1: string;
	export { AMBULANCE_1 as AMBULANCE };
	let BIGTRUCK_1: string;
	export { BIGTRUCK_1 as BIGTRUCK };
	let DANGEROUS_1: string;
	export { DANGEROUS_1 as DANGEROUS };
	let FIRETRUCK_1: string;
	export { FIRETRUCK_1 as FIRETRUCK };
	let LARGETRUCK_1: string;
	export { LARGETRUCK_1 as LARGETRUCK };
	let MINIBUS_1: string;
	export { MINIBUS_1 as MINIBUS };
	let POLICECAR_1: string;
	export { POLICECAR_1 as POLICECAR };
	let SMALLBUS_1: string;
	export { SMALLBUS_1 as SMALLBUS };
	let SMALLTRUCK_1: string;
	export { SMALLTRUCK_1 as SMALLTRUCK };
	let WATERCAR_1: string;
	export { WATERCAR_1 as WATERCAR };
	let TRAFFICCONE_1: string;
	export { TRAFFICCONE_1 as TRAFFICCONE };
	export let MAN_ANIMATE: string;
	export let WOMAN_ANIMATE: string;
	export let BICYCLE_ANIMATE: string;
}
declare const SERVICE_TEMPLATE_MODEL: {
	3: string;
	4: string;
	5: string;
	6: string;
	7: string;
	8: string;
	9: string;
	10: string;
	11: string;
	12: string;
	13: string;
	14: string;
	15: string;
	17: string;
	18: string;
	19: string;
	20: string;
	21: string;
	22: string;
	23: string;
	24: string;
	25: string;
	26: string;
	27: string;
};
export class GroundObject {
	/**
	 * @param {{color?: string, minHeight?: number, maxHeight?: number, nearScale?: number
	 * type: string, opacity?: number,
	 * }} parameter 参数对象
	 * @param {string} parameter.type 类型, 可选值: Polygon, Line
	 * @param {number} parameter.minHeight 最小高度, 默认 -1000，只贴在minHeight到maxHeight之间的对象
	 * @param {number} parameter.maxHeight 最大高度, 默认 1000，只贴在minHeight到maxHeight之间的对象
	 * @param {number} parameter.nearScale 近平面缩放, 默认 1
	 * @param {string} parameter.color 颜色
	 * @param {number} parameter.opacity 不透明度
	 * @param {*} engine
	 */
	constructor(parameter: {
		color?: string;
		minHeight?: number;
		maxHeight?: number;
		nearScale?: number;
		type: string;
		opacity?: number;
	}, engine: any);
	initPolygonObject(): void;
	frontObject: Polygon;
	backObject: Polygon;
	renderObject: any;
	initLineObject(): void;
	set dataSource(value: any);
	get dataSource(): any;
	set renderOrder(value: number);
	get renderOrder(): number;
	addEventListener(type: any, callback: any): void;
	removeEventListener(type: any, callback: any): void;
	destroy(): void;
}
/**
 * GeoInstancedMesh可以用来渲染大量具有相同几何体与材质、但具有不同世界变化的物体，
 * 它能够帮你减少draw call的数量，提升应用程序的整体性能
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个实例化格网
 * const instancedMesh = engine.add(new mapvthree.GeoInstancedMesh(geometry, material));
 * // 传入数据源
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON(randomPoints(center, 0.05, 1000));
 * instancedMesh.dataSource = data;
 * ```
 */
export class GeoInstancedMesh extends GeoObject {
	/**
	 * 实例化网格构造函数
	 * @param {BufferGeometry} geometry 一个BufferGeometry实例
	 * @param {Material} material 一个Material实例
	 */
	constructor(geometry: BufferGeometry, material: Material, parameters: any);
	/** @protected */ protected type: string;
	/** @protected */ protected isMesh: boolean;
	/** @protected */ protected isInstancedMesh: boolean;
	/** @protected */ protected instanceColor: any;
	/** @protected */ protected count: number;
	/** @protected */ protected instanceMatrix: InstancedBufferAttribute;
	/**
	 * 是否支持返回的事件参数中携带entity实体数据
	 */
	isEventEntitySupported: boolean;
	boundingBox: any;
	boundingSphere: any;
	geometry: BufferGeometry;
	material: Material;
	set enableInstanceColor(value: boolean);
	get enableInstanceColor(): boolean;
	getEcefTransformMatrix: (coordinate: any, feature: any, index: any) => Matrix4;
	collisionTest(data: any): {
		width: any;
		height: any;
	};
	originCenter: Vector3;
	computeTempMatrix(bufferData: any): void;
	/**
	 * @protected
	 * 通过index获取该index对应数据源的实体信息
	 * @param {number} index
	 * @returns
	 */
	protected getEntityByIndex(index: number): {
		index: number;
		value: any;
		itemIndex: any;
		pairs: {};
	};
	getPixelSize(position: any): any;
}
declare class GeoPoints extends GeoObject {
	/**
	 * @readonly
	 * 类型为Points的标识
	 */
	readonly isPoints: true;
	/** @protected */
	protected isEventEntitySupported: boolean;
	/**
	 * 设置object尺寸
	 * @param {number} value 尺寸值
	 */
	set size(value: number);
	/**
	 * object尺寸
	 */
	get size(): number;
	/** @protected */
	protected getEntityByIndex(index: any): {
		value: any;
		itemIndex: any;
		pairs: {};
	};
}
/**
 * 点对象，用于在地图上绘制基础的点标记。支持自定义颜色、大小等特性。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础点对象
 * const point = engine.add(new mapvthree.SimplePoint({
 *     color: 'rgba(250, 90, 50, 1)',
 *     size: 50,
 *     opacity: 0.8,
 *     vertexColors: true,
 *     vertexSizes: true,
 * }));
 *
 * // 设置数据源
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([{
 *     type: 'Feature',
 *     geometry: {
 *         type: 'Point',
 *         coordinates: [116.404, 39.915]
 *     },
 *     properties: {
 *         color: '#ff0000',
 *         size: 30
 *     }
 * }]);
 *
 * // 定义color和size属性映射
 * data.defineAttribute('color', 'color');
 * data.defineAttribute('size', 'size');
 * point.dataSource = data;
 * ```
 */
export class SimplePoint extends GeoPoints {
	/**
	 * 构造函数
	 * @param {Object} parameters 配置参数
	 * @param {string|THREE.Color} [parameters.color] 点颜色，默认0xffff00
	 * @param {boolean} [parameters.vertexColors=false] 是否启用数据驱动的颜色配置，默认false
	 * @param {number} [parameters.size] 点大小，默认30
	 * @param {boolean} [parameters.transparent=false] 是否启用透明，默认false
	 * @param {boolean} [parameters.vertexSizes=false] 是否启用数据驱动的大小配置，默认false
	 * @param {number} [parameters.opacity=1] 透明度，默认1
	 */
	constructor(parameters: {
		color?: string | THREE.Color;
		vertexColors?: boolean;
		size?: number;
		transparent?: boolean;
		vertexSizes?: boolean;
		opacity?: number;
	});
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/**
	 * 点颜色
	 * @type {string}
	 * @example
	 * ```javascript
	 * point.color = 'rgba(250, 90, 50, 1)';
	 * ```
	*/
	color: string;
	/**
	 * 是否启用数据驱动的颜色配置
	 * @type {boolean}
	 * @default false
	 * @example
	 * ```javascript
	 * point.vertexColors = true;
	 * ```
	*/
	vertexColors: boolean;
	/**
	 * 是否启用数据驱动的大小配置
	 * @type {boolean}
	 * @default false
	 * @example
	 * ```javascript
	 * point.vertexSizes = true;
	 * ```
	*/
	vertexSizes: boolean;
	/**
	 * 不透明度, 若想实现半透明效果, 需要`transparent`设置为`true`
	 * @type {number}
	 * @default 1
	 * @example
	 * ```javascript
	 * point.opacity = 0.8;
	 * ```
	*/
	opacity: number;
	parameters: {
		color?: string | THREE.Color;
		vertexColors?: boolean;
		size?: number;
		transparent?: boolean;
		vertexSizes?: boolean;
		opacity?: number;
	};
	collisionTest(data: any): {
		width: any;
		height: any;
	};
}
declare class GeoInstancedPointMesh extends GeoInstancedMesh {
	isInstancedPointMesh: boolean;
	computeInstanceMorphMatrix(scale: any): Readonly<Matrix4>;
}
/**
 * 特效点，根据类型自动创建对应的特效对象。
 *
 * 支持扇形雷达、气泡等特效类型，通过type字段自动创建对应的特效对象，包括`Fan`、`Bubble`、`Wave`、`Breath`、`Radar`、`RadarLayered`、`RadarSpread`类型。
 *
 * 注意：动画效果需要在处理画引擎时设置`rendering.enableAnimationLoop=true`
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建扇形雷达特效
 * const effectPoint = engine.add(new mapvthree.EffectPoint({
 *     type: 'Fan',
 *     color: 0xff0000,
 *     size: 50
 * }));
 *
 * // 创建气泡特效
 * const bubblePoint = engine.add(new mapvthree.EffectPoint({
 *     type: 'Bubble',
 *     color: 0x00ff00,
 *     size: 30
 * }));
 * ```
 */
export class EffectPoint extends GeoInstancedPointMesh {
	/**
	 * 构造函数
	 * @param {{color?: string, size?: number, duration?: number, type?: string, keepSize?: boolean
	 * vertexColors?: boolean, vertexSizes?: boolean, segmentAngle?: number,
	 * sideColor?: string}} parameters 传入参数对象
	 * @param {string} parameters.color 气泡颜色
	 * @param {number} parameters.size 气泡尺寸
	 * @param {number} parameters.duration 气泡动画间隔时长
	 * @param {string} parameters.type 气泡类型
	 * @param {number} parameters.keepSize 是否保持大小
	 * @param {boolean} parameters.vertexColors 是否通过数据携带颜色配置
	 * @param {boolean} parameters.vertexSizes 是否通过数据携带尺寸配置
	 * @param {number} parameters.segmentAngle 雷达的扇形弧度值，仅在type为Radar时有效
	 * @param {string} parameters.sideColor 最外圈底色，仅在type为RadarLayered时有效
	 */
	constructor(parameters: {
		color?: string;
		size?: number;
		duration?: number;
		type?: string;
		keepSize?: boolean;
		vertexColors?: boolean;
		vertexSizes?: boolean;
		segmentAngle?: number;
		sideColor?: string;
	});
	/** 气泡颜色 */ color: any;
	/** 气泡尺寸 */ size: any;
	/** 气泡动画间隔时长 */ duration: any;
	/** 气泡类型 */ type: any;
	parameters: {
		color?: string;
		size?: number;
		duration?: number;
		type?: string;
		keepSize?: boolean;
		vertexColors?: boolean;
		vertexSizes?: boolean;
		segmentAngle?: number;
		sideColor?: string;
	};
	clone(): any;
}
/**
 * 气球点，用于显示气球样式的点数据可视化，支持实例化渲染，适合大量点数据的展示。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建气球点
 * const ballonPoint = engine.add(new mapvthree.BallonPoint({
 *     color: 0xff0000,
 *     size: 20,
 *     height: 100,
 *     iconSrc: 'car'
 * }));
 * ```
 */
export class BallonPoint extends GeoInstancedMesh {
	/**
	 * 构造函数
	 * @param {Object} parameters 配置参数
	 * @param {string} [parameters.iconSrc='car'] 气球图标源
	 * @param {number} [parameters.color] 气球颜色
	 * @param {number} [parameters.size] 气球大小
	 * @param {Array<number>} [parameters.size3] 气球三维大小
	 * @param {number} [parameters.height] 气球高度
	 * @param {number} [parameters.opacity] 透明度
	 * @param {boolean} [parameters.dashed] 是否使用虚线样式
	 */
	constructor(parameters: {
		iconSrc?: string;
		color?: number;
		size?: number;
		size3?: Array<number>;
		height?: number;
		opacity?: number;
		dashed?: boolean;
	});
	parameters: {
		iconSrc?: string;
		color?: number;
		size?: number;
		size3?: Array<number>;
		height?: number;
		opacity?: number;
		dashed?: boolean;
	};
}
/**
 * 图标渲染对象，用于在地图上绘制图标标记。支持自定义图片、大小、颜色和动画效果。
 * 主要特性：
 * - 支持自定义图标图片
 * - 支持固定像素大小或随图缩放
 * - 支持颜色调整和透明度
 * - 支持平面贴地或面向屏幕展示
 * - 支持跳动动画效果
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础图标
 * const icon = engine.add(new mapvthree.Icon({
 *     mapSrc: 'path/to/icon.png',
 *     width: 32,
 *     height: 32,
 *     keepSize: true,
 *     vertexIcons: true
 * }));
 *
 * // 设置数据源
 * let data = mapvthree.GeoJSONDataSource.fromGeoJSON(pointData);
 * data.defineAttribute('icon', 'icon');  // 如果使用 vertexIcons
 * icon.dataSource = data;
 * ```
 * ![](media://icon.png)
 */
export class Icon extends GeoMesh {
	/**
	 * 创建图标渲染对象
	 * @param {Object} parameters 配置参数
	 * @param {string} [parameters.mapSrc] 图标图片URL
	 * @param {boolean} [parameters.vertexIcons=false] 是否通过数据携带图标URL, 默认false
	 * @param {boolean} [parameters.vertexColors=false] 是否通过数据携带颜色, 默认false
	 * @param {number} [parameters.width=12] 图标宽度, 默认12
	 * @param {number} [parameters.height=12] 图标高度, 默认12
	 * @param {Array<number>} [parameters.offset=[0,0]] 图标偏移量, 默认[0,0]
	 * @param {boolean} [parameters.transparent=true] 是否启用透明, 默认true
	 * @param {number} [parameters.opacity=1] 整体透明度, 默认1
	 * @param {boolean} [parameters.keepSize=true] 是否保持像素大小, 默认true
	 * @param {boolean} [parameters.flat=false] 是否贴地显示, 默认false
	 * @param {string} [parameters.color] 图标颜色
	 * @param {number} [parameters.rotateZ=0] 旋转弧度(0~2π)，仅在flat为true时生效
	 * @param {boolean} [parameters.animationJump=false] 是否启用跳动动画, 默认false
	 * @param {number} [parameters.jumpHeight=20] 跳动高度, 默认20
	 * @param {number} [parameters.jumpSpeed=1] 跳动速度, 默认1
	 */
	constructor(parameters?: {
		mapSrc?: string;
		vertexIcons?: boolean;
		vertexColors?: boolean;
		width?: number;
		height?: number;
		offset?: Array<number>;
		transparent?: boolean;
		opacity?: number;
		keepSize?: boolean;
		flat?: boolean;
		color?: string;
		rotateZ?: number;
		animationJump?: boolean;
		jumpHeight?: number;
		jumpSpeed?: number;
	});
	/** @protected */ protected texture: CanvasTexture;
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/** @protected */ protected canvas: HTMLCanvasElement;
	/** @protected */ protected ctx: CanvasRenderingContext2D;
	/** @protected */ protected iconUrlHash: Map<any, any>;
	/** @protected */ protected boxHash: Map<any, any>;
	/** @protected */ protected gap: number[];
	parameters: {
		mapSrc?: string;
		vertexIcons?: boolean;
		vertexColors?: boolean;
		width?: number;
		height?: number;
		offset?: Array<number>;
		transparent?: boolean;
		opacity?: number;
		keepSize?: boolean;
		flat?: boolean;
		color?: string;
		rotateZ?: number;
		animationJump?: boolean;
		jumpHeight?: number;
		jumpSpeed?: number;
	};
	boxes: any[];
	boxSize: any;
	collisionTest(data: any): {
		width: any;
		height: any;
	};
	createTexture(): Map<any, any> | {
		texture: CanvasTexture;
		iconUrlHash: Map<any, any>;
	} | {
		texture?: undefined;
		iconUrlHash?: undefined;
	};
	set padding(value: Array<number>);
	get padding(): Array<number>;
	getVertexPosition(index: any, target: any): any;
	getPixelSize(position: any): any;
	/** @protected */
	protected getEntityIndexByFace(faceIndex: any, pointIndex: any): any;
	_computeIntersections: any;
}
/**
 * DOM点对象，用于在地图上添加基于DOM的自定义信息窗口。可以结合事件绑定实现弹窗组件等功能。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础的DomPoints
 * const domPoint = engine.add(new mapvthree.DOMPoint({
 *     offset: [-270, -200]
 * }));
 *
 * // 自定义渲染函数, 创建dom元素
 * domPoint.renderItem = (value) => {
 *     const node = document.createElement('div');
 *     node.className = 'custom-point';
 *     node.innerHTML = `
 *         <div class="title">${value.attributes.name}</div>
 *         <div class="content">${value.attributes.description}</div>
 *     `;
 *     return node;
 * };
 *
 * // 设置数据源
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([
 *     {
 *         type: 'Feature',
 *         geometry: {
 *             type: 'Point',
 *             coordinates: [116.404, 39.915]
 *         },
 *         properties: {
 *             name: '位置1',
 *             description: '这是位置1的描述'
 *         }
 *     }
 * ]);
 * domPoint.dataSource = data;
 * ```
 */
declare class DOMPoint$1 extends GeoObject {
	/**
	 * @readonly
	 * 是否为DomPoints类型
	 */
	readonly isDOMPoint: true;
	/**
	 * @readonly
	 * 是否渲染视椎体外的物体，为false时需要渲染
	 */
	readonly frustumCulled: false;
	nodes: any[];
	offset: number[];
	/**
	 * 用于生成dom节点, 若需要自定义dom元素，需要覆盖此方法
	 * @returns {HTMLElement} dom节点
	 * @param {Object} value 数据源中的数据项
	 * @example
	 * ```javascript
	 * domPoint.renderItem = (value) => {
	 *     const node = document.createElement('div');
	 *     node.className = 'custom-point';
	 *     node.innerHTML = `
	 *         <div class="title">${value.attributes.name}</div>
	 *         <div class="content">${value.attributes.description}</div>
	 *     `;
	 *     return node;
	 * };
	 * ```
	 */
	renderItem(value: any): HTMLElement;
	/**
	 * @protected
	 * 根据当前object的位置来计算node的偏移
	 */
	protected onBeforeScenePrepareRenderHook: (engine: any, scene: any, camera: any) => void;
	container: any;
	clone(): this;
}
declare class PointGroup extends GeoObject {
	/**
	 * 是否支持返回的事件参数中携带entity实体数据
	 */
	isEventEntitySupported: boolean;
	/**
	 * 添加GeoObject类型的部件
	 * @param {GeoObject} object 添加的对象
	 * @returns {GeoObject} 添加的对象
	 * @example
	 * ```javascript
	 * const icon = new Icon({
	 *     width: 30,
	 *     height: 30,
	 *     mapSrc: 'marker.png'
	 * });
	 * pointGroup.addComponent(icon);
	 * ```
	 */
	addComponent(object: GeoObject): GeoObject;
	/**
	 * 移除部件
	 * @param {GeoObject} object 要移除的地理对象
	 * @example
	 * ```javascript
	 * const icon = new Icon();
	 * pointGroup.addComponent(icon);
	 * // ... 其他操作 ...
	 * pointGroup.removeComponent(icon); // 移除之前添加的图标组件
	 * ```
	*/
	removeComponent(object: GeoObject): void;
	getChildDataSource(child: any): DataSource;
}
/**
 * 聚合点，它能够汇总一组点要素，统计数据，利用聚合统计得到的数据信息，
 * 结合其他的可视化元素可以展示更丰富的效果。
 *
 * @category Objects
 * @example
 * ```javascript
 * const cluster = engine.add(new mapvthree.ClusterPoint({
 *     cluster: {
 *         radius: 100,
 *         maxZoom: 18,
 *         minZoom: 5
 *     },
 *     icon: {
 *         width: 30,
 *         height: 30,
 *         mapSrc: 'path/to/icon.png'
 *     },
 *     label: {
 *         fontSize: 14,
 *         width: 90,
 *         height: 40,
 *         fillStyle: '#ffffff',
 *         background: 'website_assets/images/speed-panel.png',
 *     }
 * }));
 * // 指定聚合源数据
 * let dataSource = mapvthree.GeoJSONDataSource.fromGeoJSON(data);
 * cluster.dataSource = dataSource;
 * ```
 * @example
 * ```javascript
 * // 添加自定义聚合组件
 * cluster.addComponent(new mapvthree.Text({
 *     fontSize: 14,
 *     fillStyle: '#ffffff',
 * }));
 * // 设置聚合数据数据源属性
 * cluster.clusterDataSource.defineAttribute('text', () => {
 *     return '自定义聚合组件';
 * });
 * ```
 */
export class ClusterPoint extends PointGroup {
	/**
	 * 构造函数
	 * @param {Object} parameters 传入参数对象
	 * @param {Object} [parameters.cluster] 聚合配置
	 * @param {number} [parameters.cluster.maxZoom=18] 生成聚合数据的最大缩放级别, 默认18
	 * @param {number} [parameters.cluster.minZoom=5] 生成聚合数据的最小缩放级别, 默认5
	 * @param {number} [parameters.cluster.radius=50] 聚合半径, 单位px, 默认50px
	 * @param {Object} [parameters.icon] 图标配置
	 * @param {number} [parameters.icon.width=30] 图标宽度, 默认30px
	 * @param {number} [parameters.icon.height=30] 图标高度, 默认30px
	 * @param {string} [parameters.icon.mapSrc] 图标图片地址
	 * @param {Object} [parameters.label] 标签配置
	 * @param {string} [parameters.label.fillStyle='#ccc'] 文字颜色, 默认#ccc
	 * @param {number} [parameters.label.fontSize=16] 文字大小, 默认16px
	 * @param {boolean} [parameters.label.flat=false] 是否平面化显示, 默认false
	*/
	constructor(parameters?: {
		cluster?: {
			maxZoom?: number;
			minZoom?: number;
			radius?: number;
		};
		icon?: {
			width?: number;
			height?: number;
			mapSrc?: string;
		};
		label?: {
			fillStyle?: string;
			fontSize?: number;
			flat?: boolean;
		};
	});
	cachedData: any;
	getChildDataSource(): GeoJSONDataSource;
	/**
	 * 更新最短的时间间隔, 最小为16ms
	 * @param {number} value
	 */
	set minUpdateInterval(value: number);
	/**
	 * 更新最短的时间间隔, 单位ms, 默认300ms
	 * @return {number}
	 */
	get minUpdateInterval(): number;
	/**
	 * cluster聚合点的数据源, 聚合部件的子数据源
	 * @type {GeoJSONDataSource}
	 * @readonly
	 * @example
	 * ```javascript
	 * const clusterDataSource = clusterPoint.clusterDataSource;
	 * clusterDataSource.defineAttribute('text');
	 * ```
	 */
	readonly get clusterDataSource(): GeoJSONDataSource;
	/**
	 * 当前聚合后的数据
	 * @type {Array}
	 * @readonly
	 * @example
	 * ```javascript
	 * const data = clusterPoint.clusterData;
	 * console.log('当前聚合点数量:', data.length);
	 * ```
	 *
	 * ```json
	 * [
	 *     // 非聚合数据
	 *     {
	 *         type: 'Feature',
	 *         geometry: {
	 *             coordinates: [119, 36],
	 *         },
	 *         properties: {
	 *             count: 9,
	 *         }
	 *     },
	 *     // 聚合数据
	 *     {
	 *         type: 'Feature',
	 *         geometry: {
	 *             coordinates: [120, 36],
	 *         },
	 *         properties: {
	 *             cluster: true, // 是否聚合
	 *             cluster_id: 1, // 聚合数据id
	 *             point_count: 10, // 聚合数据量
	 *         }
	 *     },
	 * ]
	 *
	 * ```
	*/
	readonly get clusterData(): any[];
}
/**
 * 特效模型点，支持加载自定义模型作为点类数据可视化，提供大小和动画配置参数，以实现理想的动画效果。
 *
 * 注意：动画效果需要在处理画引擎时设置`rendering.enableAnimationLoop=true`
 *
 * @category Objects
 * @example
 * ```javascript
 * const effectModelPoint = engine.add(new mapvthree.EffectModelPoint({
 *     normalize: true,
 *     rotateToZUp: true,
 *     keepSize: true,
 *     animationRotate: true,
 *     animationJump: true,
 *     animationJumpHeight: 100
 * }));
 * effectModelPoint.model = gltf.scene;
 * effectModelPoint.size = 30;
 * ```
 */
export class EffectModelPoint extends GeoObject {
	/**
	 * 构造函数
	 * @param {Object} parameters 传入参数对象
	 * @param {boolean} [parameters.normalize=true] 是否归一化模型大小
	 * @param {boolean} [parameters.rotateToZUp=true] 将模型调整至z轴朝上
	 * @param {boolean} [parameters.keepSize=true] 是否保持大小
	 * @param {boolean} [parameters.animationRotate=false] 是否启用旋转动画
	 * @param {number} [parameters.animationRotatePeriod=3000] 旋转一周的时间，单位毫秒
	 * @param {boolean} [parameters.animationJump=false] 是否启用跳跃动画
	 * @param {number} [parameters.animationJumpPeriod=3000] 跳跃一次的时间周期，单位毫秒
	 * @param {number} [parameters.animationJumpHeight=30] 跳跃高度
	 * @param {boolean} [parameters.vertexColors=false] 是否使用顶点颜色
	 * @param {boolean} [parameters.vertexSizes=false] 是否使用顶点大小
	 */
	constructor(parameters: {
		normalize?: boolean;
		rotateToZUp?: boolean;
		keepSize?: boolean;
		animationRotate?: boolean;
		animationRotatePeriod?: number;
		animationJump?: boolean;
		animationJumpPeriod?: number;
		animationJumpHeight?: number;
		vertexColors?: boolean;
		vertexSizes?: boolean;
	});
	/**
	 * 是否支持事件实体
	 * @type {boolean}
	 */
	isEventEntitySupported: boolean;
	parameters: {
		normalize?: boolean;
		rotateToZUp?: boolean;
		keepSize?: boolean;
		animationRotate?: boolean;
		animationRotatePeriod?: number;
		animationJump?: boolean;
		animationJumpPeriod?: number;
		animationJumpHeight?: number;
		vertexColors?: boolean;
		vertexSizes?: boolean;
	};
	/**
	 * effectModelPoint绑定的模型,默认为null
	 */
	set model(value: any);
	get model(): any;
}
/**
 * 用于高效绘制大量圆形。支持自定义颜色、大小、边框等属性。
 *
 * @category Objects
 * @example
 * ```javascript
 * const circle = engine.add(new mapvthree.Circle({
 *     color: '#f4f27a',
 *     borderWidth: 20,
 *     borderColor: '#b73145',
 *     opacity: 0.8,
 *     vertexSizes: true
 * }));
 * ```
 */
export class Circle extends GeoInstancedPointMesh {
	/**
	 * 创建一个圆形实例化渲染对象
	 * @param {Object} parameters 圆形配置参数
	 * @param {string} [parameters.color] 圆形的填充颜色, 默认#ff8000
	 * @param {number} [parameters.size] 圆形的大小, 默认100
	 * @param {number} [parameters.opacity] 整体透明度 (0-1), 默认为1
	 * @param {string} [parameters.type] 圆形渲染类型, 可选值: 'Gradient' | 'Default', 默认'Default'
	 * @param {number} [parameters.borderWidth] 边框宽度（keepSize为true时单位为像素，否则为m）, 默认1
	 * @param {string} [parameters.borderColor] 边框颜色, 默认#00ff00
	 * @param {number} [parameters.borderOpacity] 边框透明度 (0-1), 默认1
	 * @param {number} [parameters.fillOpacity] 填充区域透明度 (0-1), 默认为1
	 * @param {boolean} [parameters.vertexColors] 是否启用顶点颜色, 默认false
	 * @param {boolean} [parameters.vertexSizes] 是否启用顶点大小, 默认false
	*/
	constructor(parameters: {
		color?: string;
		size?: number;
		opacity?: number;
		type?: string;
		borderWidth?: number;
		borderColor?: string;
		borderOpacity?: number;
		fillOpacity?: number;
		vertexColors?: boolean;
		vertexSizes?: boolean;
	});
	parameters: {
		color?: string;
		size?: number;
		opacity?: number;
		type?: string;
		borderWidth?: number;
		borderColor?: string;
		borderOpacity?: number;
		fillOpacity?: number;
		vertexColors?: boolean;
		vertexSizes?: boolean;
	};
	collisionTest(data: any): {
		width: number;
		height: number;
	};
}
declare class JointLineComponent {
	/**
	 * @param {Object} label - 宿主 Label 实例
	 */
	constructor(label: any);
	/** @type {import('three').Mesh|null} */
	_mesh: import("three").Mesh | null;
	/** @type {Map<string|number, {start: number, end: number}>} id → 顶点范围 */
	/** @type {Float32BufferAttribute|null} */
	_fadeAttr: Float32BufferAttribute | null;
	/** @type {Map<string|number, Object>} id → fadeItem 索引，复用避免 GC */
	/** @type {Map<string, Promise>} 纹理缓存 */
	_textureCache: Map<string, Promise<any>>;
	/** @type {Object|null} 宿主 Label 引用 */
	/**
	 * Label component 接口：fade 数据更新时调用
	 * 首次调用时构建 mesh，后续调用时同步 fade attribute
	 * @param {Array} renderedData
	 */
	onFadeUpdate(renderedData: any[]): void;
	/**
	 * 检查是否需要重建 geometry（id 集合变化）
	 */
	/**
	 * 构建 JointLine mesh
	 */
	/**
	 * 检查 Label RTC 是否变了
	 * @returns {boolean} true 表示需要重建
	 */
	/**
	 * RTC center 变了但 id 集合没变，只更新顶点坐标和 mesh.position
	 * 不重建 material，避免 shader 重新编译的开销
	 */
	/**
	 * 同步 fade attribute
	 */
	/**
	 * 加载纹理
	 * @param {string} fillTexture - 纹理文件名
	 * @param {Object} uniforms - material uniforms
	 * @param {string} [resourceBaseUrl] - 资源基础路径
	 */
	/**
	 * 释放当前 mesh
	 */
	/**
	 * 完全释放
	 */
	dispose(): void;
}
declare class FadeData {
	constructor(options?: {});
	isStable(time: any): boolean;
	update(data: any, time: any, filter?: boolean): void;
	set filterData(value: any[]);
	get filterData(): any[];
	get data(): any[];
	set fadeDuration(value: number);
	get fadeDuration(): number;
}
declare class FontAtlasManager {
	props: {};
	get atlas(): any;
	get mapping(): any;
	setProps(props?: {}): void;
	setPropsAsync(scheduler: any, props?: {}, batchSize?: number): Promise<any>;
}
declare class SymbolMaterial extends CommonShaderMaterial {
	vertexShader: any;
	fragmentShader: any;
}
declare class TextBoxCalculator {
	constructor(ctx: any, options?: {});
	ctx: any;
	engine: any;
	dpr: any;
	padding: any;
	getTextBox(data: any, isFlat: any): {
		width: number;
		height: number;
		wrappedText: string;
		widthList: any;
		chars: any;
		rotationMatrix: Matrix4;
	} | {
		width: number;
		height: number;
		wrappedText: string;
		widthList: any[];
		chars?: undefined;
		rotationMatrix?: undefined;
	};
	getStrictStyleId(data: any): string;
}
declare class GeometryBufferBuilder {
	constructor(maxChar?: number);
	maxChar: number;
	data: {
		positions: Float32Array<ArrayBuffer>;
		typesAndPIndices: Float32Array<ArrayBuffer>;
		rotateZs: Float32Array<ArrayBuffer>;
		uvs: Float32Array<ArrayBuffer>;
		offsets: Float32Array<ArrayBuffer>;
		instanceRotationMatrices: Float32Array<ArrayBuffer>;
		whs: Float32Array<ArrayBuffer>;
		stretch: Float32Array<ArrayBuffer>;
		styles: Float32Array<ArrayBuffer>;
		fadeOpacityAndSince: Float32Array<ArrayBuffer>;
		indices: any[];
	};
	offsets: {
		positionsOffset: number;
		typesAndPIndicesOffset: number;
		rotateZsOffset: number;
		uvsOffset: number;
		offsetsOffset: number;
		instanceRotationMatricesOffset: number;
		whsOffset: number;
		stylesOffset: number;
		fadeOpacityAndSinceOffset: number;
		stretchOffset: number;
	};
	clear(): void;
	packPosition(x: any, y: any, z: any): void;
	packUV(uv: any): void;
	packOffset(dx: any, dy: any): void;
	packTypeAndPIndex(type: any): void;
	packRotateZ(theta: any): void;
	packStyle(fill: any, stroke: any, strokeWidth: any): void;
	packWH(width: any, height: any, iconSize?: number): void;
	packStretch(start?: number, end?: number, stretchRatio?: number, stretchGap?: number): void;
	packRotationMatrix(mat3: any): void;
	packFade(fadeOpacity: any, fadeSince: any): void;
	packQuadIndices(indexOffset: any): void;
	get drawRange(): number;
}
type LabelMeshParameters = {
	/**
	 * - icon texture
	 */
	spriteTexture?: Texture;
	/**
	 * - 文字是否贴地
	 */
	flat?: boolean;
	/**
	 * - 是否在后处理中绘制
	 */
	isRenderInPostprocess: boolean;
};
/**
 * @category Objects
 * @description 标签对象，用于在地图上渲染文本标签、图标标签或两者结合, 支持自定义样式。 `Label`组件一般用于批量管理大量标签数据, 比如整体显隐控制, 对于少量的标签加载和管理推荐使用{@link RenderingLabel}。
 * @example 文本标签
 * ```javascript
 * // 创建一个文本标签
 * const textLabel = engine.add(new mapvthree.Label({
 *     type: 'text',
 *     textSize: 16,
 *     textFillStyle: 'rgb(255, 8, 8)', // 字体颜色
 *     textStrokeStyle: 'rgba(0, 0, 0, 1)', // 边框颜色
 *     textStrokeWidth: 2, // 边框宽度
 * }))
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([
 *  {
 *      type: 'Feature',
 *      geometry: {
 *          type: 'Point',
 *          coordinates: [116.404, 39.915]
 *      },
 *      properties: {
 *          text: '北京市',
 *      }
 *  }]);
 * data.defineAttribute('text', 'text');
 * textLabel.dataSource = data;
 * ```
 * @example 图标标签
 * ```javascript
 * // 创建一个图标标签
 * const iconLabel = engine.add(new mapvthree.Label({
 *     type: 'icon',
 *     vertexIcons: true,
 *     iconWidth: 40,
 *     iconHeight: 40,
 * }));
 * // 设置数据源
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([
 *  {
 *      type: 'Feature',
 *      geometry: {
 *          type: 'Point',
 *          coordinates: [116.404, 39.915]
 *      },
 *      properties: {
 *          icon: 'path/icon.png',
 *      }
 *  }
 * ]);
 * // 设置数据源
 * data.defineAttribute('icon', 'icon');
 * iconLabel.dataSource = data;
 * ```
 *
 * @example 图标文字组合标签
 * ```javascript
 * // 创建一个图标和文字组合标签
 * const abel = engine.add(new mapvthree.Label({
 *     type: 'icontext',
 *     vertexIcons: true,
 *     textSize: 16,
 *     textFillStyle: 'rgb(255, 8, 8)', // 字体颜色
 *     textStrokeStyle: 'rgba(0, 0, 0, 1)', // 边框颜色
 *     textStrokeWidth: 2, // 边框宽度
 *     iconWidth: 40,
 *     iconHeight: 40,
 * }));
 * // 设置数据源
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([
 *  {
 *      type: 'Feature',
 *      geometry: {
 *          type: 'Point',
 *          coordinates: [116.404, 39.915]
 *      },
 *      properties: {
 *          icon: 'path/icon.png',
 *      }
 *  }
 * ]);
 * // 设置数据源
 * data.defineAttribute('icon', 'icon');
 * data.defineAttribute('text', 'text');
 * label.dataSource = data;
 * ```
 * @description `Label`组件的样式可以通过初始化参数整体控制, 也支持丰富的自定义样式配置(在传入数据中携带)
 * @example 自定义样式
 * ```javascript
 * // 整体控制样式，在初始化时设置
 * const label = engine.add(new mapvthree.Label({
 *     type: 'icontext',
 *     vertexIcons: true,
 *     textSize: 16,
 *     textFillStyle: 'rgb(255, 8, 8)', // 字体颜色
 *     textStrokeStyle: 'rgba(0, 0, 0, 1)', // 边框颜色
 *     textStrokeWidth: 2, // 边框宽度
 *     iconWidth: 40,
 *     iconHeight: 40,
 * }));
 * // 自定义样式，在传入数据中设置
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([
 *  {
 *      type: 'Feature',
 *      geometry: {
 *          type: 'Point',
 *          coordinates: [116.404, 39.915]
 *      },
 *      properties: {
 *          icon: 'path/icon.png',
 *          iconSize: [40, 40],
 *          text: '北京市',
 *          textSize: 16,
 *          textAnchor: 'center',
 *          textFillStyle: 'rgb(255, 8, 8)', // 字体颜色
 *          textStrokeStyle: 'rgba(0, 0, 0, 1)', // 边框颜色
 *          textStrokeWidth: 2, // 边框宽度
 *          textOffset: [0, 0],
 *          rotateZ: 0, // 旋转角度
 *      }
 * }
 * ]);
 * // 支持的自定义数据配置
 * // 图标相关
 * data.defineAttribute('icon', 'icon'); // 图标路径
 * data.defineAttribute('iconSize', 'iconSize'); // 图标尺寸
 * // 文字相关
 * data.defineAttribute('text', 'text'); // 文字内容
 * data.defineAttribute('textSize', 'textSize'); // 文字大小
 * data.defineAttribute('textFillStyle', 'textFillStyle'); // 文字颜色
 * data.defineAttribute('textStrokeStyle', 'textStrokeStyle'); // 文字边框颜色
 * data.defineAttribute('textStrokeWidth', 'textStrokeWidth'); // 文字边框宽度
 * data.defineAttribute('textOffset', 'textOffset'); // 文字偏移
 * data.defineAttribute('textAnchor', 'textAnchor'); // 文字对齐方式
 * // 其他
 * data.defineAttribute('rotateZ', 'rotateZ'); // 旋转角度
 * ```
 */
export class Label extends GeoMesh {
	/**
	 * 构造函数
	 * @param {Object} parameters 配置参数
	 * @param {Boolean} [parameters.vertexIcons=false] 数据中是否携带icon(url资源), 默认为false
	 * @param {Boolean} [parameters.flat=false] 是否贴地, 默认为false
	 * @param {String} [parameters.type='icon'] 绘制类型,支持'icon'｜'text'｜'icontext'
	 * @param {Boolean} [parameters.enableFade=false] 是否启用淡入淡出效果, 默认为false, 若要启用淡入淡出效果, 数据中需要指定id
	 * @param {Number} [parameters.textSize=16] 文字大小, 默认16
	 * @param {String} [parameters.textFamily='sans-serif'] 文字字体
	 * @param {String|Array} [parameters.textFillStyle=[255,255,255]] 文字颜色, 默认[255,255,255]
	 * @param {String|Array} [parameters.textStrokeStyle=[0,0,0]] 文字描边颜色, 默认[0,0,0]
	 * @param {Number} [parameters.textStrokeWidth=0] 文字描边宽度, 默认0
	 * @param {String} [parameters.textAnchor='center'] 文字锚点, 支持'left'|'right'|'top'|'bottom'|'top-left'|'top-right'|'bottom-left'|'bottom-right', 默认'center'
	 * @param {Array} [parameters.textOffset=[0,0]] 文字偏移, 默认[0,0]
	 * @param {String} [parameters.textWeight='400'] 文字粗细, 默认'400'
	 * @param {Array} [parameters.textPadding=[0,2]] 文字内边距, 默认[0,0]
	 * @param {Array} [parameters.padding=[2, 2]] 文字与图标间距, 默认[2, 2]
	 * @param {Number} [parameters.iconWidth=40] 图标宽度, 默认40
	 * @param {Number} [parameters.iconHeight=40] 图标高度, 默认40
	 * @param {Number} [parameters.rotateZ=0] 旋转角度, 默认0
	 * @param {String} [parameters.textAlign='center'] 文本对齐方式,支持'left'|'right'|'center', 默认'center'
	 * @param {String} [parameters.mapSrc] 图标url
	 * @param {Boolean} [parameters.transparent=false] 是否透明
	 * @param {Array} [parameters.pixelOffset] 像素偏移, 默认[0,0]
	 * @param {Array} [parameters.positionOffset] 坐标偏移, 默认[0,0]
	 * @param {Array} [parameters.useIconScale] 是否使用图片自身的比例
	*/
	constructor(parameters?: {
		vertexIcons?: boolean;
		flat?: boolean;
		type?: string;
		enableFade?: boolean;
		textSize?: number;
		textFamily?: string;
		textFillStyle?: string | any[];
		textStrokeStyle?: string | any[];
		textStrokeWidth?: number;
		textAnchor?: string;
		textOffset?: any[];
		textWeight?: string;
		textPadding?: any[];
		padding?: any[];
		iconWidth?: number;
		iconHeight?: number;
		rotateZ?: number;
		textAlign?: string;
		mapSrc?: string;
		transparent?: boolean;
		pixelOffset?: any[];
		positionOffset?: any[];
		useIconScale?: any[];
	});
	isEventEntitySupported: boolean;
	/**
	 * @type {LabelMeshParameters}
	 */
	parameters: LabelMeshParameters;
	/**
	 * @type {Texture}
	 */
	spriteTexture: Texture;
	/**
	 * @type {Texture}
	 */
	textTexture: Texture;
	/** @protected */ protected iconUrlHash: LRUCache;
	/** @protected */ protected boxHash: Map<any, any>;
	/** @protected */ protected gap: number[];
	/** @protected */ protected _labelQuadStarts: any[];
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/** @protected */ protected canvas: HTMLCanvasElement;
	/** @protected */ protected ctx: CanvasRenderingContext2D;
	symbolType: any;
	textAlign: any;
	updateTextTexture(characterSet: any): Promise<void>;
	updateTextSpriteTexture(): void;
	packTextBuffer(textData: any, indexOffset?: number): number;
	updateTextDataItem(data: any, indexOffset: any): any;
	packRotateZ(rotateZ: any): void;
	packRotationMatrix(position: any): void;
	packPosition(position: any): void;
	packFade(data: any): void;
	packOffset(offsetX: any, offsetY: any): void;
	packWH(frameWidth: any, frameHeight: any, iconSize: any): void;
	packStretch(offsetX1: any, offsetX2: any, stretchRatio: any, stretchGap: any): void;
	packTypeAndPIndex(type: any): void;
	packIconStyle(opacity?: number): void;
	packIconUV(iconUV: any): void;
	packTextStyle(data: any): void;
	packTextWh(data: any, iconFrame: any): void;
	packTextUV(iconFrame: any): void;
	onBeforeScenePrepareRenderHook(engine: any, scene: any, camera: any): void;
	getVertexPosition(index: any, target: any): any;
	set enableFade(value: any);
	get enableFade(): any;
	/**
	 * 注册一个 component，在 fade 数据更新时接收通知
	 * @param {Object} component - 需实现 onFadeUpdate(renderedData) 和 dispose() 方法
	 */
	addComponent(component: any): void;
	/**
	 * 移除一个 component
	 * @param {Object} component
	 */
	removeComponent(component: any): void;
}
/**
 * 柱状体，支持柱形和锥形两种形状。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建柱形
 * const pillar = engine.add(new mapvthree.Pillar({
 *     shape: 'pillar',
 *     color: 0xff0000,
 *     height: 100,
 *     radius: 10
 * }));
 *
 * // 创建锥形
 * const cone = engine.add(new mapvthree.Pillar({
 *     shape: 'cone',
 *     color: 0x00ff00,
 *     height: 80,
 *     radius: 15
 * }));
 * ```
 */
export class Pillar extends GeoInstancedPointMesh {
	/**
	 * 构造函数
	 * @param {Object} parameters 配置参数
	 * @param {string} [parameters.shape='pillar'] 形状类型，支持'pillar'（柱形）和'cone'（锥形）
	 *
	 * @param {string} [parameters.color] 柱体颜色，支持十六进制颜色值或颜色名称，默认为[80, 20, 170, 0.8]
	 * @param {number} [parameters.opacity] 整体透明度，取值范围0-1，默认为1
	 * @param {number} [parameters.height] 柱体高度，默认为1
	 * @param {number} [parameters.radius] 柱体半径，默认为6
	 * @param {number} [parameters.radialSegments] 柱体边数，默认为4
	 * @param {number} [parameters.heightSegments] 柱体高度分段数，默认为1
	 * @param {boolean} [parameters.openEnded] 圆柱顶底是否打开，默认为true
	 * @param {boolean} [parameters.vertexHeights] 是否通过数据携带高度配置，默认为false
	 * @param {Object} [parameters.gradient] 颜色渐变配置对象
	 * @param {boolean} [parameter.colorMode] 颜色模式, 包含'gradient'(渐变)和'band'(颜色分带)
	 * @param {boolean} [parameter.heatmap] 是否开启热力模式, 默认开启
	 */
	constructor(parameter: any);
	/** 整体透明度 */ opacity: any;
	/** 柱体高度 */ height: any;
	/** 柱体边数 */ radiusSegments: any;
	/** 柱体半径 */ radius: any;
	/** 颜色渐变 */ gradient: any;
	/** 是否通过数据携带高度配置 */ vertexHeights: any;
	/** 圆柱顶底是否打开 */ openEnded: any;
	/** 着色模式 */ colorMode: any;
	/** 是否开启热力模式，默认开启 */ heatmap: any;
	/**
	 * @protected
	 * 计算根据height和size计算模型矩阵模型矩阵
	 */
	protected getInstanceLocalMatrix: (coordinates: any, dataItem: any, index: any) => Matrix4;
}
/**
 * 2D热力图，用于在地图上展示数据密度分布。支持自定义颜色渐变、透明度、半径等属性，可以高效渲染大量数据点。
 * 主要功能：
 * - 支持自定义颜色渐变配置
 * - 支持数据权重设置
 * - 支持保持大小（按像素为单位绘制）
 * - 支持径向渐变速度调整
 * @category Objects
 * @example
 * ```javascript
 * const heatmap = engine.add(new mapvthree.Heatmap({
 *     gradient: {
 *         0.4: 'blue',
 *         0.65: 'lime',
 *         1: 'red'
 *     },
 *     radius: 30,
 *     opacity: 0.8,
 *     keepSize: true
 * }));
 * let data = mapvthree.GeoJSONDataSource.fromGeoJSON(data);
 * heatmap.dataSource = data;
 * ```
 * ![](media://heatmap.png)
 */
export class Heatmap extends GeoMesh {
	/**
	 * 创建热力图实例
	 * @param {Object} parameters 热力图配置参数
	 * @param {Object} [parameters.gradient] 热力渐变颜色配置，格式为{stop: 'color'}，例如{0.4: 'blue', 0.65: 'lime', 1: 'red'}
	 * @param {number} [parameters.opacity=1] 透明度整体系数
	 * @param {number} [parameters.minValue=0] 最小热力值
	 * @param {number} [parameters.maxValue=100] 最大热力值
	 * @param {number} [parameters.radius=30] 热力绘制半径
	 * @param {boolean} [parameters.keepSize=false] 是否保持大小（即按像素为单位绘制）
	 * @param {number} [parameters.attenuateMValueFactor=0] 径向渐变速度
	 */
	constructor(parameters: {
		gradient?: any;
		opacity?: number;
		minValue?: number;
		maxValue?: number;
		radius?: number;
		keepSize?: boolean;
		attenuateMValueFactor?: number;
	});
	/**
	 * 是否为热力图
	 * @readonly
	 */
	readonly isHeatmap: true;
	/** @protected 几何体 */
	protected geometry: any;
	/** @protected 材质 */
	protected material: any;
	/**
	 * 热力渐变颜色配置，格式为{stop: 'color'}，例如{0.4: 'blue', 0.65: 'lime', 1: 'red'}
	 */
	set gradient(value: any);
	/**
	 * 设置热力绘制半径
	 * @param {number} value 半径值
	 */
	set radius(value: number);
	/**
	 * 获取热力绘制半径
	 * @returns {number} 半径值
	 */
	get radius(): number;
	/**
	 * 设置最小热力值
	 * @param {number} value 最小热力值
	 */
	set minValue(value: number);
	/**
	 * 获取最小热力值
	 * @returns {number} 最小热力值
	 */
	get minValue(): number;
	/**
	 * 设置最大热力值
	 * @param {number} value 最大热力值
	 */
	set maxValue(value: number);
	/**
	 * 获取最大热力值
	 * @returns {number} 最大热力值
	 */
	get maxValue(): number;
	/**
	 * 设置透明度
	 * @param {number} value 透明度值
	 */
	set opacity(value: number);
	/**
	 * 获取透明度
	 * @returns {number} 透明度值
	 */
	get opacity(): number;
	/**
	 * 设置是否保持大小（即按像素为单位绘制）
	 * @param {boolean} value 是否保持大小
	 */
	set keepSize(value: boolean);
	/**
	 * 获取是否保持大小（即按像素为单位绘制）
	 * @returns {boolean} 是否保持大小
	 */
	get keepSize(): boolean;
	/**
	 * 径向渐变速度
	 */
	set attenuateMValueFactor(value: any);
}
/**
 * 3D热力图，立体热力图，平面热力图见 {@link Heatmap}
 *
 * **注意：3D热力图目前只适用于小面积覆盖范围（区、乡镇级别以下），在大面积覆盖场景下（省、市级别以上）会有明显性能问题**
 *
 * @category Objects
 * @example
 * ```javascript
 * const heatmap = engine.add(new mapvthree.Heatmap3D({
 *     gradient: {
 *         0.4: 'rgba(0,0,255,1)',
 *         0.6: 'rgba(0,255,0,1)',
 *         0.8: 'rgba(255,255,0,1)',
 *         1: 'rgba(255,0,0,1)'
 *     },
 *     radius: 100,
 *     maxValue: 1
 * }));
 * let data = mapvthree.GeoJSONDataSource.fromGeoJSON(data);
 * heatmap.dataSource = data;
 * ```
 * ![](media://heatmap3d.png)
 */
export class Heatmap3D extends GeoMesh {
	/**
	 * 构造函数
	 * @param {Object} parameters 传入参数对象
	 * @param {Object} [parameters.gradient] 热力渐变颜色配置，格式为{stop: 'color'}，例如{0.4: 'blue', 0.65: 'lime', 1: 'red'}
	 * @param {number} [parameters.opacity=1] 透明度整体系数
	 * @param {number} [parameters.heightRatio=100] 高度系数
	 * @param {number} [parameters.maxValue=1] 最大热力值
	 * @param {number} [parameters.radius=100] 热力绘制半径
	 */
	constructor(parameters: {
		gradient?: any;
		opacity?: number;
		heightRatio?: number;
		maxValue?: number;
		radius?: number;
	});
	/** @protected */ protected isHeatmap3D: boolean;
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/** 透明度整体系数 */ opacity: any;
	/** 高度系数 */ heightRatio: any;
	parameters: {
		gradient?: any;
		opacity?: number;
		heightRatio?: number;
		maxValue?: number;
		radius?: number;
	};
	texture: CanvasTexture;
	set gradient(value: any);
	/** 热力渐变颜色配置，格式为{stop: 'color'}，例如{0.4: 'blue', 0.65: 'lime', 1: 'red'} */
	get gradient(): any;
	set radius(value: number);
	/** 热力绘制半径 */
	get radius(): number;
	set maxValue(value: number);
	/** 最大热力值 */
	get maxValue(): number;
}
/**
 * 文字网格对象，用于在地图上绘制文字标注。支持自定义字体样式、填充颜色、描边等特性。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础文字网格
 * const text = engine.add(new mapvthree.Text({
 *     fontSize: 16,
 *     fontFamily: 'Arial',
 *     fillStyle: '#ff0000',
 *     strokeStyle: '#ffffff',
 *     lineWidth: 2,
 *     padding: [4, 4],
 *     keepSize: true
 * }));
 *
 * // 设置数据源
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([{
 *     type: 'Feature',
 *     geometry: {
 *         type: 'Point',
 *         coordinates: [116.404, 39.915]
 *     },
 *     properties: {
 *         text: '北京市'
 *     }
 * }]);
 *
 * // 定义text属性映射
 * data.defineAttribute('text', 'text');
 * text.dataSource = data;
 * ```
*/
declare class Text$1 extends GeoMesh {
	/**
	 * 构造函数
	 * @param {{
	 * fontSize?: number, fontFamily?: string, fillStyle?: string,
	 * strokeStyle?: string, lineWidth?: number, padding?: Array<number>
	 * }} parameters 传入参数对象
	 * @param {number} parameters.fontSize 字号大小，默认16
	 * @param {string} parameters.fontFamily 字体，默认微软雅黑
	 * @param {string} parameters.fillStyle 绘制字的填充颜色
	 * @param {string} parameters.strokeStyle 绘制字的描边颜色
	 * @param {string} parameters.lineWidth 绘制字的描边宽度
	 * @param {Array<number>} parameters.padding 绘制字方块的内边距，默认[2, 2]
	 * @param {boolean} keepSize 是否保留字体大小，默认false
	 * @param {boolean} isRenderInPostprocess 是否在后处理中绘制
	 */
	constructor(parameters: {
		fontSize?: number;
		fontFamily?: string;
		fillStyle?: string;
		strokeStyle?: string;
		lineWidth?: number;
		padding?: Array<number>;
	});
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/** @protected */ protected cachedData: any[];
	/** @protected */ protected drawingData: any[];
	/** @protected */ protected canvas: HTMLCanvasElement;
	/** @protected */ protected ctx: CanvasRenderingContext2D;
	/** @protected */ protected texture: any;
	parameters: {
		fontSize?: number;
		fontFamily?: string;
		fillStyle?: string;
		strokeStyle?: string;
		lineWidth?: number;
		padding?: Array<number>;
	};
	/**
	 * 绘制字的描边颜色
	 * @param {string} value 描边颜色
	 * @example
	 * ```javascript
	 * text.strokeStyle = '#ffffff';
	 * ```
	 */
	set strokeStyle(value: string);
	get strokeStyle(): string;
	onBeforeScenePrepareRenderHook(engine: any, scene: any, camera: any): void;
	sortByStyle: (data: any) => any;
	getStrictStyleId: (data: any) => string | 0;
	/**
	 * 字号大小
	 * @param {number} value 字号
	 * @example
	 * ```javascript
	 * text.fontSize = 16;
	 * ```
	 */
	set fontSize(value: number);
	/**
	 * 获取字号大小
	 * @returns {number} 字号
	 */
	get fontSize(): number;
	/**
	 * 字体设置
	 * @param {string} value 字体
	 * @example
	 * ```javascript
	 * text.fontFamily = 'Arial';
	 * ```
	 */
	set fontFamily(value: string);
	/**
	 * 获取字体
	 * @returns {string} 字体
	 */
	get fontFamily(): string;
	/**
	 * 绘制字的填充颜色
	 * @param {string} value 填充颜色
	 * @example
	 * ```javascript
	 * text.fillStyle = '#ff0000';
	 * ```
	 */
	set fillStyle(value: string);
	/**
	 * 获取绘制字的填充颜色
	 * @returns {string} 填充颜色
	 */
	get fillStyle(): string;
	/**
	 * 绘制字的描边粗细
	 * @param {number} value 描边粗细
	 * @example
	 * ```javascript
	 * text.lineWidth = 2;
	 * ```
	 */
	set lineWidth(value: number);
	/**
	 * 获取绘制字的描边粗细
	 * @returns {number} 描边粗细
	 */
	get lineWidth(): number;
	/**
	 * 绘制字方块的内边距
	 * @param {Array<number>} value x轴与y轴的边距
	 * @example
	 * ```javascript
	 * text.padding = [4, 4];
	 * ```
	 */
	set padding(value: Array<number>);
	/**
	 * 获取绘制字方块的内边距
	 * @returns {Array<number>} x轴与y轴的边距
	 */
	get padding(): Array<number>;
}
declare class GeoGroup extends GeoObject {
	/**
	 * @readonly
	 * 类型为Group的标识
	 */
	readonly isGroup: true;
}
declare class SDFTextMaterial extends CommonShaderMaterial {
	vertexShader: any;
	fragmentShader: any;
	isSDFTextMaterial: boolean;
	emissiveEnabled: boolean;
	emissive: number[];
}
export class SDFText extends GeoGroup {
	outlineWidth: any;
	textAlign: any;
	alignRotate: any;
	cachedData: any[];
	shouldUpdateRenderingData: boolean;
	drawingData: any[];
	canvas: HTMLCanvasElement;
	ctx: CanvasRenderingContext2D;
	geometry: BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
	material: SDFTextMaterial[];
	fontStack: string;
	fontAtalasManager: FontAtlasManager;
	update(): void;
	updateRenderingData: () => void;
	updateSdfTexture(): void;
	collisionTest(data: any): any;
	/**
	 * 字号大小
	 * @param {number} value 字号
	 */
	set fontSize(value: number);
	get fontSize(): number;
	/**
	 * 字体设置
	 * @param {string} value 字体
	 */
	set fontFamily(value: string);
	get fontFamily(): string;
	/**
	 * 绘制字的填充颜色
	 * @param {string} value css颜色
	 */
	set fillStyle(value: string);
	get fillStyle(): string;
	/**
	 * 绘制字方块的内边距
	 * @param {Array<number>} value x轴与y轴的边距
	 */
	set padding(value: Array<number>);
	get padding(): Array<number>;
	/**
	 * 绘制字的描边颜色
	 */
	set strokeStyle(value: any[]);
	get strokeStyle(): any[];
	set enableFade(value: boolean);
	get enableFade(): boolean;
	getStrictStyleId: (data: any) => string | 0;
}
declare class GeoLine extends GeoObject {
	/**
	 * @readonly
	 * 类型为Line的标识
	 */
	readonly isLine: true;
	/**
	 * @readonly
	 * 类型为LineSegments的标识
	 */
	readonly isLineSegments: true;
}
/**
 * 烟花特效，通过该类可以配置产生绚烂的烟花效果，支持自定义颜色、高度、速度等参数。
 *
 * @category Objects
 * @example
 * ```javascript
 * const spark = engine.add(new mapvthree.Spark({
 *     color: 0xff0cc0, // 烟花颜色
 *     height: 200, // 烟花高度
 *     speed: 0.1, // 动画速度
 *     idle: 500, // 动画的间隔时间
 *     tailLength: 80, // 动画拖尾长度
 *     emissive: new Color(0x0000ff)
 * }));
 * ```
 * ![](media://spark.png)
 */
export class Spark extends GeoLine {
	/**
	 * 构造函数
	 * @param {Object} parameters 传入参数对象
	 * @param {string} [parameters.color] 烟花颜色
	 * @param {boolean} [parameters.vertexColors] 是否通过数据携带颜色配置
	 * @param {number} [parameters.height] 烟花高度
	 * @param {boolean} [parameters.vertexHeights] 是否通过数据携带高度配置
	 * @param {number} [parameters.speed] 动画速度
	 * @param {number} [parameters.tailLength] 动画拖尾长度
	 * @param {number} [parameters.idle] 动画的间隔时间，单位：毫秒
	 * @param {number} [parameters.opacity] 不透明度
	 */
	constructor(parameters: {
		color?: string;
		vertexColors?: boolean;
		height?: number;
		vertexHeights?: boolean;
		speed?: number;
		tailLength?: number;
		idle?: number;
		opacity?: number;
	});
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/** 烟花颜色 */ color: any;
	/** 是否通过数据携带颜色配置 */ vertexColors: any;
	/** 烟花高度 */ height: any;
	/** 是否通过数据携带高度配置 */ vertexHeights: any;
	/** 动画速度 */ speed: any;
	/** 动画拖尾长度 */ tailLength: any;
	/** 动画的间隔时间，单位：毫秒 */ idle: any;
	/** 自发光 */ emissive: any;
	parameters: {
		color?: string;
		vertexColors?: boolean;
		height?: number;
		vertexHeights?: boolean;
		speed?: number;
		tailLength?: number;
		idle?: number;
		opacity?: number;
	};
}
/**
 * 简单线条渲染对象，相比{@link Polyline}，SimpleLine 提供了更基础的线条渲染功能，可用于绘制1px宽度的线条
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础红色线条
 * const line = engine.add(new mapvthree.SimpleLine({
 *     color: 'rgba(250, 90, 50, 1)'
 * }));
 *
 * // 设置数据源
 * let data = mapvthree.GeoJSONDataSource.fromGeoJSON(lineData);
 * line.dataSource = data;
 * ```
 */
export class SimpleLine extends GeoLine {
	/**
	 * 创建简单线条渲染对象
	 * @param {Object} parameters 配置参数
	 * @param {string} [parameters.color='#ffffff'] 线条颜色, 默认#ffffff
	 * @param {number} [parameters.opacity=1.0] 透明度, 默认1.0
	 * @param {number} [parameters.granularity=0.5] 线段细分距离(度)，仅在3D模式下生效, 默认0.5
	 */
	constructor(parameters: {
		color?: string;
		opacity?: number;
		granularity?: number;
	});
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/**
	 * 点颜色
	 * @type {Color}
	 * @example
	* ```javascript
	* line.color = 'rgb(0, 255, 0)';
	* ```
	 */
	color: Color;
	parameters: {
		color?: string;
		opacity?: number;
		granularity?: number;
	};
}
declare class PolylineInternal extends GeoMesh {
	/**
	 * 构造函数
	 * @param {{
	 * color?: string, vertexColors?: boolean, emissive?: string, map?: string,
	 * opacity?: number, alphaTest?: number,
	 * dashed?: boolean, dashArray?: number, dashOffset?: number, dashRatio?: number,
	 * }} parameters 传入参数对象
	 * @param {number} parameters.lineWidth 线的宽度，默认是4
	 * @param {number} parameters.height 线的高度
	 * @param {string} parameters.color 线的颜色
	 * @param {boolean} parameters.vertexColors 是否通过数据携带颜色配置
	 * @param {string} parameters.emissive 自发光的颜色
	 * @param {number} parameters.opacity 线的整体透明系数，默认为1
	 * @param {number} parameters.alphaTest 开启透明剔除，透明度小于该值的部分都不渲染，默认为0
	 * @param {boolean} parameters.dashed 是否渲染虚线
	 * @param {number} parameters.dashArray 每段虚线（实心加空心部分）的长度
	 * @param {number} parameters.dashOffset 虚线起始绘制部分的偏移
	 * @param {number} parameters.dashRatio 实心部分占每段长度的占比
	 */
	constructor(parameters: {
		color?: string;
		vertexColors?: boolean;
		emissive?: string;
		map?: string;
		opacity?: number;
		alphaTest?: number;
		dashed?: boolean;
		dashArray?: number;
		dashOffset?: number;
		dashRatio?: number;
	});
	isEventEntitySupported: boolean;
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/** 线的颜色 */ color: any;
	/** 是否通过数据携带颜色配置 */ vertexColors: any;
	/** 自发光的颜色 */ emissive: any;
	/** 纹理贴图的路径 */ map: any;
	/** 线的整体透明系数 */ opacity: any;
	/** 开启透明剔除，透明度小于该值的部分都不渲染，默认为0 */ alphaTest: any;
	/** 是否渲染虚线 */ dashed: any;
	/** 每段虚线（实心加空心部分）的长度 */ dashArray: any;
	/** 虚线起始绘制部分的偏移 */ dashOffset: any;
	/** 实心部分占每段长度的占比 */ dashRatio: any;
	parameters: {
		color?: string;
		vertexColors?: boolean;
		emissive?: string;
		map?: string;
		opacity?: number;
		alphaTest?: number;
		dashed?: boolean;
		dashArray?: number;
		dashOffset?: number;
		dashRatio?: number;
	};
	computeViewportOrthographicTransform(viewport: any, near: any, far: any, matrix: any): any;
	computeViewportTransformation(viewport: any, near: any, far: any, matrix: any): any;
	onBeforeScenePrepareRenderHook(): void;
	afterGeometryUpdate(): void;
	makeGeometryOffsetPosition: (geometry: any) => void;
	set lineWidth(value: any);
	/**
	 * 线的宽度
	 */
	get lineWidth(): any;
}
declare class FatLineInternal extends GeoMesh {
	/**
	 * 创建宽线渲染对象
	 * @param {Object} parameters 配置参数
	 * @param {number} [parameters.lineWidth=4] 线宽
	 * @param {number} [parameters.height] 线的高度
	 * @param {boolean} [parameters.keepSize=true] 是否保持像素宽度
	 * @param {string} [parameters.color] 线条颜色
	 * @param {boolean} [parameters.vertexColors] 是否启用顶点颜色
	 * @param {string} [parameters.mapSrc] 纹理贴图路径
	 * @param {number} [parameters.mapGap=50] 纹理贴图间隔(相对于线宽的倍数)
	 * @param {number} [parameters.opacity=1] 透明度
	 * @param {number} [parameters.alphaTest=0] 开启透明剔除，透明度小于该值的部分都不渲染，默认为0
	 * @param {boolean} [parameters.dashed] 是否启用虚线
	 * @param {number} [parameters.dashArray] 虚线段长度
	 * @param {number} [parameters.dashOffset] 虚线偏移量
	 * @param {number} [parameters.dashRatio] 实心部分占每段长度的占比
	 * @param {boolean} [parameters.enableAnimation] 是否启用动画
	 * @param {boolean} [parameters.enableAnimationChaos] 是否开启不规则动画
	 * @param {number} [parameters.animationInterval] 动画重复间隔比例, 值越大，重复之间的间隔越大，0表示不重复
	 * @param {number} [parameters.animationSpeed] 动画速度
	 * @param {1|2} [parameters.animationTailType] 动画尾迹类型(1:比例长度 2:固定长度), 1按线长度比例，需设置`animationTailRatio`属性，2按固定长度，需设置`animationTailLength`属性
	 * @param {number} [parameters.animationTailRatio] 动画尾迹长度比例
	 * @param {number} [parameters.animationTailLength] 动画尾迹固定长度
	 * @param {number} [parameters.animationIdle] 动画空闲时间(毫秒)
	 * @param {boolean} [parameters.transparent] 是否启用透明
	 * @param {boolean} [parameters.antialias] 是否启用抗锯齿
	 * @param {number} [parameters.raycastBuffer] 拾取缓冲区，上调该值，拾取范围会变大，默认为0
	 * @param {boolean} [parameters.isCurve] 是否自动生成贝塞尔曲线数据，线坐标中除了首尾点之外的点会失效，只取线数据的首尾点生成3D贝塞尔曲线
	 */
	constructor(parameters: {
		lineWidth?: number;
		height?: number;
		keepSize?: boolean;
		color?: string;
		vertexColors?: boolean;
		mapSrc?: string;
		mapGap?: number;
		opacity?: number;
		alphaTest?: number;
		dashed?: boolean;
		dashArray?: number;
		dashOffset?: number;
		dashRatio?: number;
		enableAnimation?: boolean;
		enableAnimationChaos?: boolean;
		animationInterval?: number;
		animationSpeed?: number;
		animationTailType?: 1 | 2;
		animationTailRatio?: number;
		animationTailLength?: number;
		animationIdle?: number;
		transparent?: boolean;
		antialias?: boolean;
		raycastBuffer?: number;
		isCurve?: boolean;
	});
	isEventEntitySupported: boolean;
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/**
	 * 是否保持像素宽度
	 * @type {boolean}
	 */
	keepSize: boolean;
	/**
	 * 线条颜色, 默认为#00ffff
	 * @type {string}
	 */
	color: string;
	/**
	 * 纹理贴图路径
	 * @type {string}
	 */
	mapSrc: string;
	/**
	 * 透明度, 默认为1
	 * @type {number}
	 */
	opacity: number;
	/**
	 * 开启透明剔除，透明度小于该值的部分都不渲染，默认为0
	 * @type {number}
	 */
	alphaTest: number;
	/**
	 * 是否启用虚线, 默认为false
	 * @type {boolean}
	 */
	dashed: boolean;
	/**
	 * 虚线段长度(实线和虚线部分总长度), 默认为20
	 * @type {number}
	 */
	dashArray: number;
	/**
	 * 虚线偏移量, 默认值为0
	 * @type {number}
	 */
	dashOffset: number;
	/**
	 * 虚线实线部分比例, 默认值为0
	 * @type {number}
	 */
	dashRatio: number;
	/**
	 * 是否启用动画, 默认为false
	 * @type {boolean}
	 */
	enableAnimation: boolean;
	/**
	 * 是否开启不规则动画, 默认为false
	 * @type {boolean}
	 */
	enableAnimationChaos: boolean;
	/**
	 * 动画速度, 默认值为1
	 * @type {number}
	 */
	animationSpeed: number;
	/**
	 * 动画尾迹类型, 1按线长度比例，2按固定长度
	 * @type {1|2}
	 */
	animationTailType: 1 | 2;
	/**
	 * 动画尾迹长度比例(尾迹长度占整条线的长度比例), 默认值为0.2
	 * @type {number}
	 */
	animationTailRatio: number;
	/**
	 * 动画尾迹固定长度, 默认值为100
	 * @type {number}
	 */
	animationTailLength: number;
	/**
	 * 动画间隔时间(毫秒), 默认值为1000
	 * @type {number}
	 */
	animationIdle: number;
	parameters: {
		lineWidth?: number;
		height?: number;
		keepSize?: boolean;
		color?: string;
		vertexColors?: boolean;
		mapSrc?: string;
		mapGap?: number;
		opacity?: number;
		alphaTest?: number;
		dashed?: boolean;
		dashArray?: number;
		dashOffset?: number;
		dashRatio?: number;
		enableAnimation?: boolean;
		enableAnimationChaos?: boolean;
		animationInterval?: number;
		animationSpeed?: number;
		animationTailType?: 1 | 2;
		animationTailRatio?: number;
		animationTailLength?: number;
		animationIdle?: number;
		transparent?: boolean;
		antialias?: boolean;
		raycastBuffer?: number;
		isCurve?: boolean;
	};
	raycastBuffer: number;
	afterGeometryUpdate(): void;
	makeGeometryOffsetPosition: (geometry: any) => void;
	computeViewportTransformation(viewport: any, near: any, far: any, matrix: any): any;
	onBeforeScenePrepareRenderHook(): void;
	/**
	 * 设置线宽
	 */
	set lineWidth(value: number);
	/**
	 * 获取或设置线宽
	 * @type {number}
	 */
	get lineWidth(): number;
}
/**
 * 折线，支持普通折线和贴地折线两种渲染模式。
 * 通过代理模式将属性和方法调用转发到内部对象，支持动态切换渲染模式。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建普通折线（屏幕空间线）
 * const polyline = engine.add(new mapvthree.Polyline({
 *     flat: false,
 *     color: 0xff0000,
 *     lineWidth: 2
 * }));
 *
 * // 创建贴地折线（XY平面拉伸）
 * const fatLine = engine.add(new mapvthree.Polyline({
 *     flat: true,
 *     color: 0x00ff00,
 *     lineWidth: 5
 * }));
 * ```
 */
export class Polyline extends Group<import("three").Object3DEventMap> {
	/**
	 * 构造函数
	 * @param {Object} parameters 配置参数
	 * @param {boolean} [parameters.flat=false] 是否使用贴地模式，true为贴地折线（XY平面拉伸），false为普通折线（屏幕空间拉伸）
	 *
	 * @param {string} [parameters.color] 线条颜色，支持十六进制颜色值或颜色名称，默认为#00ffff
	 * @param {number} [parameters.lineWidth] 线条宽度，默认为4
	 * @param {number} [parameters.height] 线条高度，用于3D效果
	 * @param {number} [parameters.opacity] 透明度，取值范围0-1，默认为1
	 * @param {number} [parameters.alphaTest] 透明度测试阈值，小于该值的像素将被剔除，默认为0
	 * @param {boolean} [parameters.vertexColors] 是否使用顶点颜色，当为true时可通过数据源设置每个点的颜色
	 * @param {string} [parameters.emissive] 自发光颜色，支持十六进制颜色值
	 * @param {string} [parameters.map] 纹理贴图路径，支持图片文件路径
	 * @param {boolean} [parameters.dashed] 是否渲染虚线，默认为false
	 * @param {number} [parameters.dashArray] 每段虚线（实心加空心部分）的长度，默认为20
	 * @param {number} [parameters.dashOffset] 虚线起始绘制部分的偏移，默认为0
	 * @param {number} [parameters.dashRatio] 实心部分占每段长度的占比，默认为0.5
	 * @param {boolean} [parameters.isCurve] 是否自动生成贝塞尔曲线数据，默认为false
	 */
	constructor(parameters?: {
		flat?: boolean;
		color?: string;
		lineWidth?: number;
		height?: number;
		opacity?: number;
		alphaTest?: number;
		vertexColors?: boolean;
		emissive?: string;
		map?: string;
		dashed?: boolean;
		dashArray?: number;
		dashOffset?: number;
		dashRatio?: number;
		isCurve?: boolean;
	});
}
export class FatLine extends Polyline {
	constructor(parameters: any);
}
/**
 * 墙体网格对象，用于在地图上创建无厚度的墙体效果。支持自定义高度、颜色、纹理和动画效果。
 *
 * @category Objects
 * @example
 * ```javascript
 * // 创建一个基础墙体
 * const wall = engine.add(new mapvthree.Wall({
 *     height: 200,
 *     color: '#00ffff',
 *     opacity: 0.8
 * }));
 *
 * // 设置数据源
 * const data = mapvthree.GeoJSONDataSource.fromGeoJSON([{
 *     type: 'Feature',
 *     geometry: {
 *         type: 'LineString',
 *         coordinates: [[116.404, 39.915], [116.405, 39.920]]
 *     }
 * }]);
 * wall.dataSource = data;
 *
 * // 添加动画效果
 * wall.enableAnimation = true;
 * wall.animationTailType = 3;
 * wall.animationSpeed = 1;
 * ```
*/
export class Wall extends GeoMesh {
	/**
	* 构造函数
	* @param {Object} parameters 配置参数
	* @param {number} [parameters.height=100] 墙的高度, 默认100
	* @param {string} [parameters.color='#00ffff'] 墙的颜色, 默认#00ffff
	* @param {boolean} [parameters.vertexColors=false] 是否通过数据携带颜色配置, 默认false
	* @param {string} [parameters.map] 纹理贴图的路径
	* @param {number|Array<number>} [parameters.mapScale=1] 纹理贴图的缩放系数, 默认1
	* @param {number} [parameters.opacity=1] 墙的整体透明系数, 默认1
	* @param {number} [parameters.minOpacity=0] 墙的最低透明度, 默认0
	* @param {number} [parameters.maxOpacity=1] 墙的最高透明度, 默认1
	* @param {boolean} [parameters.enableAnimation=false] 是否开启墙动画, 默认false
	* @param {number} [parameters.animationSpeed=1] 动画速度, 默认1
	* @param {number} [parameters.animationTailType=3] 动画类型, 默认3
	* @param {number} [parameters.animationTailRatio=0.2] 拖尾动画长度比例, 默认0.2
	* @param {number} [parameters.animationTailLength=100] 拖尾动画真实长度, 默认100
	* @param {number} [parameters.animationIdle=1000] 拖尾动画间隔时间, 默认1000
	* @param {number} [parameters.animationRatio=0.5] 条纹上升动画一组实虚线中实线所占比，范围0-1之间，仅在animationTailType=4.0时生效, 默认0.5
	* @param {number} [parameters.animationBales=5] 条纹上升动画显示组数，值大于等于1，仅在animationTailType=4.0时生效, 默认5
	*/
	constructor(parameters: {
		height?: number;
		color?: string;
		vertexColors?: boolean;
		map?: string;
		mapScale?: number | Array<number>;
		opacity?: number;
		minOpacity?: number;
		maxOpacity?: number;
		enableAnimation?: boolean;
		animationSpeed?: number;
		animationTailType?: number;
		animationTailRatio?: number;
		animationTailLength?: number;
		animationIdle?: number;
		animationRatio?: number;
		animationBales?: number;
	});
	/** @protected */ protected geometry: any;
	/** @protected */ protected material: any;
	/**
	 * 墙的高度
	 * @type {number}
	 * @default 100
	 * @example
	 * ```javascript
	 * wall.height = 200;
	 * ```
	*/
	height: number;
	/**
	 * 墙的颜色
	 * @type {string}
	 * @default '#00ffff'
	 * @example
	 * ```javascript
	 * wall.color = '#ff0000';
	 * ```
	*/
	color: string;
	/**
	 * 是否通过数据携带颜色配置
	 * @type {boolean}
	 * @default false
	 * @example
	 * ```javascript
	 * wall.vertexColors = true;
	 * ```
	*/
	vertexColors: boolean;
	/**
	 * 纹理贴图的路径
	 * @type {string}
	 * @default null
	 * @example
	 * ```javascript
	 * wall.map = 'path/to/texture.png';
	 * ```
	*/
	map: string;
	/**
	* 墙的整体透明系数
	* @type {number}
	* @default 1
	* @example
	* ```javascript
	* wall.opacity = 0.8;
	* ```
	*/
	opacity: number;
	/**
	* 墙的最低透明度
	* @type {number}
	* @default 0
	* @example
	* ```javascript
	* wall.minOpacity = 0.2;
	* ```
	*/
	minOpacity: number;
	/**
	* 墙的最高透明度
	* @type {number}
	* @default 1
	* @example
	* ```javascript
	* wall.maxOpacity = 0.9;
	* ```
	*/
	maxOpacity: number;
	/**
	* 是否开启墙动画
	* @type {boolean}
	* @default false
	* @example
	* ```javascript
	* wall.enableAnimation = true;
	* ```
	*/
	enableAnimation: boolean;
	/**
	* 动画速度
	* @type {number}
	* @default 1
	* @example
	* ```javascript
	* wall.animationSpeed = 2;
	* ```
	*/
	animationSpeed: number;
	/**
	* 动画类型
	* - 1: 按墙长度比例，需设置`animationTailRatio`属性
	* - 2: 按固定长度，需设置`animationTailLength`属性
	* - 3: 垂直方向动画
	* - 4: 条纹上升动画
	* @type {1|2|3|4}
	* @default 3
	* @example
	* ```javascript
	* // 设置为垂直方向动画
	* wall.animationTailType = 3;
	* ```
	*/
	animationTailType: 1 | 2 | 3 | 4;
	/**
	* 拖尾动画长度比例
	* @type {number}
	* @default 0.2
	* @example
	* ```javascript
	* wall.animationTailRatio = 0.3;
	* ```
	*/
	animationTailRatio: number;
	/**
	 * 拖尾动画真实长度
	 * @type {number}
	 * @default 100
	 * @example
	 * ```javascript
	 * wall.animationTailLength = 200;
	 * ```
	 */
	animationTailLength: number;
	/**
	* 拖尾动画间隔时间，单位：毫秒
	* @type {number}
	* @default 1000
	* @example
	* ```javascript
	* wall.animationIdle = 2000;
	* ```
	*/
	animationIdle: number;
	/**
	 * 条纹上升动画一组实虚线中实线所占比
	 * @type {number}
	 * @default 0.5
	 * @example
	 * ```javascript
	 * wall.animationRatio = 0.7;
	 * ```
	 */
	animationRatio: number;
	/**
	* 条纹上升动画显示组数
	* @type {number}
	* @default 5
	* @example
	* ```javascript
	* wall.animationBales = 3;
	* ```
	*/
	animationBales: number;
	parameters: {
		height?: number;
		color?: string;
		vertexColors?: boolean;
		map?: string;
		mapScale?: number | Array<number>;
		opacity?: number;
		minOpacity?: number;
		maxOpacity?: number;
		enableAnimation?: boolean;
		animationSpeed?: number;
		animationTailType?: number;
		animationTailRatio?: number;
		animationTailLength?: number;
		animationIdle?: number;
		animationRatio?: number;
		animationBales?: number;
	};
}
export class GLTFLoader extends Loader<any, string> {
	constructor(manager: any);
	dracoLoader: any;
	ktx2Loader: any;
	meshoptDecoder: any;
	forceUnlit: boolean;
	pluginCallbacks: any[];
	load(url: any, onLoad: any, onProgress: any, onError: any): void;
	setForceUnlit(value: any): this;
	setDRACOLoader(dracoLoader: any): this;
	setDDSLoader(): void;
	setKTX2Loader(ktx2Loader: any): this;
	setMeshoptDecoder(meshoptDecoder: any): this;
	register(callback: any): this;
	unregister(callback: any): this;
	parse(data: any, path: any, onLoad: any, onError: any): void;
	parseAsync(data: any, path: any): Promise<any>;
}
/**
 * 增强的GLTF加载器，支持Meshopt、DRACO和KTX2等扩展。
 *
 * 已实例化，可直接使用。
 *
 * @example
 * ```javascript
 * const loader = mapvthree.gltfLoader;
 * loader.load(url, (gltf) => {
 *     console.log(gltf);
 * });
 * ```
 */
export let gltfLoader: GLTFLoader;
/**
 * 水体材质，用于模拟真实的水面效果。
 *
 * 支持水下折射、岸边泡沫、菲涅耳反射、水体深度渐变、焦散等复杂水面光照效果。
 *
 * @category Materials
 * @example
 * ```javascript
 * const waterMaterial = new mapvthree.WaterMaterial({
 *     waterColor: [0.1, 0.3, 0.8],
 *     foamSpeed: 0.05,
 *     depthSoftness: 5,
 * });
 * ```
 */
export class WaterMaterial extends CommonShaderMaterial {
	static instances: Set<any>;
	static hasActiveInstances(): boolean;
	static getActiveInstances(): Set<any>;
	/**
	 * 构造函数
	 * @param {Object} parameters 材质参数
	 * @param {Array<number>} [parameters.waterColor] 水体的主颜色（深水区域颜色），默认为[1/255, 46/255, 120/255]
	 * @param {number} [parameters.foamSpeed] 泡沫流动速度，默认为0.050
	 * @param {number} [parameters.offsetScale] 波浪扰动高度偏移，默认为1
	 * @param {number} [parameters.depthSoftness] 水深渐变过渡，默认为5
	 * @param {number} [parameters.foamDepthSoftness] 泡沫在水深维度上的衰减程度，默认为1
	 * @param {number} [parameters.foamSoftness] 泡沫边缘模糊程度，默认为3
	 * @param {number} [parameters.foamScale] 泡沫贴图缩放比例，默认为100
	 * @param {number} [parameters.crestFoam] 波峰泡沫判断阈值，范围0-1，默认为0.70
	 * @param {Array<number>} [parameters.crestFoamColor] 波峰泡沫颜色，默认为[0.3, 0.3, 0.6]
	 * @param {number} [parameters.specularStrength] 高光闪耀强度，默认为1.5
	 * @param {number} [parameters.uvScale] UV缩放比例，默认为1000.0
	 * @param {boolean} [parameters.useEnvMap] 是否使用环境贴图，默认为true
	 * @param {number} [parameters.timeScaleFactor] 时间缩放因子，默认为0.001
	 */
	constructor(parameters?: {
		waterColor?: Array<number>;
		foamSpeed?: number;
		offsetScale?: number;
		depthSoftness?: number;
		foamDepthSoftness?: number;
		foamSoftness?: number;
		foamScale?: number;
		crestFoam?: number;
		crestFoamColor?: Array<number>;
		specularStrength?: number;
		uvScale?: number;
		useEnvMap?: boolean;
		timeScaleFactor?: number;
	});
	fragmentShader: any;
	isWaterMaterial: boolean;
	/**
	 * 设置水系样式，默认为lake
	 * @param {'river'|'lake'|'ocean'} style 样式名称，只接受'river', 'lake', 'ocean'
	 */
	set style(style: "river" | "lake" | "ocean");
	/**
	 * 水体样式
	 * @type {string}
	 */
	get style(): string;
	/**
	 * 设置水体的主颜色（深水区域颜色）
	 * @param {Array<number>} value RGB颜色数组，范围0-1
	 */
	set waterColor(value: Array<number>);
	/**
	 * 水体的主颜色（深水区域颜色）
	 * @type {Array<number>}
	 */
	get waterColor(): Array<number>;
	/**
	 * 设置泡沫的流动速度
	 * @param {number} value 泡沫流动速度
	 */
	set foamSpeed(value: number);
	/**
	 * 控制泡沫的流动速度（用于 `tFoamNoise` 采样偏移）
	 * @type {number}
	 */
	get foamSpeed(): number;
	/**
	 * 设置波浪扰动高度偏移
	 * @param {number} value 波浪扰动高度偏移
	 */
	set offsetScale(value: number);
	/**
	 * 控制波浪扰动高度偏移，默认为1
	 * @type {number}
	 */
	get offsetScale(): number;
	/**
	 * 设置水深渐变过渡
	 * @param {number} value 水深渐变过渡值
	 */
	set depthSoftness(value: number);
	/**
	 * 控制水深渐变过渡，默认为5
	 * @type {number}
	 */
	get depthSoftness(): number;
	/**
	 * 设置泡沫在水深维度上的衰减程度
	 * @param {number} value 泡沫深度衰减值
	 */
	set foamDepthSoftness(value: number);
	/**
	 * 控制泡沫在水深维度上的衰减程度，泡沫从深度为0到foamDepthSoftness范围衰减，默认为1
	 * @type {number}
	 */
	get foamDepthSoftness(): number;
	/**
	 * 设置泡沫边缘模糊的程度
	 * @param {number} value 泡沫边缘模糊值
	 */
	set foamSoftness(value: number);
	/**
	 * 控制泡沫边缘模糊的程度
	 * @type {number}
	 */
	get foamSoftness(): number;
	/**
	 * 设置泡沫贴图缩放比例
	 * @param {number} value 泡沫贴图缩放比例
	 */
	set foamScale(value: number);
	/**
	 * 控制泡沫贴图缩放比例，默认为100
	 * @type {number}
	 */
	get foamScale(): number;
	/**
	 * 设置波峰泡沫的判断阈值
	 * @param {number} value 波峰泡沫阈值，范围0-1
	 */
	set crestFoam(value: number);
	/**
	 * 控制波峰泡沫的判断阈值，1最大，默认0.7
	 * @type {number}
	 */
	get crestFoam(): number;
	/**
	 * 设置波峰泡沫颜色
	 * @param {Array<number>} value RGB颜色数组，范围0-1
	 */
	set crestFoamColor(value: Array<number>);
	/**
	 * 波峰泡沫颜色
	 * @type {Array<number>}
	 */
	get crestFoamColor(): Array<number>;
	/**
	 * 设置高光闪耀强度
	 * @param {number} value 高光强度值
	 */
	set specularStrength(value: number);
	/**
	 * 高光闪耀强度
	 * @type {number}
	 */
	get specularStrength(): number;
	/**
	 * 设置UV缩放比例
	 * @param {number} value UV缩放比例
	 */
	set uvScale(value: number);
	/**
	 * UV缩放比例
	 * @type {number}
	 */
	get uvScale(): number;
	defines: {
		CUBEUV_TEXEL_WIDTH: number;
		CUBEUV_TEXEL_HEIGHT: number;
		CUBEUV_MAX_MIP: string;
	};
	onBeforeRender: (renderer: any, scene: any, camera: any, geometry: any, object: any) => void;
	/**
	 * 渲染前的处理函数，更新相机和渲染状态相关的uniforms
	 * @param {Engine} engine 引擎实例
	 * @param {Scene} scene 场景对象
	 * @param {Camera} camera 相机对象
	 * @param {Object} renderState 渲染状态
	 * @protected
	 */
	protected onBeforeSceneRender(engine: Engine, scene: Scene, camera: Camera, renderState: any): void;
	engine: Engine;
	/**
	 * 设置是否使用环境贴图
	 * @param {boolean} value 是否启用环境贴图
	 */
	set useEnvMap(value: boolean);
	/**
	 * 是否使用环境贴图
	 * @type {boolean}
	 */
	get useEnvMap(): boolean;
	/**
	 * 设置时间缩放因子
	 * @param {number} value 时间缩放因子
	 */
	set timeScaleFactor(value: number);
	/**
	 * 时间缩放因子
	 * @type {number}
	 */
	get timeScaleFactor(): number;
	normalMap: any;
}
export class ExtendMeshStandardMaterial extends ShaderMaterial {
	constructor(parameters: any);
	type: string;
	isMeshStandardMaterial: boolean;
	defines: {
		STANDARD: string;
	};
	defineMaterialNormalProperties: (obj: any, props?: any[]) => void;
	defineMaterialAliasProperties: (obj: any, props?: any[]) => void;
	color: Color;
	roughness: number;
	metalness: number;
	map: any;
	lightMap: any;
	lightMapIntensity: number;
	aoMap: any;
	aoMapIntensity: number;
	emissive: Color;
	emissiveIntensity: number;
	emissiveMap: any;
	bumpMap: any;
	bumpScale: number;
	normalMap: any;
	normalMapType: 0;
	normalScale: Vector2;
	displacementMap: any;
	displacementScale: number;
	displacementBias: number;
	roughnessMap: any;
	metalnessMap: any;
	alphaMap: any;
	envMap: any;
	envMapIntensity: number;
	envMapRotation: Euler;
	refractionRatio: number;
	wireframeLinecap: string;
	wireframeLinejoin: string;
	flatShading: boolean;
	set vertexShaderChunks(chunks: any);
	set fragmentShaderChunks(chunks: any);
	getShaderSource: (fromSource: any, defaultChunks: any, chunks: any, shaderName: any) => any;
	setCommonUniforms: (uniforms: any) => void;
}
declare function getBaseUrl(): any;
declare function getAssetUrl(...args: any[]): string;
declare function getAbsoluteUri(relative: any, base: any): any;
declare function getExtensionFromUri(uri: any): any;
declare function getBaseUri(uri: any, includeQuery: any): string;
declare function getGeoFeatures(data: any, projection: any): any;
declare function projectArrayCoordinates(coordinates: Array<number>, projection: any): any;
declare function unprojectArrayCoordinates(coordinates: Array<number>, projection: any): any;
declare function transformArrayCoordinates(coordinates: any, sourceCoordType: any, targetCoordType: any): any;
declare function fixFeature(feature: object): any;
declare function multiPointToPoints(feature: object, projectionName: string): any[];
declare function multiLineStringToLineStrings(feature: object, projectionName: string): any[];
declare function multiPolygonToPolygons(feature: object, projectionName: string): any[];
declare function convertLineString2Points(geojson: object): any[];
declare function convertPolygon2LineString(geojson: object): any[];
declare function coordEach(geojson: object, callback: Function, excludeWrapCoord: boolean): boolean;
declare function geomEach(geojson: object, callback: Function): boolean;
declare function featureEach(geojson: object, callback: Function): void;
declare function geomReduce(geojson: object, callback: Function, initialValue: any): any;
declare function getbbox(geojson: object, options?: {
	recompute: boolean;
}): any;
declare function getCoord(coords: object | any[]): any[];
declare function getGeom(geojson: any): any;
declare function inBBox(pt: Array<number>, bbox: Array<number>): boolean;
declare function booleanPointInPolygon(point: Array<number>, polygon: object, options?: object): boolean;
declare function feature(geom: object, properties: object, options?: object): {
	type: string;
};
declare function featureCollection(features: object, options?: {
	id: number;
	bbox: Array<number>;
}): object;
declare function coordToPoint(coordinates: any[], properties: object, options?: object): object;
declare function coordToLineString(coordinates: any, properties: any, options?: {}): {
	type: string;
};
declare function coordToPolygon(coordinates: any[], properties: object, options?: object): object;
declare function computeGeoJSONArea(geojson: object): number;
declare function getcenter(geojson: object, options?: object): object;
declare function isLngLatArrValid(lnglat: any): boolean;
declare function colorToArr4(params: number | string): number[];
declare function colorToRgbaArr(params: any): number[];
declare function normalizeColor(params: number | string): number[];
declare function convertSRGBColor(params: number | string): Color | Vector4;
declare function rgb565torgb(rgb565: any): number[];
declare function parseLODModel(scenes: object, normalize: boolean, toZUp: boolean): Array<object>;
declare function parseScene(scene: Object3D, normalize: boolean, toZUp: boolean): Array<object>;
declare function reFetch(url?: string, fetchOptions?: object, times?: number): any;
declare function jsonp(url: string, param: any, options?: {}): boolean;
declare function defer(): defer.deferred;
declare function request(url: any, config: any): Promise<any>;
declare function get(url: any): Promise<any>;
declare function post(url: any, data: any): Promise<any>;
declare function isObject(item: any): boolean;
declare function isNumber(num: any): boolean;
declare function defined(value: any): boolean;
declare function defaultValue(a: any, b: any): any;
declare namespace defaultValue {
	let EMPTY_OBJECT: Readonly<{}>;
	let EMPTY_MAT4: Readonly<Matrix4>;
}
declare function deepMerge(target: any, ...sources: any[]): any;
declare function clone(object: any, deep?: boolean): any;
declare function combine(object1: any, object2: any, deep: any): {};
/**
 * 4326坐标系
 */
export const PROJECTION_GEO: "EPSG:4326";
/**
 * 3857坐标系
 */
export const PROJECTION_WEB_MERCATOR: "EPSG:3857";
/**
 * 4978坐标系，也称为ECEF坐标系
 */
export const PROJECTION_ECEF: "EPSG:4978";
/**
 * 百度墨卡托坐标系
 */
export const PROJECTION_BD_MERCATOR: "BD:MERCATOR";
/**
 * UTM坐标系
 */
export const PROJECTION_UTM: "UTM";
/**
 * 等地球坐标系
 */
export const PROJECTION_EQUAL_EARTH: "EPSG:8857";
/**
 * 屏幕像素坐标系
 */
export const PROJECTION_SCREEN_PIXEL: "SCREEN_PIXEL";
/**
 * 点几何类型
 */
export const GEOMETRY_TYPE_POINT: 1;
/**
 * 线几何类型
 */
export const GEOMETRY_TYPE_LINE: 2;
/**
 * 面几何类型
 */
export const GEOMETRY_TYPE_POLYGON: 3;
export const RENDER_STAGE_PREPARE: 0;
export const RENDER_STAGE_SCENE: 10;
export const RENDER_STAGE_BLOOM: 11;
export const RENDER_STAGE_FEATURES: 20;
export const RENDER_STAGE_POSTPROCESSING: 30;
/**
 * 百度地图配置
 * @category MapView
 */
export class BaiduMapConfig {
	/**
	 * 百度地图AK，所有百度地图服务都需要使用该AK。获取方式：https://lbsyun.baidu.com/apiconsole/key
	 */
	static set ak(value: any);
	static get ak(): any;
}
/**
 * Cesium配置
 * @category MapView
 */
export class CesiumConfig {
	/**
	 * Cesium accessToken。获取方式：https://ion.cesium.com/tokens
	 */
	static accessToken: any;
}
/**
 * mapbox配置
 * @category MapView
 */
export class MapboxConfig {
	/**
	 * mapbox accessToken。获取方式：https://console.mapbox.com/account/access-tokens/
	 */
	static accessToken: any;
}
/**
 * 天地图配置
 * @category MapView
 */
export class TiandituConfig {
	/**
	 * 天地图token。获取方式：https://console.tianditu.gov.cn/api/key
	 */
	static tk: any;
}

declare namespace objectUtils {
	export { clone, combine, deepMerge, defaultValue, defined, isNumber, isObject };
}
declare namespace mapViewConstants {
	export { BING_MAP_STYLE_AERIAL, BING_MAP_STYLE_AERIAL_WITH_LABELS, BING_MAP_STYLE_ROAD, MAP_GRID_NAME_BD_LANE_VECTOR, MAP_GRID_NAME_BD_VECTOR_OFFLINE, MAP_GRID_NAME_BD_VECTOR_ONLINE, MAP_GRID_NAME_GEO, MAP_GRID_NAME_WEB_MERCATOR, STADIA_MAP_STYLE_ALIDE_SMOOTH, STADIA_MAP_STYLE_ALIDE_SMOOTH_DARK, STADIA_MAP_STYLE_OUTDOORS, STADIA_MAP_STYLE_STAMEN_TONER, STADIA_MAP_STYLE_STAMEN_WATERCOLOR, TILELOADER_STRATEGY_FAST, TILELOADER_STRATEGY_HIERARCHICAL };
}
declare namespace services {
	export { API_SOURCE_BAIDU, API_SOURCE_TIANDITU, AutoComplete, Boundary, DistrictLayer, DrivingRoute, Geocoder, LocalSearch, RidingRoute, TransitRoute, WalkingRoute, getApiSource, setApiSource };
}
declare namespace twinConstants {
	export { MINIMALIST_TEMPLATE_MODEL, REALISTIC_TEMPLATE_COLOR, REALISTIC_TEMPLATE_MODEL, SERVICE_TEMPLATE_MODEL };
}
declare namespace urlUtils {
	export { getAbsoluteUri, getAssetUrl, getBaseUri, getBaseUrl, getExtensionFromUri };
}
declare namespace geojsonUtils {
	export { booleanPointInPolygon, computeGeoJSONArea, convertLineString2Points, convertPolygon2LineString, coordEach, coordToLineString, coordToPoint, coordToPolygon, feature, featureCollection, featureEach, fixFeature, geomEach, geomReduce, getCoord, getGeoFeatures, getGeom, getbbox, getcenter, inBBox, isLngLatArrValid, multiLineStringToLineStrings, multiPointToPoints, multiPolygonToPolygons, projectArrayCoordinates, transformArrayCoordinates, unprojectArrayCoordinates };
}
declare namespace colorUtils {
	export { colorToArr4, colorToRgbaArr, convertSRGBColor, normalizeColor, rgb565torgb };
}
declare namespace modelUtils {
	export { parseLODModel, parseScene };
}
declare namespace requestUtils {
	export { defer, get, jsonp, post, reFetch, request };
}

export {
	DOMPoint$1 as DOMPoint,
	OrbitTracker as RotateTracker,
	Text$1 as Text,
	colorUtils,
	geojsonUtils,
	mapViewConstants,
	modelUtils,
	objectUtils,
	requestUtils,
	services,
	twinConstants,
	urlUtils,
};

export {};