import { author } from '../package.json';
import { BaseEvent } from 'three';
import { Box3 } from 'three';
import { BufferGeometry } from 'three';
import { BufferGeometryEventMap } from 'three';
import { Camera } from 'three';
import { ColorRepresentation } from 'three';
import { Intersection } from 'three';
import { LoadingManager } from 'three';
import { Material } from 'three';
import { Mesh } from 'three';
import { MeshStandardMaterial } from 'three';
import { MeshStandardMaterialParameters } from 'three';
import { NormalBufferAttributes } from 'three';
import { Object3D } from 'three';
import { Object3DEventMap } from 'three';
import { PlaneGeometry } from 'three';
import { Raycaster } from 'three';
import { Texture } from 'three';
import { Vector2 } from 'three';
import { Vector3 } from 'three';
import { version } from '../package.json';

/**
 * 给模型加裙边
 * @param attributes - POSITION and TEXCOOD_0 attributes data
 * @param  triangles - indices array of the mesh geometry
 * @param  skirtHeight - height of the skirt geometry
 * @param  outsideIndices - edge indices from quantized mesh data
 * @returns - geometry data with added skirt
 */
export declare function addSkirt(attributes: AttributesType, triangles: Uint16Array | Uint32Array, skirtHeight: number, outsideIndices?: EdgeIndices): GeometryDataType;

export declare function attachEvent(map: TileMap): void;

/**
 *@description: Define geometry data type
 *@author: 郭江峰
 *@date: 2023-04-06
 */
/**
 * Geometry Attributes type
 */
export declare type AttributesType = {
    position: {
        value: Float32Array;
        size: number;
    };
    texcoord: {
        value: Float32Array;
        size: number;
    };
    normal: {
        value: Float32Array;
        size: number;
    };
};

export { author }

export declare type BoundsType = [number, number, number, number];

/**
 *@description: 时钟工具类，用于计时和性能测量
 *@author: 郭江峰
 *@date: 2023-04-06
 */
/**
 * 时钟类，用于测量时间
 *
 * 用于跟踪时间的类，提供获取 elapsed time 和 delta time 的功能
 */
export declare class Clock {
    /**
     * 如果设置为 true，第一次调用 getDelta() 时会自动启动时钟
     * @type {boolean}
     * @default true
     */
    autoStart: boolean;
    /**
     * 保存最后一次调用 start() 方法时的时间
     * @type {number}
     * @default 0
     */
    startTime: number;
    /**
     * 保存最后一次调用 start()、getElapsedTime() 或 getDelta() 方法时的时间
     * @type {number}
     * @default 0
     */
    oldTime: number;
    /**
     * 时钟运行的总时间（秒）
     * @type {number}
     * @default 0
     */
    elapsedTime: number;
    /**
     * 时钟是否正在运行
     * @type {boolean}
     * @default false
     */
    running: boolean;
    /**
     * 构造函数
     * @param autoStart - 是否在第一次调用 getDelta() 时自动启动时钟，默认值为 true
     */
    constructor(autoStart?: boolean);
    /**
     * 启动时钟。当 autoStart 设置为 true 时，该方法会自动被调用
     */
    start(): void;
    /**
     * 停止时钟
     */
    stop(): void;
    /**
     * 获取时钟已运行的时间（秒）
     * @returns 已运行的时间（秒）
     */
    getElapsedTime(): number;
    /**
     * 获取上一次调用到本次调用之间的时间间隔（秒）
     * @returns 时间间隔（秒）
     */
    getDelta(): number;
}

declare type EdgeIndices = {
    westIndices: Uint16Array | Uint32Array;
    southIndices: Uint16Array | Uint32Array;
    eastIndices: Uint16Array | Uint32Array;
    northIndices: Uint16Array | Uint32Array;
};

/**
 * Geometry Attributes and indices type
 */
export declare type GeometryDataType = {
    attributes: AttributesType;
    indices: Uint16Array | Uint32Array;
};

/**
 * Get bounds to clip image
 * @param clipBounds bounds [minx,miny,maxx,maxy],0-1
 * @param targetSize size to scale
 * @returns startX,StarY,width,height
 */
export declare function getBoundsCoord(clipBounds: [number, number, number, number], targetSize: number): {
    sx: number;
    sy: number;
    sw: number;
    sh: number;
};

/**
 * 取得地形加载器
 * @param dateType 数据类型
 * @returns 加载器
 */
export declare function getDEMLoader<T extends ITileGeometryLoader<BufferGeometry>>(dateType: string): T;

/**
 * 取得影像加载器
 * @param dateType 数据类型
 * @returns 加载器
 */
export declare function getImgLoader<T extends ITileMaterialLoader<Material>>(dateType: string): T;

/**
 * get ground info from an ary
 * @param map
 * @param ray
 * @returns intersect info or undefined(not intersect)
 */
export declare function getLocalInfoFromRay(map: TileMap, ray: Raycaster): LocationInfo | undefined;

/**
 * get ground info from screen coordinate
 * @param camera
 * @param pointer screen coordiante（-0.5~0.5）
 * @returns ground info
 */
export declare function getLocalInfoFromScreen(camera: Camera, map: TileMap, pointer: Vector2): LocationInfo | undefined;

/**
 * get ground info from world coordinate
 * @param worldPosition world coordinate
 * @returns ground info
 */
export declare function getLocalInfoFromWorld(map: TileMap, worldPosition: Vector3): LocationInfo | undefined;

/**
 * Get url and rect for max level tile
 * to load greater than max level from source,  had to load from max level.
 * 因为瓦片数据并未覆盖所有级别瓦片，如MapBox地形瓦片最高只到15级，如果要显示18级以上瓦片，不能从17级瓦片中获取，只能从15级瓦片里截取一部分
 * @param source
 * @param tile
 * @returns max tile url and bounds in  in maxTile
 */
export declare function getSafeTileUrlAndBounds(source: ISource, x: number, y: number, z: number): {
    url: string | undefined;
    clipBounds: [number, number, number, number];
};

/**
 * get sub image in rect from source image
 * @param image source image
 * @bounds  rect (orgin is (0,0), range is (-1,1))
 * @returns sub image
 */
export declare function getSubImage(image: HTMLImageElement, bounds: [number, number, number, number]): OffscreenCanvas;

/**
 * 取得瓦片加载器列表
 * @returns 加载器列表
 */
export declare function getTileLoaders(): {
    imgLoaders: ITileMaterialLoader<Material>[];
    demLoaders: ITileGeometryLoader<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>>[];
};

/**
 * Porjection interface
 */
declare interface IProjection {
    readonly ID: ProjectionType_2;
    readonly mapWidth: number;
    readonly mapHeight: number;
    readonly mapDepth: number;
    readonly lon0: number;
    project(lon: number, lat: number): {
        x: number;
        y: number;
    };
    unProject(x: number, y: number): {
        lon: number;
        lat: number;
    };
    getTileXWithCenterLon(x: number, z: number): number;
    getProjBoundsFromLonLat(bounds: [number, number, number, number]): [number, number, number, number];
    getProjBoundsFromXYZ(x: number, y: number, z: number): [number, number, number, number];
    getLonLatBoundsFromXYZ(x: number, y: number, z: number): [number, number, number, number];
}

/**
 * 数据源接口
 * 所有数据源实现此接口，通过 x/y/z 坐标获取 URL
 */
export declare interface ISource {
    /** 数据类型标识，决定使用哪种加载器处理数据，默认为 "image" */
    dataType: string;
    /** 瓦片服务 URL 模板 */
    url: string;
    /** 数据源的版权信息，用于显示地图版权声明 */
    attribution: string;
    /** 支持的最小缩放级别 */
    minLevel: number;
    /** 支持的最大缩放级别 */
    maxLevel: number;
    /** 投影类型 */
    projectionID: ProjectionType;
    /** 材质透明度，范围 0-1 */
    opacity: number;
    /** 材质是否透明 */
    transparent: boolean;
    /** 是否使用 TMS 瓦片坐标系，默认 false 使用 XYZ，true 使用 TMS */
    isTMS?: boolean;
    /** 数据范围，经纬度格式 [最小经度, 最小纬度, 最大经度, 最大纬度] */
    bounds?: [number, number, number, number];
    /** 投影后的数据范围，内部使用 */
    _projectionBounds: [number, number, number, number];
    /** 根据瓦片坐标获取 URL，可重写自定义 URL 生成逻辑 */
    getUrl(x: number, y: number, z: number, obj?: {
        [name: string]: any;
    }): string | undefined;
    /** 扩展属性 */
    [key: string]: unknown;
}

/**
 * 瓦片几何体加载器接口, 用于加载瓦片地形
 */
export declare interface ITileGeometryLoader<TGeometry extends BufferGeometry = BufferGeometry> {
    /** 加载器信息 */
    info: ITileLoaderInfo;
    /** 数据类型标记 */
    dataType: string;
    /** 加载地形数据 */
    load(params: TileSourceLoadParamsType): Promise<TGeometry>;
}

/**
 * 瓦片加载器接口
 */
export declare interface ITileLoader {
    /** 正在进行的下载线程数量 */
    downloadingThreads: number;
    /** 最大线程数量 */
    maxThreads: number;
    /** 调试级别 */
    debug: number;
    /** 瓦片加载管理器 */
    manager: TileLoadingManager;
    /** 影像数据加载器 */
    imgSource: ISource[];
    /** 地形数据加载器 */
    demSource: ISource | undefined;
    /** 投影ID */
    projectionID: string;
    /** 经纬度范围 */
    bounds: BoundsType;
    /** 加载瓦片数据 */
    load(coord: TileLoadParamsType): Promise<TileMesh>;
    /** 瓦片更新 */
    update(coord: TileLoadParamsType, tileMesh: TileMesh): Promise<void>;
}

/**
 * 瓦片加载器接口
 */
declare interface ITileLoader_2 {
    /** 正在进行的下载线程数量 */
    downloadingThreads: number;
    /** 最大线程数量 */
    maxThreads: number;
    /** 调试级别 */
    debug: number;
    /** 投影ID */
    projectionID: string;
    /** 加载瓦片数据 */
    load(coord: TileCoords_2): Promise<TileMesh_2>;
    /** 更新瓦片 */
    update(coord: TileCoords_2, tileMesh: TileMesh_2): Promise<void>;
}

/**
 * 加载器元数据类型
 */
export declare type ITileLoaderInfo = {
    /** 加载器版本号 */
    version: string;
    /** 加载器作者 */
    author?: string;
    /** 加载器说明 */
    description?: string;
};

declare interface ITileMapLoader extends ITileLoader {
    get projection(): IProjection;
    set projection(projection: IProjection);
}

/**
 * 瓦片材质接口
 */
export declare interface ITileMaterial extends Material {
    map?: Texture | null;
}

/**
 * 瓦片材质加载器接口, 用于加载瓦片影像
 */
export declare interface ITileMaterialLoader<TMaterial extends Material = Material> {
    /** 加载器信息 */
    info: ITileLoaderInfo;
    /** 数据类型标记 */
    dataType: string;
    /**加载影像数据 */
    load(params: TileSourceLoadParamsType): Promise<TMaterial>;
}

/**
 * Factory for loader
 */
export declare const LoaderFactory: {
    manager: TileLoadingManager;
    demLoaderMap: Map<string, ITileGeometryLoader<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>>>;
    imgLoaderMap: Map<string, ITileMaterialLoader<Material>>;
    /**
     * Register material loader
     * @param loader material loader
     */
    registerMaterialLoader(loader: ITileMaterialLoader): void;
    /**
     * Register geometry loader
     * @param loader geometry loader
     */
    registerGeometryLoader(loader: ITileGeometryLoader): void;
    /**
     * Get material loader from datasource
     * @param source datasource
     * @returns material loader
     */
    getMaterialLoader(source: ISource | string): ITileMaterialLoader<Material>;
    /**
     * Get geometry loader from datasource
     * @param source datasource
     * @returns geometry loader
     */
    getGeometryLoader(source: ISource | string): ITileGeometryLoader<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>>;
    /**
     * Get all loaders
     * @returns Image loaders and terrain loaders
     */
    getLoaders(): {
        imgLoaders: ITileMaterialLoader<Material>[];
        demLoaders: ITileGeometryLoader<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>>[];
    };
};

/** 地面信息类型(经度、纬度、高度) */
export declare interface LocationInfo extends Intersection {
    location: Vector3;
}

/** 瓦片 LOD 结果 */
declare enum LODAction {
    none = 0,// 无操作
    create = 1,// 细化
    remove = 2
}

/** 地图创建参数 */
export declare type MapParams = {
    /** 开启调试模式, debug mode: 0: off, 1... */
    debug?: number;
    loader?: TileMapLoader;
    /** 跟瓦片 root tile */
    rootTile?: Tile;
    /** 影像数据源, image source */
    imgSource: ISource[] | ISource;
    /** 高程数据源, terrain source */
    demSource?: ISource;
    /**  地图经纬度范围  */
    bounds?: BoundsType;
    /** 地图最小缩放级别, maximum zoom level of the map */
    minLevel?: number;
    /** 中央子午线经度, map centralMeridian longitude */
    lon0?: ProjectCenterLongitude;
    /** @deprecated  背景色，已废弃，使用background插件 */
    backgroundColor?: ColorRepresentation;
    /** @deprecated  地图最大缩放级别，已废弃，自动根据数据源基本设定 */
    maxLevel?: number;
};

/**
 * Martini mesh tile generator (Mapbox's Awesome Right-Triangulated Irregular Networks, Improved).
 *
 * Represents a height map tile node using the RTIN method from the paper "Right Triangulated Irregular Networks".
 *
 * Based off the library https://github.com/mapbox/martini.
 */
export declare class Martini {
    /**
     * Size of the grid to be generated.
     */
    gridSize: number;
    /**
     * Number of triangles to be used in the tile.
     */
    numTriangles: number;
    /**
     * Number of triangles in the parent node.
     */
    numParentTriangles: number;
    /**
     * Indices of the triangles faces.
     */
    indices: Uint32Array;
    /**
     * Coordinates of the points composing the mesh.
     */
    coords: Uint16Array;
    /**
     * Constructor for the generator.
     *
     * @param gridSize - Size of the grid.
     */
    constructor(gridSize?: number);
    createTile(terrain: Float32Array): MartiniTile;
}

/**
 * Tile geometry
 */
export declare class MartiniGeometry extends TileGeometry {
    type: string;
    /**
     * set attribute data to geometry
     * @param data geometry or DEM data
     * @returns this
     */
    setAttributes(data: GeometryDataType | Float32Array, skirtHeight?: number): this;
}

/**
 * Class describes the generation of a tile using the Martini method.
 */
declare class MartiniTile {
    /**
     * Pointer to the martini generator object.
     */
    martini: Martini;
    /**
     * Terrain to generate the tile for.
     */
    terrain: Float32Array;
    /**
     * Errors detected while creating the tile.
     */
    errors: Float32Array;
    constructor(terrain: Float32Array, martini: Martini);
    update(): void;
    getGeometryData(maxError?: number): GeometryDataType;
    private _getMeshAttributes;
}

/**
 * 点类型
 */
export declare type Point = {
    x: number;
    y: number;
};

/** 地图中央子午线经度类型 */
declare type ProjectCenterLongitude = 0 | 90 | -90;

/**
 *@description: 地图数据源模块
 *@author: 郭江峰
 *@date: 2023-04-05
 */
/** 投影类型 */
export declare type ProjectionType = "3857" | "4326";

/**
 *@description: Map projection interface
 *@author: 郭江峰
 *@date: 2023-04-06
 */
declare type ProjectionType_2 = "3857" | "4326";

/**
 * 注册地形加载器
 * @param loader 要注册的地形加载器
 * @returns 加载器
 */
export declare function registerDEMLoader(loader: ITileGeometryLoader): ITileGeometryLoader<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>>;

/**
 * 注册影像加载器
 * @param loader 要注册的影像加载器
 * @returns 加载器
 */
export declare function registerImgLoader(loader: ITileMaterialLoader): ITileMaterialLoader<Material>;

/**
 * 数据源构造函数参数类型
 */
export declare interface SourceOptions {
    /** 数据类型标识 */
    dataType?: string;
    /** 版权信息 */
    attribution?: string;
    /** 最小缩放级别 */
    minLevel?: number;
    /** 最大缩放级别 */
    maxLevel?: number;
    /** 投影类型 */
    projectionID?: ProjectionType;
    /** 材质透明度 */
    opacity?: number;
    /** 材质是否透明 */
    transparent?: boolean;
    /** 数据范围 */
    bounds?: [number, number, number, number];
    /** URL 模板 */
    url?: string;
    /** URL 子域名数组或字符串，用于负载均衡 */
    subdomains?: string[] | string;
    /** 是否使用 TMS 坐标系 */
    isTMS?: boolean;
    /** 扩展属性 */
    [key: string]: unknown;
}

/**
 * 字符串模板替换函数
 * 将模板字符串中的 {key} 替换为数据对象中对应的值
 * @param str 模板字符串，如 "http://example.com/{z}/{x}/{y}"
 * @param data 数据对象
 * @returns 替换后的字符串
 */
export declare function strTemplate(str: string, data: {
    [name: string]: any;
}): string;

/**
 * Mapbox-RGB geometry loader
 */
export declare class TerrainDEMLoader extends TileGeometryLoader {
    readonly info: {
        version: string;
        description: string;
    };
    readonly dataType = "terrain-dem";
    private imageLoader;
    private _workerPool;
    constructor();
    /**
     * 异步加载BufferGeometry对象
     *
     * @param url 图片的URL地址
     * @param params 加载参数，包含瓦片xyz和裁剪边界clipBounds
     * @returns 返回解析后的BufferGeometry对象
     */
    protected doLoad(url: string, params: TileLoadClipParamsType): Promise<TileGeometry>;
}

/**
 * ArcGis-lerc格式瓦片几何体加载器
 * @link https://github.com/Esri/lerc
 */
export declare class TerrainLercLoader extends TileGeometryLoader {
    readonly info: {
        version: string;
        description: string;
    };
    readonly dataType = "lerc";
    private fileLoader;
    private _workerPool;
    constructor();
    /**
     * 异步加载并解析数据，返回BufferGeometry对象
     *
     * @param url 数据文件的URL
     * @param params 解析参数，包含瓦片xyz和裁剪边界clipBounds
     * @returns 返回解析后的BufferGeometry对象
     */
    protected doLoad(url: string, params: TileLoadClipParamsType): Promise<TileGeometry>;
}

/**
 * Mapbox-RGB geometry loader
 */
export declare class TerrainRGBLoader extends TileGeometryLoader {
    readonly info: {
        version: string;
        description: string;
    };
    readonly dataType = "terrain-rgb";
    private imageLoader;
    private _workerPool;
    constructor();
    /**
     * 异步加载BufferGeometry对象
     *
     * @param url 图片的URL地址
     * @param params 加载参数，包含瓦片xyz和裁剪边界clipBounds
     * @returns 返回解析后的BufferGeometry对象
     */
    protected doLoad(url: string, params: TileLoadClipParamsType): Promise<TileGeometry>;
}

/**
 * 动态LOD（DLOD）地图瓦片类，用于表示地图中的一块瓦片，瓦片可以包含子瓦片，以四叉树方式管理。
 */
export declare class Tile extends Object3D<TTileEventMap> {
    /** 瓦片x坐标 */
    readonly x: number;
    /** 瓦片y坐标 */
    readonly y: number;
    /** 瓦片层级 */
    readonly z: number;
    /** 是否为瓦片 */
    readonly isTile = true;
    /** 瓦片是否正在加载中 */
    private _isLoading;
    /** 根瓦片 */
    private _root;
    private _sizeInWorld;
    /** 瓦片包围盒（世界坐标） */
    private _model?;
    /** 瓦片模型 */
    get model(): TileMesh_2 | undefined;
    private _subTiles;
    /** 子瓦片 */
    get subTiles(): Tile[] | undefined;
    /** 瓦片到相机的距离比例，用于 LOD 评估，值越小瓦片越密集 */
    get distRatio(): number;
    private _inFrustum;
    /** 瓦片是否在视锥体内 */
    get inFrustum(): boolean;
    /** 是否为叶子瓦片 */
    get isLeaf(): boolean;
    /** 取得瓦片是否显示 */
    get showing(): boolean;
    /** 设置瓦片是否显示 */
    set showing(value: boolean);
    /** 是否为脏瓦片 */
    private _isDirty;
    private _needsLoad;
    /**
     * 构造函数
     * @param x - 瓦片X坐标，默认：0
     * @param y - 瓦片Y坐标，默认：0
     * @param z - 瓦片层级，默认：0
     */
    constructor(x?: number, y?: number, z?: number);
    /**
     * 瓦片射线检测，仅检测视锥体中的瓦片
     */
    raycast(_raycaster: Raycaster): boolean;
    /** 计算瓦片包围盒（世界坐标） */
    getBBox(): Box3;
    /**
     * 计算瓦片大小
     * @returns 瓦片对角线长度
     */
    getTileSize(): number;
    /**
     * 瓦片更新，该函数在每帧渲染中被调用
     * @param params 瓦片更新参数，包括相机、加载器、最小层级、最大层级和LOD阈值
     */
    update(params: TileUpdateParames): void;
    /** 更新瓦片阴影 */
    private _updateShadow;
    /**
     * LOD (Level of Detail).
     * @returns add or remove
     */
    protected LOD(params: TileUpdateParames): LODAction;
    /**
     * 瓦片下载完成后，检查4个兄弟瓦片全部下载完成时再显示
     */
    private _checkVisible;
    /**
     * 下载瓦片数据
     * @param loader  - 瓦片加载器
     */
    private _startLoad;
    /**
     * 修改瓦片数据
     * @param loader  - 瓦片加载器
     */
    private _startModify;
    /**
     * 重新加载瓦片数据
     * @param dispose - 是否销毁瓦片树
     * @returns this
     */
    reload(dispose?: boolean): this;
    /**
     * 卸载瓦片 (包括瓦片模型和其子瓦片)，释放资源
     * @returns this
     */
    unload(): this;
    unloadModel(): this;
    unloadSubTiles(): this;
}

/**
 * 将瓦片影像超出mapBounds范围的部分设为透明
 * @param image 原始瓦片图像，类型可以是 OffscreenCanvas 或 HTMLImageElement
 * @param mapBounds 地图范围，格式为 [minX, minY, maxX, maxY]
 * @param tileBounds 瓦片范围，格式为 [minX, minY, maxX, maxY]
 * @returns 处理后的图像，可能是原始图像或处理后的 OffscreenCanvas
 */
export declare function tileBoundsClip(image: OffscreenCanvas | HTMLImageElement, mapBounds: [number, number, number, number], tileBounds: [number, number, number, number]): HTMLImageElement | OffscreenCanvas;

/**
 * Canvas material loader abstract base class
 */
export declare abstract class TileCanvasLoader implements ITileMaterialLoader<ITileMaterial> {
    readonly info: {
        version: string;
        description: string;
    };
    dataType: string;
    /**
     * Asynchronously load tile material
     * @param params Tile loading parameters
     * @returns Returns the tile material
     */
    load(params: TileSourceLoadParamsType): Promise<TileMaterial>;
    private _creatCanvasContext;
    /**
     * Draw tile on canvas, protected
     * @param ctx Tile canvas context
     * @param params Tile load params
     */
    protected abstract drawTile(ctx: OffscreenCanvasRenderingContext2D, params: TileSourceLoadParamsType): void;
}

/**
 * 瓦片坐标类型
 */
export declare type TileCoords = {
    /** 瓦片 X 坐标 */
    x: number;
    /** 瓦片 Y 坐标 */
    y: number;
    /** 瓦片 Z 坐标 */
    z: number;
};

/**
 * 瓦片坐标类型
 */
declare type TileCoords_2 = {
    /** 瓦片 X 坐标 */
    x: number;
    /** 瓦片 Y 坐标 */
    y: number;
    /** 瓦片 Z 坐标 */
    z: number;
};

/**
 * Tile geometry
 */
export declare class TileGeometry extends PlaneGeometry {
    type: string;
    setAttributes(geometryData: GeometryDataType, z?: number): this;
    setData(data: Float32Array, z: number, martini?: boolean): this;
}

/**
 * Terrain loader base class
 */
export declare abstract class TileGeometryLoader implements ITileGeometryLoader<TileGeometry> {
    info: ITileLoaderInfo;
    dataType: string;
    /**
     * load tile's data from source
     * @param source
     * @param tile
     * @param onError
     * @returns
     */
    load(params: TileSourceLoadParamsType): Promise<TileGeometry>;
    /**
     * Download terrain data
     * @param url url
     */
    protected abstract doLoad(url: string, params: TileLoadClipParamsType): Promise<TileGeometry>;
}

/**
 * Tile image loader
 */
export declare class TileImageLoader extends TileMaterialLoader {
    readonly info: {
        version: string;
        description: string;
    };
    dataType: string;
    private loader;
    /**
     * 加载瓦片图像作为纹理
     *
     * @param url 图像资源的URL
     * @param params 加载参数，包括x, y, z坐标、投影范围，裁剪边界clipBounds
     * @returns 返回一个Promise对象，解析为HTMLImageElement类型。
     */
    protected doLoad(url: string, params: TileLoadClipParamsType): Promise<Texture>;
}

/**
 * 瓦片加载参数类型，包括剪裁范围
 */
export declare type TileLoadClipParamsType<TSource extends ISource = ISource> = TileSourceLoadParamsType<TSource> & {
    clipBounds: [number, number, number, number];
};

/**
 * Tile loader
 */
export declare class TileLoader implements ITileLoader {
    private _downloadingThreads;
    /** Map bounds in lonlat, default is world */
    private _bounds;
    get bounds(): BoundsType;
    set bounds(value: BoundsType);
    private _maxThreads;
    /** Get the max downloading threads count*/
    get maxThreads(): number;
    /** Set the max downloading threads count*/
    set maxThreads(value: number);
    /** Get downloading threads count*/
    get downloadingThreads(): number;
    private _imgSource;
    /** Get image source */
    get imgSource(): ISource[];
    /** Set image source */
    set imgSource(value: ISource[]);
    private _demSource;
    /** Get terrain source */
    get demSource(): ISource | undefined;
    /** Set terrain source */
    set demSource(value: ISource | undefined);
    /** Get map prjection ID */
    get projectionID(): ProjectionType;
    /** Loader manager */
    get manager(): TileLoadingManager;
    /** Debug single */
    debug: number;
    /** Error material */
    private readonly _errorMaterial;
    /**
     * Load getmetry and materail of tile from x, y and z coordinate.
     * @param params load params(x,y,z,bounds etc.)
     * @param tileMesh tile mesh
     * @returns Promise<TileMesh> tile mesh
     */
    load(params: TileLoadParamsType): Promise<TileMesh>;
    /**
     * modify tile
     * @param params
     * @param tileMesh
     */
    update(params: TileLoadParamsType, tileMesh: TileMesh): Promise<void>;
    /**
     * Load geometry
     * @returns BufferGeometry
     */
    protected loadGeometry(params: TileLoadParamsType, tileGeometry?: BufferGeometry): Promise<BufferGeometry>;
    /**
     * Load material
     * @param x x coordinate of tile
     * @param y y coordinate of tile
     * @param z z coordinate of tile
     * @returns Material[]
     */
    protected loadMaterial(params: TileLoadParamsType, tileMaterial?: Material[]): Promise<Material[]>;
    /** Clip the material texture from mapBounds */
    private _materialClip;
    /** Check the tile is in the source bounds. */
    private _checkBounds;
}

export declare class TileLoadingManager extends LoadingManager {
    onParseEnd?: (geometry: BufferGeometry) => void;
    parseEnd(geometry: BufferGeometry): void;
}

/**
 * 瓦片加载参数类型，包括瓦片投影范围和经纬度范围
 */
export declare type TileLoadParamsType = TileCoords & {
    /** 瓦片投影范围（或剪裁范围） */
    bounds: BoundsType;
    /** 瓦片经纬度范围 */
    lonLatBounds?: BoundsType;
};

/**
 * 瓦片地图模型
 */
export declare class TileMap extends Object3D<TileMapEventMap> {
    /** 名称 */
    readonly name = "map";
    /** 调试标志，0：不调试 */
    debug: number;
    /** 瓦片树更新时钟 */
    private readonly _mapClock;
    /** 是否为LOD模型（LOD模型，当autoUpdate为真时渲染时会自动调用update方法）*/
    readonly isLOD = true;
    /** 地图是否在每帧渲染时自动更新，默认为真 */
    autoUpdate: boolean;
    /** 瓦片树更新间隔，单位毫秒（默认100ms） */
    updateInterval: number;
    /** 根瓦片 */
    readonly rootTile: Tile;
    /** 瓦片数据加载器 */
    readonly loader: ITileMapLoader;
    private _minLevel;
    /** 取得地图最小缩放级别，小于这个级别瓦片树不再加载数据 */
    get minLevel(): number;
    /** 设置地图最小缩放级别，小于这个级别瓦片树不再加载数据 */
    set minLevel(value: number);
    private _maxLevel;
    /**  地图最大缩放级别，大于这个级别瓦片树不再更新 */
    get maxLevel(): number;
    /** @deprecated 废弃，它会自动根据数据源的最大缩放级别设置 */
    set maxLevel(value: number);
    /** 取得中央子午线经度 */
    get lon0(): number;
    /** 设置中央子午线经度，中央子午线决定了地图的投影中心经度，可设置为-90，0，90，默认为0 */
    set lon0(value: number);
    /** 取得地图投影对象 */
    get projection(): IProjection;
    /** 设置地图投影对象 */
    private set projection(value);
    /** 取得影像数据源 */
    get imgSource(): ISource[];
    /** 设置影像数据源 */
    set imgSource(value: ISource | ISource[]);
    /** 设置地形数据源 */
    get demSource(): ISource | undefined;
    /** 取得地形数据源 */
    set demSource(value: ISource | undefined);
    private _LODThreshold;
    /** 取得LOD阈值	 */
    get LODThreshold(): number;
    /** 设置LOD阈值，LOD阈值越大，瓦片细化，但耗费资源越高，建议取1-2之间，默认为1 */
    set LODThreshold(value: number);
    /** 取得地图经纬度范围 */
    get bounds(): BoundsType;
    /** 设置地图经纬度范围 */
    set bounds(value: BoundsType);
    /** 取得最大线下载程数 */
    get maxThreads(): number;
    /** 设置最大线下载程数 */
    set maxThreads(value: number);
    /** @deprecated 取得背景色 */
    get backgroundColor(): ColorRepresentation;
    /** @deprecated 设置背景色 */
    set backgroundColor(_value: ColorRepresentation);
    /**
     * 地图创建工厂函数
     @param params 地图参数 {@link MapParams}
     @returns map mesh 地图模型
     */
    static create(params: MapParams): TileMap;
    /**
     * 地图模型构造函数
     * @param params 地图参数 {@link MapParams}
     */
    constructor(params: MapParams);
    /**
     * 地图改变大小
     */
    private _resize;
    /**
     * 取得最大缩放级别
     * @returns 最大缩放级别
     */
    private _getMaxLevel;
    /**
     * 模型更新回调函数，地图加入场景后会在每帧更新时被调用，该函数调用根瓦片实现瓦片树更新和数据加载
     * @param camera 摄像机
     */
    update(camera: Camera): void;
    /**
     * 更新地图数据
     */
    private _updateSource;
    /**
     * 销毁全部瓦片并重新加载
     */
    reload(dispose?: boolean): void;
    /**
     * 释放地图资源，并移出场景
     */
    dispose(): void;
    /**
     * 地理坐标转换为地图模型坐标(与geo2map同功能)
     * @param geo 地理坐标（经纬度）
     * @returns 模型坐标
     * @deprecated 废弃. 请使用 geo2map()
     */
    geo2pos(geo: Vector3): Vector3;
    /**
     * 地理坐标转换为地图模型坐标(与geo2pos同功能)
     * @param geo 地理坐标（经纬度）
     * @returns 模型坐标
     */
    geo2map(geo: Vector3): Vector3;
    /**
     * 地理坐标转换为世界坐标
     *
     * @param geo 地理坐标（经纬度）
     * @returns 世界坐标
     */
    geo2world(geo: Vector3): Vector3;
    /**
     * 地图模型坐标转换为地理坐标(与map2geo同功能)
     * @param pos 模型坐标
     * @returns 地理坐标（经纬度）
     * @deprecated 废弃. 请使用 map2geo()
     */
    pos2geo(pos: Vector3): Vector3;
    /**
     * 地图模型坐标转换为地理坐标(与pos2geo同功能)
     * @param map 模型坐标
     * @returns 地理坐标（经纬度）
     */
    map2geo(pos: Vector3): Vector3;
    /**
     * 世界坐标转换为地理坐标
     * @param world 世界坐标
     * @returns 地理坐标（经纬度）
     */
    world2geo(world: Vector3): Vector3;
    /**
     * 获取指定经纬度的地面信息（法向量、高度等）
     * @param geo 地理坐标
     * @returns 地面信息
     */
    getLocalInfoFromGeo(geo: Vector3): LocationInfo | undefined;
    /**
     * 获取指定世界坐标的地面信息
     * @param pos 世界坐标
     * @returns 地面信息
     */
    getLocalInfoFromWorld(pos: Vector3): LocationInfo | undefined;
    /**
     * 获取指定屏幕坐标的地面信息
     * @param camera 摄像机
     * @param pointer 点的屏幕坐标（-0.5~0.5）
     * @returns 位置信息（经纬度、高度等）
     */
    getLocalInfoFromScreen(camera: Camera, pointer: Vector2): LocationInfo | undefined;
    /**
     * 取得当前正在下载的瓦片数量
     */
    get downloading(): number;
    /**
     * 取得地图瓦片状态统计信息
     */
    getTileCount(): {
        total: number;
        leaf: number;
        visible: number;
        inFrustum: number;
        maxLevel: number;
        downloading: number;
    };
}

declare interface TileMapEventMap extends Object3DEventMap {
    update: BaseEvent & {
        delta: number;
    };
    ready: BaseEvent;
    "tile-created": BaseEvent & {
        tile: Tile;
    };
    "tile-loaded": BaseEvent & {
        tile: Tile;
    };
    "tile-unload": BaseEvent & {
        tile: Tile;
    };
    "tile-visible-changed": BaseEvent & {
        tile: Tile;
        visible: boolean;
    };
    "projection-changed": BaseEvent & {
        projection: IProjection;
    };
    "source-changed": BaseEvent & {
        source: ISource | ISource[] | undefined;
    };
    "loading-start": BaseEvent & {
        itemsLoaded: number;
        itemsTotal: number;
    };
    "loading-error": BaseEvent & {
        url: string;
    };
    "loading-complete": BaseEvent;
    "loading-progress": BaseEvent & {
        url: string;
        itemsLoaded: number;
        itemsTotal: number;
    };
    "parsing-end": BaseEvent & {
        url: string;
    };
}

/** 地图瓦片加载器，ITileLoader基础上增加地图投影属性 */
declare class TileMapLoader extends TileLoader implements ITileMapLoader {
    private _projection;
    get imgSource(): ISource[];
    set imgSource(source: ISource[]);
    get demSource(): ISource | undefined;
    set demSource(source: ISource | undefined);
    set bounds(value: BoundsType);
    get bounds(): BoundsType;
    private _updateImgProjBounds;
    private _updateDemPrjBounds;
    get projection(): IProjection;
    set projection(projection: IProjection);
    load(params: TileLoadParamsType): Promise<TileMesh>;
    update(coord: TileLoadParamsType, tileMesh: TileMesh): Promise<void>;
    private _getTileCoords;
}

/**
 * 瓦片材质
 */
export declare class TileMaterial extends MeshStandardMaterial {
    constructor(params?: MeshStandardMaterialParameters);
}

/**
 * Image loader base class
 */
export declare abstract class TileMaterialLoader implements ITileMaterialLoader<ITileMaterial> {
    info: {
        version: string;
        description: string;
    };
    dataType: string;
    private _material;
    /** 取得默认材质 */
    get material(): ITileMaterial;
    /** 设置默认材质 */
    set material(value: ITileMaterial);
    /**
     * Load tile material from source
     * @param source
     * @param tile
     * @returns
     */
    load(params: TileSourceLoadParamsType): Promise<ITileMaterial>;
    /**
     * Create material
     * @returns {ITileMaterial} the material of tile
     */
    createMaterial(_params: TileSourceLoadParamsType): ITileMaterial;
    /**
     * Download terrain data
     * @param url url
     * @returns {Promise<TBuffer>} the buffer of download data
     */
    protected doLoad(_url: string, _params: TileLoadClipParamsType): Promise<Texture | undefined | null>;
}

export declare type TileMesh = Mesh<BufferGeometry, Material[]>;

declare type TileMesh_2 = Mesh<BufferGeometry, Material[]>;

/**
 * 数据源基类
 * 用户可通过继承此类自定义数据源
 */
export declare class TileSource implements ISource {
    /** 数据类型，默认为 "image" */
    dataType: string;
    /** 版权信息，默认为 "ThreeTile" */
    attribution: string;
    /** 最小缩放级别，默认为 0 */
    minLevel: number;
    /** 最大缩放级别，默认为 18 */
    maxLevel: number;
    /** 投影类型，默认为 "3857" 墨卡托投影 */
    projectionID: ProjectionType;
    /** URL 模板 */
    url: string;
    /** 子域名列表，用于负载均衡 */
    subdomains: string[] | string;
    /** 材质透明度，默认为 1.0（不透明） */
    opacity: number;
    /** 材质是否透明，默认为 true */
    transparent: boolean;
    /** 是否使用 TMS 坐标系，默认为 false（使用 XYZ） */
    isTMS: boolean;
    /** 数据范围 [最小经度, 最小纬度, 最大经度, 最大纬度] */
    bounds?: [number, number, number, number];
    /** 投影后的数据范围 */
    _projectionBounds: [number, number, number, number];
    /** 扩展属性 */
    [key: string]: unknown;
    /**
     * 构造函数
     * @param options 数据源配置项
     */
    constructor(options?: SourceOptions);
    /**
     * 计算瓦片的边界框
     * @param x 瓦片 x 坐标
     * @param y 瓦片 y 坐标
     * @param z 瓦片 z 坐标
     * @returns 边界框字符串 "minX,minY,maxX,maxY"
     */
    private _getBBox;
    /**
     * 根据瓦片坐标获取 URL
     * 可重写此方法自定义 URL 生成逻辑
     * @param x 瓦片 x 坐标
     * @param y 瓦片 y 坐标
     * @param z 瓦片 z 坐标
     * @param obj 额外参数
     * @returns 瓦片 URL
     */
    getUrl(x: number, y: number, z: number, obj?: {
        [name: string]: any;
    }): string | undefined;
    /**
     * 工厂方法：创建数据源实例
     * @param options 数据源配置项
     * @returns 数据源实例
     */
    static create(options: SourceOptions): TileSource;
}

/**
 * 瓦片加载参数类型，包括数据源
 */
export declare type TileSourceLoadParamsType<TSource extends ISource = ISource> = TileLoadParamsType & {
    /** 瓦片数据源 */
    source: TSource;
};

/** 瓦片更新参数类型 */
declare type TileUpdateParames = {
    /** 相机 */
    camera: Camera;
    /** 瓦片加载器 */
    loader: ITileLoader_2;
    /** 最小层级 */
    minLevel: number;
    /** 最大层级 */
    maxLevel: number;
    /** 瓦片LOD阈值 */
    LODThreshold: number;
};

/**
 * 瓦片事件映射类型，为了便于使用，所有事件均由根瓦片发出
 */
declare interface TTileEventMap extends Object3DEventMap {
    /** 瓦片创建事件 */
    "tile-created": BaseEvent & {
        tile: Tile;
    };
    /** 瓦片加载完成事件 */
    "tile-loaded": BaseEvent & {
        tile: Tile;
    };
    /** 瓦片卸载事件 */
    "tile-unload": BaseEvent & {
        tile: Tile;
    };
    /** 瓦片可视状态改变事件 */
    "tile-visible-changed": BaseEvent & {
        tile: Tile;
        visible: boolean;
    };
}

/**
 * 矢量特征值
 */
export declare type VectorFeature = {
    geometry: Point[][];
    properties?: Record<string, unknown>;
    size?: number;
};

/**
 * 元素类型
 */
export declare enum VectorFeatureTypes {
    Unknown = 0,
    Point = 1,
    Linestring = 2,
    Polygon = 3
}

/**
 *@description: Vectior tile renderer interface
 *@author: 郭江峰
 *@date: 2023-04-05
 */
/**
 *  瓦片绘图样式，参考leaflet的path样式定义
 */
export declare interface VectorStyle {
    minLevel?: number;
    maxLevel?: number;
    stroke?: boolean | undefined;
    color?: string | undefined;
    weight?: number | undefined;
    opacity?: number | undefined;
    dashArray?: number[] | undefined;
    dashOffset?: string | undefined;
    fill?: boolean | undefined;
    fillColor?: string | undefined;
    font?: string;
    fontColor?: string;
    fontOffset?: [number, number];
    textField?: string;
    fillOpacity?: number | undefined;
    fillRule?: CanvasFillRule | undefined;
    shadowBlur?: number;
    shadowColor?: string;
    shadowOffset?: [number, number];
}

/**
 * 样式集合
 */
export declare type VectorStyles = {
    [key: string]: VectorStyle;
};

/**
 * 矢量数据渲染器
 */
export declare class VectorTileRender {
    /**
     * 渲染矢量数据
     * @param ctx 渲染上下文
     * @param type 元素类型
     * @param feature 元素
     * @param style 样式
     * @param scale 拉伸倍数
     */
    render(ctx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, type: VectorFeatureTypes, feature: VectorFeature, style: VectorStyle, scale?: number): void;
    private _renderPointText;
    private _renderLineString;
    private _renderPolygon;
}

export { version }

/**
 * 等待某个条件成立后继续执行
 * @param {() => boolean} conditionFn - 返回 boolean 的条件函数
 * @param {number} [checkInterval=100] - 检查间隔（毫秒）
 * @returns {Promise<void>} - 当条件成立时 resolve
 */
export declare function waitFor(conditionFn: () => boolean, checkInterval?: number): Promise<void>;

export { }