import { Event as Event_2 } from 'cesium';
import { ImageryLayerFeatureInfo } from 'cesium';
import { ImageryProvider } from 'cesium';
import { ImageryTypes } from 'cesium';
import { Rectangle } from 'cesium';
import { Request as Request_2 } from 'cesium';
import { VectorTile } from '@mapbox/vector-tile';
import { VectorTileFeature } from '@mapbox/vector-tile';
import { VectorTileLayer } from '@mapbox/vector-tile';
import { WebMercatorTilingScheme } from 'cesium';

declare class CesiumMVTImageryProvider implements ImageryProviderTrait {
    private readonly _minimumLevel;
    private readonly _maximumLevel;
    private readonly _urlTemplate;
    private readonly _layerNames;
    private readonly _credit?;
    private readonly _resolution?;
    private readonly _headers?;
    private _currentUrl?;
    private _onRenderFeature?;
    private _onFeaturesRendered?;
    private _style?;
    private _onSelectFeature?;
    private _parseTile;
    private _pickPointRadius;
    private _pickLineWidth;
    private readonly _tilingScheme;
    private readonly _tileWidth;
    private readonly _tileHeight;
    private readonly _rectangle;
    private readonly _ready;
    private readonly _readyPromise;
    private readonly _errorEvent;
    private readonly _tileCaches;
    constructor(options: ImageryProviderOption);
    get url(): string | undefined;
    get tileWidth(): number;
    get tileHeight(): number;
    get maximumLevel(): number;
    get minimumLevel(): number;
    get tilingScheme(): WebMercatorTilingScheme;
    get rectangle(): Rectangle;
    get errorEvent(): Event_2<(...args: any[]) => void>;
    get ready(): boolean;
    get hasAlphaChannel(): boolean;
    get credit(): any;
    get defaultNightAlpha(): undefined;
    get defaultDayAlpha(): undefined;
    get defaultAlpha(): any;
    get defaultBrightness(): any;
    get defaultContrast(): any;
    get defaultHue(): any;
    get defaultSaturation(): any;
    get defaultGamma(): any;
    get defaultMinificationFilter(): any;
    get defaultMagnificationFilter(): any;
    get readyPromise(): Promise<boolean>;
    get tileDiscardPolicy(): any;
    get proxy(): any;
    getTileCredits(_x: number, _y: number, _level: number): never[];
    requestImage(x: number, y: number, level: number, _request?: Request_2 | undefined): Promise<ImageryTypes> | undefined;
    _renderCanvas(canvas: HTMLCanvasElement, requestedTile: TileCoordinates, layerName: string, scaleFactor: number): Promise<HTMLCanvasElement>;
    _renderPolygon(context: CanvasRenderingContext2D, feature: VectorTileFeature, extentFactor: number, shouldRenderLine: boolean): void;
    _renderPoint(context: CanvasRenderingContext2D, feature: VectorTileFeature, extentFactor: number): void;
    _renderLineString(context: CanvasRenderingContext2D, feature: VectorTileFeature, extentFactor: number): void;
    pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
    _pickFeatures(requestedTile: TileCoordinates, longitude: number, latitude: number, layer: VectorTileLayer): Promise<ImageryLayerFeatureInfo[]>;
    _cachedTile(currentUrl: string): Promise<VectorTile | undefined>;
}
export { CesiumMVTImageryProvider }
export default CesiumMVTImageryProvider;

declare type FeatureHandler<R> = (feature: VectorTileFeature, tileCoords: TileCoordinates) => R;

export declare type ImageryProviderOption = {
    urlTemplate: URLTemplate;
    layerName: string;
    headers?: any;
    minimumLevel?: number;
    maximumLevel?: number;
    maximumNativeZoom?: number;
    credit?: string;
    resolution?: number;
    onRenderFeature?: FeatureHandler<boolean | void>;
    onFeaturesRendered?: () => void;
    style?: FeatureHandler<Style>;
    onSelectFeature?: FeatureHandler<ImageryLayerFeatureInfo | void>;
    parseTile?: (url?: string) => Promise<VectorTile | undefined>;
    pickPointRadius?: number | FeatureHandler<number>;
    pickLineWidth?: number | FeatureHandler<number>;
};

declare type ImageryProviderTrait = ImageryProvider;

declare type Style = {
    fillStyle?: string;
    strokeStyle?: string;
    lineWidth?: number;
    lineJoin?: CanvasLineJoin;
};

declare type TileCoordinates = {
    x: number;
    y: number;
    level: number;
};

declare type URLTemplate = `${`http${"s" | ""}://` | ""}${string}/{z}/{x}/{y}${string}`;

export { }