import Extent from '../../../geo/Extent';
import LRUCache from '../../../core/util/LRUCache';
import Actor from '../../../core/worker/Actor';
import { TileImageBuffer, TileImageTexture } from '../../types';
import type { WithUndef } from '../../../types/typings';
import { MixinConstructor } from '../../../core/Mixin';
declare class TileWorkerConnection extends Actor {
    constructor();
    checkUrl(url: string): string;
    fetchImage(url: string, workerId: number, cb: Function, fetchOptions: any): void;
}
/**
 * 瓦片图层的渲染器抽象类，实现瓦片的遍历功能，可以继承并实现 drawTile 等方法来实现瓦片图层渲染
 *
 * @english
 * Abstract renderer class for TileLayers in maptalks-gl
 * @class
 * @protected
 * @group renderer
 * @extends {renderer.LayerAbstractRenderer}
 */
declare const TileLayerRenderable: <T extends MixinConstructor>(Base: T) => {
    new (...args: any[]): {
        [x: string]: any;
        tilesInView: TilesInViewType;
        tilesLoading: {
            [key: string]: any;
        };
        _parentTiles: any[];
        _childTiles: any[];
        _tileZoom: number;
        _tileQueue: {
            tileInfo: any;
            tileData: any;
        }[];
        _tileQueueIds: Set<LayerId>;
        tileCache: LRUCache;
        _compareTiles: any;
        _tileImageWorkerConn: TileWorkerConnection;
        _renderTimestamp: number;
        _frameTiles: {
            empty: boolean;
            timestamp: number;
        };
        _terrainHelper: TerrainHelper;
        _tilePlaceHolder: any;
        _frameTileGrids: TileGrids;
        drawingCurrentTiles: WithUndef<boolean>;
        drawingChildTiles: WithUndef<boolean>;
        drawingParentTiles: WithUndef<boolean>;
        avgMinAltitude: number;
        avgMaxAltitude: number;
        init(): void;
        getCurrentTileZoom(): number;
        draw(timestamp: number, context: any): number;
        getTileGridsInCurrentFrame(): TileGrids;
        getCurrentTimestamp(): number;
        _getTilesInCurrentFrame(): {
            childTiles: any[];
            missedTiles: any[];
            parentTiles: any[];
            tiles: any[];
            incompleteTiles: unknown[];
            placeholders: any[];
            loading: boolean;
            loadingCount: number;
            tileQueue: {};
        };
        removeTileCache(tileId: TileId): void;
        isTileCachedOrLoading(tileId: TileId): any;
        isTileCached(tileId: TileId): boolean;
        isTileFadingIn(tileImage: Tile['image']): boolean;
        _drawTiles(tiles: any, parentTiles: any, childTiles: any, placeholders: any, parentContext: any, missedTiles: any, incompleteTiles: any): void;
        _drawCurrentTiles(tiles: any, parentContext: any): void;
        _drawChildTiles(childTiles: any, parentContext: any): void;
        _drawParentTiles(parentTiles: any, parentContext: any): void;
        onDrawTileStart(context: RenderContext, parentContext: RenderContext): void;
        onDrawTileEnd(context: RenderContext, parentContext: RenderContext): void;
        _drawTile(info: any, image: any, parentContext: any): void;
        drawTile(tileInfo: Tile['info'], tileImage: Tile['image'], parentContext?: RenderContext): void;
        _drawTileAndCache(tile: Tile, parentContext: any): void;
        drawOnInteracting(event: any, timestamp: number, context: any): void;
        checkIfNeedRedraw(): boolean;
        hitDetect(): boolean;
        /**
         * @private
         * limit tile number to load when map is interacting
         */
        _getLoadLimit(): number;
        _isLoadingTile(tileId: TileId): boolean;
        loadTileQueue(tileQueue: any): void;
        loadTile(tile: Tile['info']): Tile['image'];
        _fetchImage(image: any, tile: Tile['info']): void;
        loadTileImage(tileImage: any, url: string, tile: Tile['info']): void;
        abortTileLoading(tileImage: Tile['image'], tileInfo: Tile['info']): void;
        onTileLoad(tileImage: Tile['image'], tileInfo: Tile['info']): void;
        removeTileLoading(tileInfo: Tile['info']): void;
        _consumeTileQueue(): void;
        _computeAvgTileAltitude(): void;
        checkTileInQueue(tileImage: Tile['image'], tileInfo: Tile['info']): boolean;
        consumeTile(tileImage: Tile['image'], tileInfo: Tile['info']): void;
        resetTileLoadTime(tileImage: Tile['image']): void;
        onTileError(tileImage: Tile['image'], tileInfo: Tile['info'], error?: any): void;
        getDebugInfo(tileId: TileId): string;
        findChildTiles(info: Tile['info']): any;
        _findChildTiles(info: Tile['info']): Tile[] | any;
        _findChildTilesAt(children: Tile[], pmin: number, pmax: number, layer: any, childZoom: number): void;
        findParentTile(info: Tile['info'], targetDiff?: number): Tile;
        _findParentTile(info: Tile['info'], targetDiff?: number): Tile;
        isValidCachedTile(tile: Tile): boolean;
        isTileComplete(tile: Tile): boolean;
        _getLayerOfTile(layerId: LayerId): any;
        getCachedTile(tile: Tile, isParent: boolean): any;
        _addTileToCache(tileInfo: Tile['info'], tileImage: Tile['image']): void;
        getTileOpacity(tileImage: Tile['image'], tileInfo: Tile['info']): number;
        getTileFadingOpacity(tileImage: Tile['image']): number;
        clearTileCaches(): void;
        removeTileCaches(): void;
        markCurrent(tile: Tile, isCurrent?: boolean): void;
        markTiles(): number[];
        retireTiles(force?: boolean): void;
        deleteTile(tile: Tile): void;
        _generatePlaceHolder(res: number): HTMLCanvasElement;
        setTerrainHelper(helper: TerrainHelper): void;
        _validateTileImage(image: any): boolean;
    };
} & T;
export default TileLayerRenderable;
export type TileId = string;
export type LayerId = string | number;
export type TerrainHelper = any;
export type TileImage = (HTMLImageElement | HTMLCanvasElement | ImageBitmap) & {
    loadTime: number;
    fetchErrorTime: number;
    glBuffer?: TileImageBuffer;
    texture?: TileImageTexture;
};
export interface Tile {
    id: TileId;
    info: {
        x: number;
        y: number;
        z: number;
        idx: number;
        idy: number;
        id: TileId;
        layer: number | string;
        children: [];
        error: number;
        offset: [number, number];
        extent2d: Extent;
        res: number;
        url: string;
        parent: any;
        cache?: boolean;
        minAltitude?: number;
        maxAltitude?: number;
    };
    image: TileImage;
    current?: boolean;
}
export type RenderContext = any;
export type TilesInViewType = {
    [key: string]: Tile;
};
export interface TileGrid {
    extent: Extent;
    count: number;
    tiles: Tile[];
    parents: any[];
    offset: number[];
    zoom: number;
}
export interface TileGrids {
    count: number;
    tileGrids: TileGrid[];
}
//# sourceMappingURL=TileLayerRendererable.d.ts.map