import { Field, WindCore, IField, IOptions } from 'wind-core';
export { Field } from 'wind-core';
import { BaseLayer as BaseLayer$1, UserOptions } from 'wind-gl-core';
export { DecodeType, ImageSource, LayerSourceType, MaskType, RenderFrom, RenderType, TileID, TileSource, TimelineSource, configDeps } from 'wind-gl-core';
import * as L from 'leaflet';
import * as _sakitam_gis_vis_engine from '@sakitam-gis/vis-engine';
import { Matrix4, Scene, OrthographicCamera, PerspectiveCamera, Renderer } from '@sakitam-gis/vis-engine';

declare class BaseLayer extends L.Layer {
    options: any;
    _updating: boolean;
    _layerId: string | number;
    devicePixelRatio: number;
    _width: number;
    _height: number;
    canvas: HTMLCanvasElement | null;
    constructor(id: string | number, data: any, options: any);
    initialize(id: string | number, data: any, options: any): void;
    _createCanvas(id: string | number, zIndex: number): HTMLCanvasElement;
    _reset(): void;
    _onResize(resizeEvent: L.ResizeEvent): void;
    _zoomStart(): void;
    _moveStart(): void;
    _animateZoom(event: L.ZoomAnimEvent): void;
    _resizeCanvas(scale: number): void;
    _redraw(): void;
    _render(): void;
    project(coordinate: [number, number]): [number, number];
    unproject(pixel: [number, number]): [number, number];
    intersectsCoordinate(coordinate: [number, number]): boolean;
    onAdd(map: L.Map): this;
    _resetView(e?: any): void;
    onMoveEnd(): void;
    onRemove(): this;
    getEvents(): {
        [key: string]: any;
    };
}

declare class WindLayer extends BaseLayer {
    field: Field | undefined;
    wind: WindCore | null;
    initialize(id: string | number, data: any, options: any): void;
    _redraw(): void;
    _render(): void;
    onRemove(): this;
    pickWindOptions(): void;
    /**
     * get wind layer data
     */
    getData(): Field | undefined;
    /**
     * set layer data
     * @param data
     * @param options
     * @returns {WindLayer}
     */
    setData(data: any, options?: Partial<IField>): this;
    setWindOptions(options: Partial<IOptions>): void;
    getWindOptions(): any;
}

interface ViewState$1 {
    width: number;
    height: number;
    maxPitch: number;
    fov: number;
    worldSize: number;
    elevation: any;
    _horizonShift: number;
    getCenter: () => any;
    getPitch: () => number;
    getBearing: () => number;
    getFovRad: () => number;
    getCameraPosition: () => number[];
    centerOffset: () => any;
    project: (coordinates: number[]) => any;
}
declare class CameraSync {
    worldMatrix: Matrix4;
    mercatorMatrix: Matrix4;
    labelPlaneMatrix: Matrix4;
    glCoordMatrix: Matrix4;
    viewState: ViewState$1;
    scene: Scene;
    camera: OrthographicCamera | PerspectiveCamera;
    halfFov: number;
    cameraToCenterDistance: number;
    acuteAngle: number;
    cameraTranslateZ: number;
    constructor(viewState: ViewState$1, cameraType: any, scene: any);
    setup(): void;
    update(): void;
}

declare class ViewState {
    _width: number;
    _height: number;
    _fov: number;
    _worldSize: number;
    _center: any;
    zoom: number;
    tileSize: number;
    maxPitch: number;
    elevation: any;
    _horizonShift: number;
    /**
     * 获取 gl 宽度
     */
    get width(): number;
    /**
     * 获取 gl 高度
     */
    get height(): number;
    get fov(): number;
    get worldSize(): number;
    getCenter(): any;
    getPitch(): number;
    getBearing(): number;
    getFovRad(): number;
    getCameraPosition(): number[];
    centerOffset(): {
        x: number;
        y: number;
    };
    project(lnglat: any): {
        x: number;
        y: number;
        z: number;
    };
    get pixelsPerMeter(): number;
    unproject(p: number[]): number[];
    update(state: Record<string, any>): void;
}
interface LayerOptions extends UserOptions {
    renderingMode?: '2d' | '3d';
}
declare class WebglLayer extends BaseLayer {
    gl: WebGL2RenderingContext | WebGLRenderingContext | null;
    renderer: Renderer;
    scene: Scene;
    sync: CameraSync;
    planeCamera: OrthographicCamera;
    viewState: ViewState;
    layer: BaseLayer$1;
    _tileZoom: number | undefined;
    _wrapX: undefined | false | number[];
    _wrapY: undefined | false | number[];
    _globalTileRange: any;
    _currentTiles: any[];
    _unLimitTiles: any[];
    private source;
    initialize(id: string | number, source: any, options: any): void;
    _resizeCanvas(scale: number): void;
    get camera(): OrthographicCamera | _sakitam_gis_vis_engine.PerspectiveCamera;
    getTileSize(): L.Point;
    _redraw(): this;
    _render(): void;
    glPrerender(): void;
    glRender(): void;
    picker(coordinates: any): Promise<any>;
    calcWrappedWorlds(): number[];
    _resetView(e?: any): void;
    _resetGrid(): void;
    _setView(center: L.LatLng, zoom: number, noPrune?: boolean, noUpdate?: boolean): void;
    _tileCoordsToBounds(coords: any): L.LatLngBounds;
    _tileCoordsToNwSe(coords: any): L.LatLng[];
    _isValidTile(coords: any): boolean;
    _wrapCoords(coords: any): L.Point;
    _update(center?: L.LatLng): any[] | undefined;
    _getTiledPixelBounds(center: L.LatLng, zoom: number): L.Bounds;
    _pxBoundsToTileRange(bounds: L.Bounds): L.Bounds;
    handleZoom(): void;
    onMoveEnd(): void;
    onMoveStart(): void;
    _animateZoom(event: L.ZoomAnimEvent): void;
    getEvents(): Record<string, any>;
    updateOptions(options: Partial<LayerOptions>): void;
    getMask(): any;
    private processMask;
    setMask(mask: any): void;
    onRemove(): this;
}

export { WebglLayer, WindLayer };