import BaseLayer from 'ol/layer/Base';
import { Circle } from 'ol/style';
import { Color } from 'ol/color';
import { ColorLike } from 'ol/colorlike';
import { Control } from 'ol/control';
import { Coordinate } from 'ol/coordinate';
import { default as default_2 } from 'ol/Map';
import { Feature } from 'ol';
import { FeatureLike } from 'ol/Feature';
import { Fill } from 'ol/style';
import { Icon } from 'ol/style';
import Interaction from 'ol/interaction/Interaction';
import { Layer } from 'ol/layer';
import type { Lifecycle } from '@vmap/core';
import { LifecycleState } from '@vmap/core';
import { default as Map_2 } from 'ol/Map';
import { Map as Map_3 } from 'ol';
import * as ol from 'ol';
import Overlay from 'ol/Overlay';
import { PanIntoViewOptions } from 'ol/Overlay';
import { Positioning } from 'ol/Overlay';
import { Projection } from 'ol/proj';
import RenderEvent from 'ol/render/Event';
import ScaleLine from 'ol/control/ScaleLine';
import { Stroke } from 'ol/style';
import { Style } from 'ol/style';
import type { StyleLike } from 'ol/style/Style';
import { TypeEvented } from '@vmap/core';

declare type AreaUnit = 'm2' | 'km2' | 'auto';

/**
 * 抽象基类
 */
export declare abstract class BaseMapTool<T> extends TypeEvented<T> implements MapTool {
    /**
     * 地图对象
     */
    protected map: ol.Map;
    /**
     * 工具状态
     */
    protected state: LifecycleState;
    constructor(map: ol.Map);
    protected abstract startInternal(): void;
    protected abstract stopInternal(): void;
    clear(): void;
    start(): void;
    stop(): void;
    getLifecycleState(): LifecycleState;
}

export declare class CanvasCompassControl extends CanvasControlBase {
    private _img;
    constructor(options?: {
        className?: string;
        style?: Style | Stroke;
        rotateWithView?: boolean;
        visible?: boolean;
        image?: HTMLImageElement;
        src?: 'compact' | 'default' | string;
        widthPixel?: number;
        heightPixel?: number;
    });
    /** Set compass image
     * @param {Image|string} [img=default] the image or an url or 'compact' or 'default'
     */
    setImage(img: HTMLImageElement | string | undefined): void;
    /** Create a default image.
     * @param {number} s the size of the compass
     * @private
     */
    private compactCompass_;
    /** Create a default image.
     * @param {number} s the size of the compass
     * @private
     */
    private defaultCompass_;
    private drawCtx;
    private drawCtx2;
    /** Get control visibility
     * @return {boolean}
     */
    getVisible(): boolean;
    /** Set visibility
     * @param {boolean} b
     */
    setVisible(b: boolean): void;
    /** Draw compass
     * @param {ol.event} e postcompose event
     * @private
     */
    protected draw(e: RenderEvent): void;
}

export declare abstract class CanvasControlBase extends Control {
    #private;
    private _style;
    constructor(options: CanvasControlOptions | undefined);
    protected abstract draw(e: RenderEvent): void;
    setMap(map: Map_3): void;
    /** Get canvas overlay
     */
    getCanvas(map: Map_3): HTMLCanvasElement | null;
    /** Get map Canvas
     * @private
     */
    getContext(e: any): CanvasRenderingContext2D | null;
    setStyle(style: Style | undefined): void;
    getStyle(): Style | undefined;
    /** Get stroke
     * @api
     */
    getStroke(): Stroke | undefined;
    /** Get fill
     * @api
     */
    getFill(): Fill | undefined;
    /** Get stroke
     * @api
     */
    getTextStroke(): Stroke;
    /** Get text fill
     * @api
     */
    getTextFill(): Fill;
    /** Get text font
     * @api
     */
    getTextFont(): string;
}

declare interface CanvasControlOptions {
    style?: Style | undefined;
    element?: HTMLElement | undefined;
}

export declare class CanvasScaleControl extends ScaleLine {
    private _scaleHeight;
    /**
     * 监听
     */
    private _listener;
    private _olscale;
    private _strokeColor;
    private _strokeWidth;
    private _fillColor;
    private _font;
    private _fontStrokeColor;
    private _fontStrokeWidth;
    private _fontFillColor;
    constructor(options?: {
        style?: Style;
    });
    /**
     * Remove the control from its current map and attach it to the new map.
     * Subclasses may set up event handlers to get notified about changes to
     * the map here.
     * @param {ol_Map} map Map.
     * @api stable
     */
    setMap(map: Map_3): void;
    /**
     * Change the control style
     * @param {ol_style_Style} style
     */
    setStyle(style: Style): void;
    private drawScale;
    /** Get map Canvas
     * @private
     */
    private getContext;
}

export declare class CanvasTitleControl extends CanvasControlBase {
    private myElement;
    constructor(options: {
        title?: string;
        visible?: boolean;
        style?: Style;
        className?: string;
    });
    /**
     * Change the control style
     * @param {Style} style
     */
    setStyle(style: Style): void;
    /**
     * Set the map title
     * @param {string} map title.
     * @api stable
     */
    setTitle(title: string): void;
    /**
     * Get the map title
     * @param {string} map title.
     * @api stable
     */
    getTitle(): any;
    /**
     * Set control visibility
     * @param {bool} b
     * @api stable
     */
    setVisible(b: boolean): void;
    /**
     * Get control visibility
     * @return {bool}
     * @api stable
     */
    getVisible(): boolean;
    /**
     * canvas 绘制 标题
     * @param e event
     * @returns
     */
    protected draw(e: RenderEvent): void;
}

/**
 * 十字样式
 * @param radius
 * @param strokeColor
 * @param strokeWidth
 * @param fillColor
 * @returns
 */
export declare function crossStyle(radius?: number, strokeColor?: Color | ColorLike, strokeWidth?: number, fillColor?: Color | ColorLike): Style;

export declare type CrsDetail = {
    projection: string;
    olProjection: Projection;
};

export declare const EPSG3857 = "EPSG:3857";

export declare const EPSG4326 = "EPSG:4326";

export declare const EPSG4490 = "EPSG:4490";

export declare function error(msg: string, ...args: any[]): void;

/**
 * 是否已注册
 */
export declare function hasRegistered(crsCode: string): boolean;

export declare interface ImageStyleType {
    type: 'circle' | 'icon';
    radiusProp?: string;
    radiusRatio?: number;
    [_: string]: any;
}

declare type ImageType = 'image/jpeg' | 'image/png';

export declare function info(msg: string, ...args: any[]): void;

/**
 * 是否是openlayers 默认的空间参考
 * @param crsCode crs code eg: 'EPSG:4326'
 * @returns true/false
 */
export declare function isOlDefaultCrs(crsCode: string): boolean;

/**
 * 图层类型枚举
 */
export declare enum LayerTypes {
    WebGLTile = "webgl-tile",
    Tile = "tile",
    VectorTile = "vector-tile",
    Heatmap = "heatmap",
    Vector = "vector",
    WebGLVector = "webgl-vector",
    Image = "image",
    Shp = "shp"
}

declare type LengthUnit = 'meter' | 'kilometer' | 'auto';

export declare class MapContainer extends TypeEvented<MapEvent_2> {
    #private;
    constructor(target: string);
    get target(): string;
    get map(): ol.Map;
    get style(): MapStyle;
    /**
     * 加载地图模板
     * <code>
     * <pre>
     * mapContainer.load(async () => {
     *    const data: MapStyle = await axios.get('map_style.json')
     *    return data
     * })
     * </pre>
     * </code>
     *
     *
     * @param styleSource 加载的style文件名
     */
    load: (styleSource: MapStyleSource) => Promise<void>;
    remove(): void;
    /**
     * 获取图层
     * @param id 图层id
     * @returns
     */
    getLayerById(id: string): Layer | undefined;
    /**
     * 调整图层的透明度
     * @param lyrId 图层id
     * @param opacity 需要设置的透明度
     * @param callback 回调函数
     */
    setLayerOpacity(lyrId: string, opacity: number, callback?: (pre: number, now: number) => void): void;
    /**
     * 获取地图工具
     * @param type 工具类型
     * @returns 地图工具
     */
    getTool<T extends BaseMapTool<any>>(type: 'identify' | string): T;
    /**
     * 开/关 地图交互
     * @param type 地图键鼠交互类型
     * @param toggle 开/关
     */
    toggleMapInteraction(type: 'MouseWheelZoom' | 'DoubleClickZoom' | 'DragAndDrop' | 'PointerInteraction', toggle?: boolean): void;
    /**
     * 初始化地图视图
     * @param styleData 地图模板
     */
    private initMapView;
}

declare class MapContext extends TypeEvented<MapEvent> {
    #private;
    static INSTANCE: MapContext;
    private constructor();
    setMainMap(map: ol.Map): void;
    getMainMap(): ol.Map;
    getMapContainer(): MapContainer;
    setMapContainer(mc: MapContainer): void;
    setMapStyle(mapStyle: MapStyle): void;
    getMapStyle(): MapStyle;
}

export declare const mapContext: MapContext;

/**
 * 地图控件选项类型
 */
export declare type MapControlOptions = Record<string, any>;

export declare interface MapControlPosition {
    top?: string;
    right?: string;
    bottom?: string;
    left?: string;
}

export declare interface MapControlType {
    id: string;
    title: string;
    /**
     * 可见性
     */
    visible: boolean;
    /**
     * 组件方位 top-left/...
     */
    position: MapControlPosition;
    /**
     * 定义组件的外观样式
     */
    style?: {
        [k: string]: any;
    };
    /**
     * 控件选项
     */
    options: MapControlOptions;
}

export declare interface MapEvent {
    evt_layer_visible: {
        lyrId: string;
        visible: boolean;
    };
    map_ready: {
        map: ol.Map;
    };
    map_hidden: any;
    map_shown: any;
    map_control_pause: {
        id: string;
    };
    map_layer_added: {
        lyrId: string;
    };
    [key: string]: unknown;
}

/**
 * 地图事件
 */
declare interface MapEvent_2 {
    map_style_loaded: MapEventPayload;
    map_loaded: MapEventPayload;
    map_loading: {
        mc: MapContainer;
    };
}

/**
 * 地图事件载荷数据类型
 */
declare interface MapEventPayload {
    map: ol.Map;
    container: MapContainer;
    type: string;
}

export declare interface MapExtent {
    /**
     * [minx, miny, maxx, maxy]
     */
    coordinates: number[];
    /**
     * 坐标系,为空时，默认EPSG:4326
     */
    crs?: string;
}

declare interface MapIdentifyEvent {
    [_: string]: any;
}

export declare class MapIdentifyTool extends BaseMapTool<MapIdentifyEvent> {
    #private;
    /**
     * 添加一个识别图层
     * @param lyrId 图层id
     * @param callback 事件回调
     * @returns
     */
    addLayer(lyrId: string, callback: (feature: FeatureLike, coord: Coordinate) => void): this;
    /**
     *
     * @param lyrId 地图中加载的图层id
     * @param fetchConfig
     * @param callback
     * @returns
     */
    addRemoteLayer(lyrId: string, fetchConfig: RemoteFeaturesFetchConfig, callback: (feature: FeatureLike, coord: Coordinate) => void): this;
    /**
     * 设置独占图层
     * 仅仅当前图层可识别 其他均失效
     * @param lyrId  图层id
     * @param callback 回调
     */
    setExclusiveLayer(lyrId: string, callback: (feature: FeatureLike, coord: Coordinate) => void): this;
    /**
     * 设置remote layer 为独占图层
     * @param lyrId        地图图层id
     * @param fetchConfig  remote 数据获取配置
     * @param callback     获取数据后的回调
     * @returns
     */
    setRemoteExclusiveLayer(lyrId: string, fetchConfig: RemoteFeaturesFetchConfig, callback: (feature: FeatureLike, coord: Coordinate) => void): this;
    /**
     * 会清除该图层所有的事件回调
     * @param lyrId 图层id
     */
    removeLayer(lyrId: string): void;
    protected startInternal(): void;
    protected stopInternal(): void;
    clear(): void;
    /**
     * 处理地图点击事件
     * @param e 地图点击事件
     */
    private _singClickHandler;
    /**
     * 远程方式获取识别的图形数据
     * @param coord 坐标点
     * @param fetchConfig 获取数据配置
     * @returns promise
     */
    private _fetchRemoteFeature;
}

/**
 * 图层加载器
 */
export declare class MapLayerLoader {
    private readonly mapStyle;
    constructor(mapStyle: MapStyle);
    load(): any[];
    /**
     * convert to layer
     * @param layerType 图层类型
     * @param sourceType 数据源类型
     * @returns openlayers layer
     */
    toOlLayer(layerType: MapLayerType, sourceType: MapSourceType): BaseLayer | ShapfileLayer | null;
    /**
     * 根据配置生成对应的 ol 的切片类 source
     * @param sourceType 图层来源类型定义
     * @returns
     */
    private getTileSource;
    /**
     * 转换为 ol的样式对象
     * 1. 图片样式
     * 2. 文字样式
     * @param style  样式定义
     * @returns
     */
    static getVectorStyle(feature: FeatureLike, style: VectorFeatureStyleType | undefined): Style;
    static getImageStyle(imageType: ImageStyleType): Icon | Circle | undefined;
    /**
     * 给8位字符串文件名补0
     * @param num
     * @param len
     * @param radix
     * @returns
     */
    private zeroFill;
}

/**
 * 图层类型定义
 */
export declare interface MapLayerType {
    /**
     * 唯一标识 自定义
     */
    id: string;
    /**
     * 图层类型 自定义
     */
    type: 'shp' | string;
    /**
     * 显示名称 用于图层控制等 自定义
     */
    name: string;
    /**
     * 数据来源id
     * shp layer 不需要此属性！
     */
    source?: string;
    /**
     * 透明度
     */
    opacity?: number;
    /**
     * 是否加载显示
     */
    visible: boolean;
    /**
     *  [minx, miny, maxx, maxy]
     */
    extent?: number[];
    /**
     * 层叠顺序
     */
    zIndex?: number;
    minZoom?: number;
    maxZoom?: number;
    properties?: {
        [key: string]: any;
    };
    /**
     * 图层样式
     */
    style?: VectorFeatureStyleType | RasterTileStyleType;
    projection?: string;
    /**
     * 扩展
     */
    [key: string]: any;
}

declare interface MapMeasureEvent {
    [_: string]: any;
}

declare interface MapMeasureOptions {
    /**
     * 指定面积单位 auto 则会自动判断
     */
    areaUnit?: AreaUnit;
    /**
     * 指定长度单位 auto 则会自动判断
     */
    lengthUnit?: LengthUnit;
}

/**
 * 地图量算工具
 * - 量算面积
 * - 量算长度
 * - 清除等
 * - 自定义样式
 */
export declare class MapMeasureTool extends BaseMapTool<MapMeasureEvent> {
    private _sketch;
    private _source;
    /**
     * 存放结果的图层
     */
    private _vectorLayer;
    private _layerId;
    /**
     * The help tooltip element.
     * @type {HTMLElement}
     */
    private _helpTooltipElement;
    private _helpTooltip;
    /**
     * 测量结果div
     * The measure tooltip element.
     * @type {HTMLElement}
     */
    private _measureTooltipElement;
    /**
     * 测量结果 overlay
     * Overlay to show the measurement.
     * @type {Overlay}
     */
    private _measureTooltip;
    /**
     * so we can remove it later
     */
    private _draw;
    private _overlays;
    private _pointerMoveListener;
    constructor(map: Map_3, options?: MapMeasureOptions);
    doArea(): void;
    doLength(): void;
    cleanup(): void;
    private clearAndReady;
    private addInteraction;
    /**
     * Creates a new help tooltip
     */
    private createHelpTooltip;
    /**
     * Creates a new measure tooltip
     */
    private createMeasureTooltip;
    private pointerMoveHandler;
    protected startInternal(): void;
    protected stopInternal(): void;
}

declare interface MapOverlayEvent {
    [_: string]: any;
}

export declare class MapOverlayTool extends BaseMapTool<MapOverlayEvent> {
    #private;
    protected startInternal(): void;
    protected stopInternal(): void;
    clear(): void;
    /**
     * 添加 marker
     * TODO: 默认样式
     * @param position -点坐标
     * @param classNameOrStyle marker 样式
     * @param centerAt  是否居中显示
     * @returns
     */
    addMarker(position: [number, number], classNameOrStyle: string | Record<string, string>, centerAt?: boolean): string;
    /**
     *  添加 overlay，可用于添加地图弹窗以及覆盖 html 元素等
     *
     * @param content html元素内容
     * @param position 坐标点位置
     * @param centerAt 地图在该点居中
     * @param [stopEvent=true]
     * @returns id
     */
    addOverlay(content: HTMLElement, position: [number, number], centerAt?: boolean, stopEvent?: boolean): string;
    /**
     * 移除当前已添加的overlay
     * @param id overlay id
     * @returns
     */
    removeOverlay(id: string): boolean;
}

declare interface MapPrintEvent {
    /**
     * 开始输出...
     */
    printing: any;
    error: any;
    /**
     * 调用放监听事件来接收生成的 图片
     */
    print: any;
}

export declare class MapPrintTool extends BaseMapTool<MapPrintEvent> {
    private _imageType;
    private _quality;
    getMap(): default_2;
    /**
     * 输出地图
     * @param {Object} options 选项
     * quality: Number between 0 and 1 indicating the image quality to use for image formats that use lossy compression such as image/jpeg and image/webp
     * printNow: 立即输出
     * @api
     */
    print(options?: {
        imageType?: ImageType;
        quality?: number;
        size?: number[];
        format?: string;
        margin?: number;
        orientation?: 'landscape' | 'portrait';
        printNow?: boolean;
    }): void;
    /**
     * 将map输出到 canvas
     * @param event 渲染事件
     * @param imageType 图片类型
     * @param canvas 指定canvas
     * @returns
     */
    private _getCanvas;
    protected startInternal(): void;
    protected stopInternal(): void;
}

declare interface MapRenderEvent {
    [_: string]: any;
}

export declare class MapRenderTool extends BaseMapTool<MapRenderEvent> {
    /**
     * 存储图层的引用 用于缓存图层
     */
    private readonly layers;
    private readonly highlightLayer;
    protected startInternal(): void;
    protected stopInternal(): void;
    clear(): void;
    /**
     * FIXME: 高亮features
     * demo:
     *
     * const fs = new GeoJSON({
     *     dataProjection: 'EPSG:4527',
     *     featureProjection: 'EPSG:3857'
     *   }).readFeatures(JSON.stringify(data))
     *   console.log(fs)
     *   // 高亮
     *   renderTool.highlightFeature(fs, true, 'EPSG:3857', style, 10)
     *
     * @param features 要高亮的图形，注意geojson的坐标系需要和地图保持一致
     * @param clearFirst 是否先清空图层
     * @param extentBufferSize 范围 buffer 数值
     * @param style 样式
     * @param clearAfterSeconds 多少秒后自动清除
     */
    highlightFeatures(features: Feature[], clearFirst?: boolean, extentBufferSize?: number, style?: Style | undefined, clearAfterSeconds?: number): void;
    /**
     * 清除高亮图层
     */
    clearHightLightLayer(): void;
    /**
     * 从数组里渲染点图层
     * @param points 点数据
     * @param xFieldName x字段名
     * @param yFieldName y字段名
     * @param layerId 图层id
     * @param style 图层样式
     */
    renderPoints<T extends {
        [_: string]: any;
    }>(points: T[], xFieldName: string, yFieldName: string, layerId?: string, style?: Style | StyleLike): string | unknown;
    /**
     * 渲染 geojson 数据
     * @param url 获取 geojson 的url
     * @param style  渲染 geojson 样式
     * @param layerId 指定 layerid
     * @param clearAfterSeconds  在xx秒后自动清除
     */
    renderGeoJSON(url: string, style?: Style, layerId?: string, clearAfterSeconds?: number): void;
    /**
     * 渲染 feature
     * @param features 图形要素
     * @param style    高亮样式
     * @param layerId  图形id
     * @param clearAfterSeconds  多少秒后清除
     */
    renderFeature(feature: FeatureLike, style?: Style, layerId?: string, clearAfterSeconds?: number): void;
}

export declare interface MapSourceType {
    type: string;
    url: string;
    /**
     * eg: 'EPSG:3857'
     */
    projection?: string;
    /**
     * 256
     */
    tileSize?: number;
    /**
     * 定制 origin
     */
    origin?: [number, number];
    /**
     * 定制分辨率
     */
    resolutions?: number[];
    /**
     * 扩展
     */
    [key: string]: any;
}

declare interface MapSpyEvent {
    [_: string]: any;
}

export declare class MapSpyTool extends BaseMapTool<MapSpyEvent> {
    /**
     * 默认通透镜的半径
     */
    private _radius;
    private _mousePosition;
    private _mapContainer;
    /**
     * 进行 spy 的目标图层
     */
    private _targetLayer;
    private _prerenderListener;
    private _postrenderListener;
    /**
     * true： 自动添加图层到 map 的 top layer
     */
    private _autoAdd2Top;
    constructor(options: {
        map: Map_3;
        target: Layer;
        radius?: number;
        autoAdd2Top?: boolean;
    });
    protected startInternal(): void;
    protected stopInternal(): void;
    private resizeRadius;
    private mapMove;
    private mapOut;
}

export declare interface MapStyle {
    id: string;
    version: number;
    name: string;
    title: string;
    zoom: number;
    bearing: number;
    center: [number, number];
    initialExtent?: MapExtent;
    crs?: string;
    sources: {
        [_: string]: MapSourceType;
    };
    layers: MapLayerType[];
    controls: MapControlType[];
    debug?: boolean;
    metadata?: Record<string, any>;
}

export declare type MapStyleSource = string | (() => Promise<MapStyle>) | MapStyle;

declare interface MapSwipeEvent {
    [_: string]: any;
}

export declare class MapSwipeTool extends BaseMapTool<MapSwipeEvent> {
    /**
     * 进行 swipe 的目标图层
     */
    private _targetLayer;
    /**
     * true： 自动添加图层到 map 的 top layer
     */
    private _autoAdd2Top;
    private _prerenderListener;
    private _postrenderListener;
    /**
     * 用于显示在地图上可拖动的控件
     */
    private _swipeControl;
    constructor(options: {
        map: Map_3;
        target: Layer;
        autoAdd2Top?: boolean;
    });
    protected startInternal(): void;
    protected stopInternal(): void;
}

declare interface MapTool extends Lifecycle {
    /**
     * 清除tool状态 数据等
     */
    clear: () => void;
}

export declare class OverlayPopup extends Overlay {
    private _offsetBox;
    private _showCloseBox;
    private _onclose;
    private _onshow;
    private _prevHTML;
    private _content;
    private _tout;
    private _autoPositioning;
    constructor(options: OverlayPopupOptions);
    /**
     * add to map
     * @param map {ol.Map}
     */
    addToMap(map: Map_3): void;
    /**
     * Get CSS class of the popup according to its positioning.
     * @private
     */
    getClassPositioning(): string;
    /**
     * Set a close box to the popup.
     * @param {bool} b
     * @api stable
     */
    setClosebox(b: boolean): void;
    /**
     * Set the CSS class of the popup.
     * @param {string} c class name.
     * @api stable
     */
    setPopupClass(cls: string): void;
    /**
     * Add a CSS class to the popup.
     * @param {string} c class name.
     * @api stable
     */
    addPopupClass(c: string): void;
    /**
     * Remove a CSS class to the popup.
     * @param {string} c class name.
     * @api stable
     */
    removePopupClass(c: string): void;
    /**
     * Set positionning of the popup
     * @param {ol.OverlayPositioning | string | undefined} pos an ol.OverlayPositioning
     * 		or 'auto' to var the popup choose the best position
     * @api stable
     */
    setPositioning(pos: Positioning | string | undefined | 'auto' | 'center'): void;
    /** @private
     * @param {ol.OverlayPositioning | string | undefined} pos
     */
    private setPositioning_;
    /** Check if popup is visible
     * @return {boolean}
     */
    getVisible(): boolean;
    /**
     * Set the position and the content of the popup.
     * @param {ol.Coordinate|string} coordinate the coordinate of the popup or the HTML content.
     * @param {string|undefined} html the HTML content (undefined = previous content).
     * @example
     var popup = new ol_Overlay_Popup();
     // Show popup
     popup.show([166000, 5992000], "Hello world!");
     // Move popup at coord with the same info
     popup.show([167000, 5990000]);
     // set new info
     popup.show("New informations");
     * @api stable
     */
    show(coordinate: Coordinate | string | undefined | boolean, html?: string | HTMLElement): void;
    /**
     * Hide the popup
     * @api stable
     */
    hide(): void;
}

export declare interface OverlayPopupOptions {
    showCloseBox?: boolean;
    offsetBox?: number | number[];
    onClose?: () => void;
    onShow?: () => void;
    anchor?: boolean;
    minibar?: boolean;
    stopEvent?: boolean;
    html?: string;
    popupClass?: string;
    className?: string;
    anim?: boolean;
    autoPan?: boolean | PanIntoViewOptions;
    positioning?: Positioning;
    position?: Coordinate;
    [k: string]: any;
}

/**
 * 渲染一个 pulsing 的动态点样式(点图层)
 * @param size canvas 大小
 * @param duration 动画持续时间 值越小 越快
 * @param map  作用的地图实例
 * @returns style
 */
export declare function pulsingStyle(size: number | undefined, duration: number | undefined, map: Map_2): Style;

/**
 * 绘制一个雷达图范围（点图层）
 * @param size 半径
 * @returns
 */
export declare function radarStyle(size: number | undefined, map: Map_2): Style;

/**
 * 栅格切片样式
 * 参考:https://openlayers.org/en/latest/apidoc/module-ol_layer_WebGLTile.html#~Style
 */
export declare interface RasterTileStyleType {
    color: any;
}

/**
 * 注册空间参考
 * @param crsCode crs code eg: 'EPSG:4326'
 * @param crsDetail 详细
 * @returns 注册表
 */
export declare function registerCrs(crsCode: string, crsDetail: CrsDetail): Map<string, any>;

/**
 * 向gscp平台进行remote查询的配置参数
 */
declare interface RemoteFeaturesFetchConfig {
    url: string;
    remoteLayerId: string;
}

export declare class ShapfileLayer {
    #private;
    readonly id: string;
    readonly url: string;
    readonly type: string;
    readonly options: ShapfileLayerOptions & (MapLayerType | {
        source?: any;
        [_: string]: any;
    });
    constructor(id: string, options: ShapfileLayerOptions & (MapLayerType | {
        source?: any;
        id?: string;
        [_: string]: any;
    }));
    /**
     * convert to ol layer
     * @returns ol map layer
     */
    toMapLayer(): Promise<any>;
    private readShapeFeatures;
    private str2ab;
}

export declare interface ShapfileLayerOptions {
    url: string;
    crs: string;
    encoding?: string;
}

/**
 * 数据源枚举
 */
export declare enum SourceTypes {
    XYZ = "xyz",
    TileArcGISRest = "arcgis-rest",
    WMTS = "wmts",
    VectorTile = "vector-tile",
    Vector = "vector",
    ArcGISLocal = "arcgis-local",
    GeoTIFF = "geotiff"
}

/**
 * 正方形样式
 * @param radius   正方形边长
 * @param strokeColor stroke color
 * @param strokeWidth  stroke width
 * @param fillColor  fill color
 * @returns style
 */
export declare function squareShapeStyle(radius?: number, strokeColor?: Color | ColorLike, strokeWidth?: number, fillColor?: Color | ColorLike): Style;

/**
 * 五角星样式
 * @param radiusOuter
 * @param radiusInner
 * @param strokeColor
 * @param strokeWidth
 * @param fillColor
 */
export declare function starStyle(radiusOuter?: number, radiusInner?: number, strokeColor?: Color | ColorLike, strokeWidth?: number, fillColor?: Color | ColorLike): void;

/**
 * 多个地图保持状态同步
 */
export declare class Synchronize extends Interaction {
    /**
     * 需要同步的地图实例
     */
    private _maps;
    private _listener;
    private _active;
    constructor(options: {
        active?: boolean;
        maps?: Map_2[];
    });
    /**
     * Remove the interaction from its current map, if any,  and attach it to a new
     * map, if any. Pass `null` to just remove the interaction from the current map.
     * @param {ol_Map} map Map.
     * @api stable
     */
    setMap(map: Map_2): void;
    /** Auto activate/deactivate controls in the bar
     * @param {boolean} b activate/deactivate
     */
    setActive(b: boolean): void;
    /**
     * Synchronize the maps
     */
    syncMaps(): void;
    /**
     * Cursor move > tells other maps to show the cursor
     * @param {ol.event} e "move" event
     */
    private handleMove;
    /**
     * Cursor out of map > tells other maps to hide the cursor
     * @param {event} e "mouseOut" event
     */
    private handleMouseOut;
    private showMapTarget;
    private removeTarget;
}

/**
 * 三角形样式
 * @param radius
 * @param strokeColor
 * @param strokeWidth
 * @param fillColor
 */
export declare function triangleStyle(radius?: number, strokeColor?: Color | ColorLike, strokeWidth?: number, fillColor?: Color | ColorLike): void;

/**
 * 矢量要素样式
 */
export declare interface VectorFeatureStyleType {
    fill?: {
        color: [number, number, number, number];
        propertyName?: string;
    };
    stroke?: {
        color: [number, number, number, number];
        width: number;
        lineCap?: 'butt' | 'round' | 'square';
        lineJoin?: 'bevel' | 'round' | 'miter';
        miterLimit?: number;
        propertyName?: string;
    };
    text?: {
        propertyName?: string;
        showLabelOnly?: boolean;
        [_: string]: any;
    };
    image?: ImageStyleType;
    colorSample?: Array<{
        color?: string | [number, number, number, number];
        value: any;
    }>;
    imageSample?: Array<{
        imgUrl: string;
        value: any;
    }>;
}

export declare function warn(msg: string, ...args: any[]): void;

/**
 * webgl vector style
 */
export declare interface WebGLVectorStyleType {
    fill?: {
        color: [number, number, number, number];
        opacity?: number;
    };
    stroke?: {
        color: [number, number, number, number];
        width: number;
        opacity?: number;
    };
}

export { }