import LRUCache from '../../core/util/LRUCache';
import Size from '../../geo/Size';
import PointExtent from '../../geo/PointExtent';
import Layer, { LayerJSONType, LayerOptionsType } from '../Layer';
import SpatialReference, { SpatialReferenceType } from '../../map/spatial-reference/SpatialReference';
import { type TileLayerCanvasRenderer } from '../../renderer';
import { Tile } from '../../renderer/layer/tilelayer/TileLayerRendererable';
/**
 * A layer used to display tiled map services, such as [google maps](http://maps.google.com), [open street maps](http://www.osm.org)
 * @category layer
 * @example
 *  new TileLayer("tile",{
        urlTemplate : 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
        subdomains:['a','b','c']
    })
 */
declare class TileLayer extends Layer {
    tileInfoCache: LRUCache;
    options: TileLayerOptionsType;
    /**
     *
     * @param id - tile layer's id
     * @param options - options defined in TileLayerOptionsType
     */
    constructor(id: string, options?: TileLayerOptionsType);
    /**
     * Reproduce a TileLayer from layer's profile JSON.
     * @param layerJSON - layer's profile JSON
     * @return
     * @static
     * @protected
     * @function
     */
    static fromJSON(layerJSON: Record<string, any>): TileLayer;
    onAdd(): void;
    _prepareOptions(): void;
    /**
     * force Reload tilelayer.
     * Note that this method will clear all cached tiles and reload them. It shouldn't be called frequently for performance reason.

     * @return this
     */
    forceReload(): this;
    /**
     * Get tile size of the tile layer
     * @return
     */
    getTileSize(id?: string): Size;
    getTiles(z: number, parentLayer: Layer): any;
    createTileNode(x: number, y: number, z: number, idx: number, idy: number, res: number, error: number, parentId?: string, extent2d?: PointExtent, tileId?: string): TileNodeType;
    isParentTile(currentTileZoom: number, maxZoom: number, tile: TileNodeType): boolean;
    /**
     * Get tile's url
     * @param x
     * @param y
     * @param z
     * @returns url
     */
    getTileUrl(x: number, y: number, z: number): string;
    /**
     * Clear the layer
     * @return this
     */
    clear(): this;
    /**
     * Export the tile layer's profile json. <br>
     * Layer's profile is a snapshot of the layer in JSON format. <br>
     * It can be used to reproduce the instance by [fromJSON]{@link Layer#fromJSON} method
     * @return layer's profile JSON
     */
    toJSON(): LayerJSONType;
    /**
     * Get tilelayer's spatial reference.
     * @returns spatial reference
     */
    getSpatialReference(): SpatialReference;
    getMinZoom(): number;
    getMaxZoom(): number;
    /**
     * Get tileLayer's max available zoom, either options['maxAvailableZoom'] or spatialReference's maxZoom
     *
     * @returns
     **/
    getMaxAvailableZoom(): number;
    getTileId(x: number, y: number, zoom: number, id: string): string;
    getEvents(): {
        spatialreferencechange: () => void;
    };
    /**
     * Get layer's polygonOffset count
     * @return
     */
    getPolygonOffsetCount(): number;
    /**
     * Get layer's base polygon offset
     * @return
     */
    getPolygonOffset(): number;
    /**
     * Set layer's base polygon offset, called by GroupGLLayer
     * @param offset polygon offset
     * @return
     */
    setPolygonOffset(offset: number): this;
    getRenderer(): TileLayerCanvasRenderer;
}
export default TileLayer;
export type TileOffsetType = [number, number];
export type TileNodeType = {
    x: number;
    y: number;
    z: number;
    url: string;
    res: number;
    parent: string;
    offset: TileOffsetType;
    layer: string;
    idy: number;
    idx: number;
    id: string;
    extent2d: PointExtent;
    error: number;
    children: Array<string>;
    minAltitude?: number;
    maxAltitude?: number;
};
export type TileGridType = {
    count?: number;
    extent: PointExtent;
    offset: TileOffsetType;
    parents?: Array<TileNodeType>;
    tiles: Array<TileNodeType>;
    zoom: number;
};
export type TilesType = {
    tileGrids: Array<TileGridType>;
    count: number;
};
export type TileCacheType = {
    info: TileNodeType;
};
export type TileRootType = {
    status: 0 | 1;
    error?: string;
    tiles?: Array<TileNodeType>;
    mapWidth?: number;
    mapHeight?: number;
};
export type TileLayerOptionsType = LayerOptionsType & {
    urlTemplate: string | ((...args: any[]) => string);
    subdomains?: string[];
    spatialReference?: SpatialReferenceType;
    tileSize?: number | [number, number];
    offset?: number[] | ((...args: any[]) => number[]);
    tileSystem?: [number, number, number, number];
    maxAvailableZoom?: number;
    repeatWorld?: boolean;
    background?: boolean;
    placeholder?: boolean | ((...args: any[]) => boolean);
    fragmentShader?: string;
    crossOrigin?: string;
    fadeAnimation?: boolean;
    fadeDuration?: number;
    debug?: boolean;
    renderer?: 'gl' | 'canvas';
    maxCacheSize?: number;
    cascadeTiles?: boolean;
    zoomOffset?: number;
    reloadErrorTileFunction?: (layer: TileLayer, renderer: TileLayerCanvasRenderer, tileInfo: Tile['info'], tileImage: Tile['image']) => void;
    errorUrl?: string;
    customTags?: Record<string, any>;
    decodeImageInWorker?: boolean;
    token?: string;
    fetchOptions?: Record<string, any>;
    awareOfTerrain?: boolean;
    bufferPixel?: number;
    depthMask?: boolean;
    loadingLimitOnInteracting?: number;
    loadingLimit?: number;
    clipByPitch?: boolean;
    pyramidMode?: number;
    tileLimitPerFrame?: number;
    tileStackStartDepth?: number;
    tileStackDepth?: number;
    mipmapTexture?: boolean;
    currentTilesFirst?: boolean;
    tileErrorScale?: number;
};
//# sourceMappingURL=TileLayer.d.ts.map