import '../data/feature_index';
import type FeatureIndex from '../data/feature_index';
import GeoJSONFeature from '../util/vectortile_to_geojson';
import { CollisionBoxArray } from '../data/array_types';
import Texture from '../render/texture';
import SourceFeatureState from '../source/source_state';
import type { Bucket } from '../data/bucket';
import type StyleLayer from '../style/style_layer';
import type { WorkerTileResult } from './worker_source';
import type Actor from '../util/actor';
import type DEMData from '../data/dem_data';
import type { AlphaImage } from '../util/image';
import type ImageAtlas from '../render/image_atlas';
import type ImageManager from '../render/image_manager';
import type Context from '../gl/context';
import type { OverscaledTileID } from './tile_id';
import type Framebuffer from '../gl/framebuffer';
import type Transform from '../geo/transform';
import type { LayerFeatureStates } from './source_state';
import type { Cancelable } from '../types/cancelable';
import type { FilterSpecification } from '../style-spec/types';
import type Point from '../util/point';
import { mat4 } from 'gl-matrix';
export declare type TileState = // Tile data is in the process of loading.
'loading' | // Tile data has been loaded. Tile can be rendered.
'loaded' | // Tile data has been loaded and is being updated. Tile can be rendered.
'reloading' | // Tile data has been deleted.
'unloaded' | // Tile data was not loaded because of an error.
'errored' | 'expired';
/**
 * A tile object is the combination of a Coordinate, which defines
 * its place, as well as a unique ID and data tracking for its content
 *
 * @private
 */
declare class Tile {
    tileID: OverscaledTileID;
    uid: number;
    uses: number;
    tileSize: number;
    buckets: {
        [_: string]: Bucket;
    };
    latestFeatureIndex: FeatureIndex;
    latestRawTileData: ArrayBuffer | undefined | null;
    imageAtlas: ImageAtlas | undefined | null;
    imageAtlasTexture: Texture;
    glyphAtlasImage: AlphaImage | undefined | null;
    glyphAtlasTexture: Texture;
    expirationTime: any;
    expiredRequestCount: number;
    state: TileState;
    timeAdded: any;
    fadeEndTime: any;
    collisionBoxArray: CollisionBoxArray | undefined | null;
    redoWhenDone: boolean;
    showCollisionBoxes: boolean;
    placementSource: any;
    actor: Actor | undefined | null;
    vtLayers: {
        [_: string]: VectorTileLayer;
    };
    neighboringTiles: any;
    dem: DEMData | undefined | null;
    aborted: boolean | undefined | null;
    needsHillshadePrepare: boolean | undefined | null;
    request: Cancelable | undefined | null;
    texture: any;
    fbo: Framebuffer | undefined | null;
    demTexture: Texture | undefined | null;
    refreshedUponExpiration: boolean;
    reloadCallback: any;
    resourceTiming: Array<PerformanceResourceTiming> | undefined | null;
    queryPadding: number;
    symbolFadeHoldUntil: number | undefined | null;
    hasSymbolBuckets: boolean;
    hasRTLText: boolean;
    dependencies: any;
    /**
     * @param {OverscaledTileID} tileID
     * @param size
     * @private
     */
    constructor(tileID: OverscaledTileID, size: number);
    registerFadeDuration(duration: number): void;
    wasRequested(): boolean;
    /**
     * Given a data object with a 'buffers' property, load it into
     * this tile's elementGroups and buffers properties and set loaded
     * to true. If the data is null, like in the case of an empty
     * GeoJSON tile, no-op but still set loaded to true.
     * @param {Object} data
     * @param painter
     * @returns {undefined}
     * @private
     */
    loadVectorData(data: WorkerTileResult, painter: any, justReloaded?: boolean | null): void;
    /**
     * Release any data or WebGL resources referenced by this tile.
     * @returns {undefined}
     * @private
     */
    unloadVectorData(): void;
    getBucket(layer: StyleLayer): Bucket;
    upload(context: Context): void;
    prepare(imageManager: ImageManager): void;
    queryRenderedFeatures(layers: {
        [_: string]: StyleLayer;
    }, serializedLayers: {
        [_: string]: any;
    }, sourceFeatureState: SourceFeatureState, queryGeometry: Array<Point>, cameraQueryGeometry: Array<Point>, scale: number, params: {
        filter: FilterSpecification;
        layers: Array<string>;
        availableImages: Array<string>;
    }, transform: Transform, maxPitchScaleFactor: number, pixelPosMatrix: mat4): {
        [_: string]: Array<{
            featureIndex: number;
            feature: GeoJSONFeature;
        }>;
    };
    querySourceFeatures(result: Array<GeoJSONFeature>, params: any): void;
    hasData(): boolean;
    patternsLoaded(): boolean;
    setExpiryData(data: any): void;
    getExpiryTimeout(): number;
    setFeatureState(states: LayerFeatureStates, painter: any): void;
    holdingForFade(): boolean;
    symbolFadeFinished(): boolean;
    clearFadeHold(): void;
    setHoldDuration(duration: number): void;
    setDependencies(namespace: string, dependencies: Array<string>): void;
    hasDependency(namespaces: Array<string>, keys: Array<string>): boolean;
}
export default Tile;
//# sourceMappingURL=tile.d.ts.map