import { LayerTreeManager } from '../../core/LayerTreeManager';
import { LayerConfigManager } from '../../core/LayerConfigManager';
import { LayerConfig } from '../../types';

declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
    modelValue: boolean;
}>>, {
    handleLayerChange: (layer: LayerConfig) => void;
    addLayer: (config: Omit<LayerConfig, "layer"> & {
        id?: string;
    }) => void;
    removeLayer: (layerId: string) => void;
    showLayerInfo: (layer: LayerConfig) => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    "update:modelValue": (value: boolean) => void;
    "layer-change": (layer: LayerConfig) => void;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
    modelValue: boolean;
}>>> & Readonly<{
    "onUpdate:modelValue"?: (value: boolean) => any;
    "onLayer-change"?: (layer: LayerConfig) => any;
}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
    title?(_: {}): any;
    footer?(_: {
        layers: {
            id: string;
            name: string;
            type: string;
            url?: string;
            method?: import('../../types').GeoJSONRequestMethod;
            headers?: Record<string, string>;
            body?: string | Record<string, any>;
            dataPath?: string;
            visible: boolean;
            opacity: number;
            zIndex: number;
            extent?: [number, number, number, number];
            canvasConfig?: any;
            source?: any;
            layer?: unknown;
            legend?: {
                type?: "symbol" | "custom" | "color" | "icon" | "simple" | "gradient" | "category";
                items: {
                    label: string;
                    value?: string | number;
                    color?: string;
                    symbol?: "circle" | "line" | "polygon" | "square" | "triangle";
                    image?: string;
                    shape?: "circle" | "square" | "triangle";
                    size?: number;
                    borderColor?: string;
                    pattern?: string;
                }[];
                title?: string;
                position?: "bottom-left" | "bottom-right" | "top-left" | "top-right";
                colors?: string[];
                min?: string | number;
                max?: string | number;
                unit?: string;
                content?: string;
                description?: string;
                visible?: boolean;
                layerId?: string;
            };
            metadata?: Record<string, any>;
            group?: string;
            children?: any[];
            layers?: any[];
            transparent?: boolean;
            cacheEnabled?: boolean;
            autoFetchMetadata?: boolean;
            projection?: string;
            projectionDefinition?: string;
            geojsonConfig?: {
                data?: string | object;
                request?: {
                    url?: string;
                    method?: import('../../types').GeoJSONRequestMethod;
                    headers?: Record<string, string>;
                    params?: Record<string, any>;
                    body?: string | Record<string, any>;
                    dataPath?: string;
                    managementUnit?: string;
                    managementUnitParamName?: string;
                    landType?: string;
                    landTypeParamName?: string;
                    requestInterceptor?: (request: {
                        url: string;
                        method: import('../../types').GeoJSONRequestMethod;
                        headers: Record<string, string>;
                        params: Record<string, any>;
                        body?: string | Record<string, any>;
                    }, context: import('../../types').GeoJSONRequestContext) => {
                        url?: string;
                        method?: import('../../types').GeoJSONRequestMethod;
                        headers?: Record<string, string>;
                        params?: Record<string, any>;
                        body?: string | Record<string, any>;
                    } | Promise<{
                        url?: string;
                        method?: import('../../types').GeoJSONRequestMethod;
                        headers?: Record<string, string>;
                        params?: Record<string, any>;
                        body?: string | Record<string, any>;
                    }>;
                    responseInterceptor?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                    responseParser?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                };
                dataPath?: string;
                refresh?: {
                    enabled?: boolean;
                    interval?: number;
                    onMoveEnd?: boolean;
                    onZoomEnd?: boolean;
                    debounce?: number;
                    useExtent?: boolean;
                    extentParamName?: string;
                    extentTarget?: "body" | "params";
                    extentProjection?: string;
                };
                clearOnError?: boolean;
            };
            managementUnit?: string;
            geojsonLandType?: string;
            config?: {
                wms?: {
                    layers: string;
                    format?: string;
                    transparent?: boolean;
                    version?: string;
                    srs?: string;
                    styles?: string;
                    cql_filter?: string;
                    viewparams?: string;
                };
                wmts?: {
                    layer: string;
                    matrixSet: string;
                    format?: string;
                    style?: string;
                };
                vector?: {
                    format?: "GeoJSON" | "KML" | "GPX" | "WKT" | "GML";
                    style?: any;
                    cluster?: boolean;
                    clusterDistance?: number;
                    geojson?: {
                        data?: string | object;
                        request?: {
                            url?: string;
                            method?: import('../../types').GeoJSONRequestMethod;
                            headers?: Record<string, string>;
                            params?: Record<string, any>;
                            body?: string | Record<string, any>;
                            dataPath?: string;
                            managementUnit?: string;
                            managementUnitParamName?: string;
                            landType?: string;
                            landTypeParamName?: string;
                            requestInterceptor?: (request: {
                                url: string;
                                method: import('../../types').GeoJSONRequestMethod;
                                headers: Record<string, string>;
                                params: Record<string, any>;
                                body?: string | Record<string, any>;
                            }, context: import('../../types').GeoJSONRequestContext) => {
                                url?: string;
                                method?: import('../../types').GeoJSONRequestMethod;
                                headers?: Record<string, string>;
                                params?: Record<string, any>;
                                body?: string | Record<string, any>;
                            } | Promise<{
                                url?: string;
                                method?: import('../../types').GeoJSONRequestMethod;
                                headers?: Record<string, string>;
                                params?: Record<string, any>;
                                body?: string | Record<string, any>;
                            }>;
                            responseInterceptor?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                            responseParser?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                        };
                        dataPath?: string;
                        refresh?: {
                            enabled?: boolean;
                            interval?: number;
                            onMoveEnd?: boolean;
                            onZoomEnd?: boolean;
                            debounce?: number;
                            useExtent?: boolean;
                            extentParamName?: string;
                            extentTarget?: "body" | "params";
                            extentProjection?: string;
                        };
                        clearOnError?: boolean;
                    };
                    declutter?: boolean;
                };
                heatmap?: {
                    blur?: number;
                    radius?: number;
                    weight?: string | ((feature: any) => number);
                    gradient?: string[];
                };
                bing?: {
                    key: string;
                    imagerySet: "Aerial" | "AerialWithLabels" | "Road" | "OrdnanceSurvey" | "CollinsBart";
                };
                google?: {
                    mapType: "hybrid" | "roadmap" | "satellite" | "terrain";
                };
                arcgis?: {
                    params?: Record<string, any>;
                    ratio?: number;
                };
                mapbox?: {
                    accessToken: string;
                    styleId: string;
                    username?: string;
                };
                xyz?: {
                    minZoom?: number;
                    maxZoom?: number;
                    tileSize?: number;
                    crossOrigin?: string;
                };
                webgl?: {
                    vertexShader?: string;
                    fragmentShader?: string;
                    uniforms?: Record<string, any>;
                };
                canvas?: {
                    canvasFunction?: (extent: number[], resolution: number, pixelRatio: number, size: number[], projection: any) => HTMLCanvasElement;
                    ratio?: number;
                };
                graticule?: {
                    strokeStyle?: any;
                    maxLines?: number;
                    targetSize?: number;
                    showLabels?: boolean;
                    lonLabelFormatter?: (lon: number) => string;
                    latLabelFormatter?: (lat: number) => string;
                };
                wfs?: {
                    version?: string;
                    featureNS?: string;
                    featureType?: string;
                    featurePrefix?: string;
                    gmlFormat?: any;
                    className?: string;
                    strategy?: "all" | "bbox";
                    usePostMethod?: boolean;
                    outputFormat?: string;
                    srsName?: string;
                    customParams?: Record<string, any>;
                    geometryName?: string;
                    filters?: {
                        type: "equalTo" | "like";
                        property: string;
                        value: any;
                    }[];
                };
                geojson?: {
                    data?: string | object;
                    request?: {
                        url?: string;
                        method?: import('../../types').GeoJSONRequestMethod;
                        headers?: Record<string, string>;
                        params?: Record<string, any>;
                        body?: string | Record<string, any>;
                        dataPath?: string;
                        managementUnit?: string;
                        managementUnitParamName?: string;
                        landType?: string;
                        landTypeParamName?: string;
                        requestInterceptor?: (request: {
                            url: string;
                            method: import('../../types').GeoJSONRequestMethod;
                            headers: Record<string, string>;
                            params: Record<string, any>;
                            body?: string | Record<string, any>;
                        }, context: import('../../types').GeoJSONRequestContext) => {
                            url?: string;
                            method?: import('../../types').GeoJSONRequestMethod;
                            headers?: Record<string, string>;
                            params?: Record<string, any>;
                            body?: string | Record<string, any>;
                        } | Promise<{
                            url?: string;
                            method?: import('../../types').GeoJSONRequestMethod;
                            headers?: Record<string, string>;
                            params?: Record<string, any>;
                            body?: string | Record<string, any>;
                        }>;
                        responseInterceptor?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                        responseParser?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                    };
                    dataPath?: string;
                    refresh?: {
                        enabled?: boolean;
                        interval?: number;
                        onMoveEnd?: boolean;
                        onZoomEnd?: boolean;
                        debounce?: number;
                        useExtent?: boolean;
                        extentParamName?: string;
                        extentTarget?: "body" | "params";
                        extentProjection?: string;
                    };
                    clearOnError?: boolean;
                };
            };
            filterLogic?: import('../../types').FilterLogic;
            wmsLayers?: string;
            wmsFormat?: string;
            wmsVersion?: string;
            params?: Record<string, any>;
            layerName?: string;
            serviceStyle?: string;
            format?: string;
            matrixSet?: string;
            resolutions?: number[];
            matrixIds?: string[];
            origin?: [number, number];
            wmtsConfig?: {
                url?: string;
                layer?: string;
                matrixSet?: string;
                style?: string;
                format?: string;
                version?: string;
                projection?: string;
                projectionDefinition?: string;
                origin?: [number, number];
                resolutions?: number[];
                matrixIds?: string[];
                tileSize?: number | [number, number];
            };
            bingKey?: string;
            bingImagerySet?: string;
            vectorFormat?: string;
            vectorColor?: string;
            data?: any;
            gmlConfig?: {
                version?: string;
                srsName?: string;
                className?: string;
            };
            wktConfig?: {
                wktString?: string;
                splitCollection?: boolean;
            };
            wfsConfig?: {
                version?: string;
                featureNS?: string;
                featureType?: string;
                featurePrefix?: string;
                gmlFormat?: any;
                className?: string;
                strategy?: "all" | "bbox";
                usePostMethod?: boolean;
                outputFormat?: string;
                srsName?: string;
                customParams?: Record<string, any>;
                geometryName?: string;
                filters?: {
                    type: "equalTo" | "like";
                    property: string;
                    value: any;
                }[];
            };
            supermapConfig?: {
                queryMethod?: "point" | "buffer";
                bufferDistance?: number;
                datasetNames?: string[];
                featureServiceUrl?: string;
            };
            clusterDistance?: number;
            minDistance?: number;
            heatmapBlur?: number;
            heatmapRadius?: number;
            xyzMinZoom?: number;
            xyzMaxZoom?: number;
            center?: [number, number];
            locationAnimation?: {
                enabled?: boolean;
                duration?: number;
                easing?: "ease-out" | "linear" | "ease" | "ease-in" | "ease-in-out";
                maxZoom?: number;
                padding?: [number, number, number, number];
            };
            style?: {
                "fill-color"?: string | {
                    setTransform: (transform?: DOMMatrix2DInit) => void;
                } | {
                    addColorStop: (offset: number, color: string) => void;
                };
                "stroke-color"?: string | {
                    setTransform: (transform?: DOMMatrix2DInit) => void;
                } | {
                    addColorStop: (offset: number, color: string) => void;
                };
                "stroke-width"?: number;
                "text-color"?: string | {
                    setTransform: (transform?: DOMMatrix2DInit) => void;
                } | {
                    addColorStop: (offset: number, color: string) => void;
                };
                "text-size"?: number;
                "text-font"?: string;
                mixBlendMode?: GlobalCompositeOperation;
                filter?: string;
                fill?: {
                    color?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    opacity?: number;
                };
                stroke?: {
                    color?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    width?: number;
                    lineDash?: number[];
                };
                circle?: {
                    radius?: number;
                    fill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        opacity?: number;
                    };
                    stroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                    };
                };
                text?: {
                    text?: string;
                    field?: string;
                    template?: string;
                    fill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                    };
                    stroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                    };
                    font?: string;
                    fontSize?: number;
                    fontFamily?: string;
                    fontWeight?: string;
                    offsetX?: number;
                    offsetY?: number;
                    scale?: number;
                    textAlign?: CanvasTextAlign;
                    textBaseline?: CanvasTextBaseline;
                    rotation?: number;
                    backgroundFill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                    };
                    backgroundStroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                    };
                    padding?: [number, number, number, number];
                    overflow?: boolean;
                };
            };
            styleFunction?: (feature: any, resolution: number) => any;
            cssClass?: string;
            className?: string;
            fitToExtent?: boolean;
            highlight?: {
                enabled?: boolean;
                style?: {
                    fill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        opacity?: number;
                    };
                    stroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                        lineDash?: number[];
                    };
                    fillColor?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    strokeColor?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    strokeWidth?: number;
                    lineDash?: number[];
                    circle?: {
                        radius?: number;
                        fill?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                            opacity?: number;
                        };
                        stroke?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                            width?: number;
                        };
                    };
                    text?: {
                        font?: string;
                        fill?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                        };
                        stroke?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                            width?: number;
                        };
                        offsetX?: number;
                        offsetY?: number;
                        scale?: number;
                    };
                };
                duration?: number;
                fadeOut?: boolean;
                clearOthersOnHighlight?: boolean;
            };
            popup?: Record<string, string> | {
                type: "html";
                content: string | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string);
                template?: {
                    title?: string;
                    body?: string;
                };
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "image";
                images: string[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string[]);
                title?: string;
                description?: string;
                showThumbnails?: boolean;
                allowZoom?: boolean;
                slideshow?: boolean;
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "array";
                fields: {
                    key?: string;
                    name?: string;
                    label: string;
                    type?: "number" | "boolean" | "image" | "text" | "date" | "link";
                    format?: string | ((value: any) => string);
                    visible?: boolean | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>) => boolean);
                    sortable?: boolean;
                    width?: string | number;
                }[];
                title?: string;
                description?: string;
                showHeader?: boolean;
                striped?: boolean;
                bordered?: boolean;
                compact?: boolean;
                allowViewSwitch?: boolean;
                defaultView?: "table" | "list" | "card";
                searchable?: boolean;
                showStats?: boolean;
                pagination?: boolean;
                pageSize?: number;
                data?: any[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => any[]);
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "all";
                title?: string;
                excludeFields?: string[];
                includeFields?: string[];
                fieldLabels?: Record<string, string>;
                showEmpty?: boolean;
                groupBy?: string;
                htmlContent?: string | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string);
                images?: string[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string[]);
                data?: any[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => any[]);
                fields?: {
                    key?: string;
                    name?: string;
                    label: string;
                    type?: "number" | "boolean" | "image" | "text" | "date" | "link";
                    format?: string | ((value: any) => string);
                    visible?: boolean | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>) => boolean);
                    sortable?: boolean;
                    width?: string | number;
                }[];
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "custom";
                component: any;
                props?: Record<string, any> | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => Record<string, any>);
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            };
            isBasemap?: boolean;
            isCompare?: boolean;
            filters?: ({
                type: import("../../types").FilterType.ATTRIBUTE;
                property: string;
                operator: import('../../types').FilterOperator;
                value: any;
                caseSensitive?: boolean;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            } | {
                type: import("../../types").FilterType.SPATIAL;
                spatialType: import('../../types').SpatialFilterType;
                geometry: any;
                srid?: string;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            } | {
                type: import("../../types").FilterType.CQL;
                cqlExpression: string;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            } | {
                type: import("../../types").FilterType.CUSTOM;
                filterFunction: (feature: any) => boolean;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            })[];
            reuseId?: string;
            customCss?: string;
            baseImgUrl?: string;
            attribution?: string;
            minZoom?: number;
            maxZoom?: number;
        }[];
        layerGroups: any;
        onTreeCheck: (data: any, ctx?: any) => void;
        handleLayerVisibilityChange: (layer: LayerConfig) => Promise<void>;
        updateLayerOpacity: (layerData: any) => void;
        updateClusterDistance: (layerData: any) => void;
        updateSuperMapConfig: (layerData: any) => void;
        resetLayerStyle: (layerData: any) => void;
        layerManager: any;
        layerTreeManager: LayerTreeManager;
        layerConfigManager: LayerConfigManager;
        treeRef: any;
        treeData: import('../../core/LayerTreeManager').TreeNodeData[];
        treeProps: {
            children: string;
            label: string;
        };
        defaultExpandedKeys: string[];
        defaultCheckedKeys: string[];
        syncTreeCheckedState: () => void;
        getAllTreeNodes: (nodes: any[]) => any[];
        onNodeExpand: (data: any) => void;
    }): any;
    default?(_: {
        layers: {
            id: string;
            name: string;
            type: string;
            url?: string;
            method?: import('../../types').GeoJSONRequestMethod;
            headers?: Record<string, string>;
            body?: string | Record<string, any>;
            dataPath?: string;
            visible: boolean;
            opacity: number;
            zIndex: number;
            extent?: [number, number, number, number];
            canvasConfig?: any;
            source?: any;
            layer?: unknown;
            legend?: {
                type?: "symbol" | "custom" | "color" | "icon" | "simple" | "gradient" | "category";
                items: {
                    label: string;
                    value?: string | number;
                    color?: string;
                    symbol?: "circle" | "line" | "polygon" | "square" | "triangle";
                    image?: string;
                    shape?: "circle" | "square" | "triangle";
                    size?: number;
                    borderColor?: string;
                    pattern?: string;
                }[];
                title?: string;
                position?: "bottom-left" | "bottom-right" | "top-left" | "top-right";
                colors?: string[];
                min?: string | number;
                max?: string | number;
                unit?: string;
                content?: string;
                description?: string;
                visible?: boolean;
                layerId?: string;
            };
            metadata?: Record<string, any>;
            group?: string;
            children?: any[];
            layers?: any[];
            transparent?: boolean;
            cacheEnabled?: boolean;
            autoFetchMetadata?: boolean;
            projection?: string;
            projectionDefinition?: string;
            geojsonConfig?: {
                data?: string | object;
                request?: {
                    url?: string;
                    method?: import('../../types').GeoJSONRequestMethod;
                    headers?: Record<string, string>;
                    params?: Record<string, any>;
                    body?: string | Record<string, any>;
                    dataPath?: string;
                    managementUnit?: string;
                    managementUnitParamName?: string;
                    landType?: string;
                    landTypeParamName?: string;
                    requestInterceptor?: (request: {
                        url: string;
                        method: import('../../types').GeoJSONRequestMethod;
                        headers: Record<string, string>;
                        params: Record<string, any>;
                        body?: string | Record<string, any>;
                    }, context: import('../../types').GeoJSONRequestContext) => {
                        url?: string;
                        method?: import('../../types').GeoJSONRequestMethod;
                        headers?: Record<string, string>;
                        params?: Record<string, any>;
                        body?: string | Record<string, any>;
                    } | Promise<{
                        url?: string;
                        method?: import('../../types').GeoJSONRequestMethod;
                        headers?: Record<string, string>;
                        params?: Record<string, any>;
                        body?: string | Record<string, any>;
                    }>;
                    responseInterceptor?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                    responseParser?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                };
                dataPath?: string;
                refresh?: {
                    enabled?: boolean;
                    interval?: number;
                    onMoveEnd?: boolean;
                    onZoomEnd?: boolean;
                    debounce?: number;
                    useExtent?: boolean;
                    extentParamName?: string;
                    extentTarget?: "body" | "params";
                    extentProjection?: string;
                };
                clearOnError?: boolean;
            };
            managementUnit?: string;
            geojsonLandType?: string;
            config?: {
                wms?: {
                    layers: string;
                    format?: string;
                    transparent?: boolean;
                    version?: string;
                    srs?: string;
                    styles?: string;
                    cql_filter?: string;
                    viewparams?: string;
                };
                wmts?: {
                    layer: string;
                    matrixSet: string;
                    format?: string;
                    style?: string;
                };
                vector?: {
                    format?: "GeoJSON" | "KML" | "GPX" | "WKT" | "GML";
                    style?: any;
                    cluster?: boolean;
                    clusterDistance?: number;
                    geojson?: {
                        data?: string | object;
                        request?: {
                            url?: string;
                            method?: import('../../types').GeoJSONRequestMethod;
                            headers?: Record<string, string>;
                            params?: Record<string, any>;
                            body?: string | Record<string, any>;
                            dataPath?: string;
                            managementUnit?: string;
                            managementUnitParamName?: string;
                            landType?: string;
                            landTypeParamName?: string;
                            requestInterceptor?: (request: {
                                url: string;
                                method: import('../../types').GeoJSONRequestMethod;
                                headers: Record<string, string>;
                                params: Record<string, any>;
                                body?: string | Record<string, any>;
                            }, context: import('../../types').GeoJSONRequestContext) => {
                                url?: string;
                                method?: import('../../types').GeoJSONRequestMethod;
                                headers?: Record<string, string>;
                                params?: Record<string, any>;
                                body?: string | Record<string, any>;
                            } | Promise<{
                                url?: string;
                                method?: import('../../types').GeoJSONRequestMethod;
                                headers?: Record<string, string>;
                                params?: Record<string, any>;
                                body?: string | Record<string, any>;
                            }>;
                            responseInterceptor?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                            responseParser?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                        };
                        dataPath?: string;
                        refresh?: {
                            enabled?: boolean;
                            interval?: number;
                            onMoveEnd?: boolean;
                            onZoomEnd?: boolean;
                            debounce?: number;
                            useExtent?: boolean;
                            extentParamName?: string;
                            extentTarget?: "body" | "params";
                            extentProjection?: string;
                        };
                        clearOnError?: boolean;
                    };
                    declutter?: boolean;
                };
                heatmap?: {
                    blur?: number;
                    radius?: number;
                    weight?: string | ((feature: any) => number);
                    gradient?: string[];
                };
                bing?: {
                    key: string;
                    imagerySet: "Aerial" | "AerialWithLabels" | "Road" | "OrdnanceSurvey" | "CollinsBart";
                };
                google?: {
                    mapType: "hybrid" | "roadmap" | "satellite" | "terrain";
                };
                arcgis?: {
                    params?: Record<string, any>;
                    ratio?: number;
                };
                mapbox?: {
                    accessToken: string;
                    styleId: string;
                    username?: string;
                };
                xyz?: {
                    minZoom?: number;
                    maxZoom?: number;
                    tileSize?: number;
                    crossOrigin?: string;
                };
                webgl?: {
                    vertexShader?: string;
                    fragmentShader?: string;
                    uniforms?: Record<string, any>;
                };
                canvas?: {
                    canvasFunction?: (extent: number[], resolution: number, pixelRatio: number, size: number[], projection: any) => HTMLCanvasElement;
                    ratio?: number;
                };
                graticule?: {
                    strokeStyle?: any;
                    maxLines?: number;
                    targetSize?: number;
                    showLabels?: boolean;
                    lonLabelFormatter?: (lon: number) => string;
                    latLabelFormatter?: (lat: number) => string;
                };
                wfs?: {
                    version?: string;
                    featureNS?: string;
                    featureType?: string;
                    featurePrefix?: string;
                    gmlFormat?: any;
                    className?: string;
                    strategy?: "all" | "bbox";
                    usePostMethod?: boolean;
                    outputFormat?: string;
                    srsName?: string;
                    customParams?: Record<string, any>;
                    geometryName?: string;
                    filters?: {
                        type: "equalTo" | "like";
                        property: string;
                        value: any;
                    }[];
                };
                geojson?: {
                    data?: string | object;
                    request?: {
                        url?: string;
                        method?: import('../../types').GeoJSONRequestMethod;
                        headers?: Record<string, string>;
                        params?: Record<string, any>;
                        body?: string | Record<string, any>;
                        dataPath?: string;
                        managementUnit?: string;
                        managementUnitParamName?: string;
                        landType?: string;
                        landTypeParamName?: string;
                        requestInterceptor?: (request: {
                            url: string;
                            method: import('../../types').GeoJSONRequestMethod;
                            headers: Record<string, string>;
                            params: Record<string, any>;
                            body?: string | Record<string, any>;
                        }, context: import('../../types').GeoJSONRequestContext) => {
                            url?: string;
                            method?: import('../../types').GeoJSONRequestMethod;
                            headers?: Record<string, string>;
                            params?: Record<string, any>;
                            body?: string | Record<string, any>;
                        } | Promise<{
                            url?: string;
                            method?: import('../../types').GeoJSONRequestMethod;
                            headers?: Record<string, string>;
                            params?: Record<string, any>;
                            body?: string | Record<string, any>;
                        }>;
                        responseInterceptor?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                        responseParser?: (response: any, context: import('../../types').GeoJSONRequestContext) => any;
                    };
                    dataPath?: string;
                    refresh?: {
                        enabled?: boolean;
                        interval?: number;
                        onMoveEnd?: boolean;
                        onZoomEnd?: boolean;
                        debounce?: number;
                        useExtent?: boolean;
                        extentParamName?: string;
                        extentTarget?: "body" | "params";
                        extentProjection?: string;
                    };
                    clearOnError?: boolean;
                };
            };
            filterLogic?: import('../../types').FilterLogic;
            wmsLayers?: string;
            wmsFormat?: string;
            wmsVersion?: string;
            params?: Record<string, any>;
            layerName?: string;
            serviceStyle?: string;
            format?: string;
            matrixSet?: string;
            resolutions?: number[];
            matrixIds?: string[];
            origin?: [number, number];
            wmtsConfig?: {
                url?: string;
                layer?: string;
                matrixSet?: string;
                style?: string;
                format?: string;
                version?: string;
                projection?: string;
                projectionDefinition?: string;
                origin?: [number, number];
                resolutions?: number[];
                matrixIds?: string[];
                tileSize?: number | [number, number];
            };
            bingKey?: string;
            bingImagerySet?: string;
            vectorFormat?: string;
            vectorColor?: string;
            data?: any;
            gmlConfig?: {
                version?: string;
                srsName?: string;
                className?: string;
            };
            wktConfig?: {
                wktString?: string;
                splitCollection?: boolean;
            };
            wfsConfig?: {
                version?: string;
                featureNS?: string;
                featureType?: string;
                featurePrefix?: string;
                gmlFormat?: any;
                className?: string;
                strategy?: "all" | "bbox";
                usePostMethod?: boolean;
                outputFormat?: string;
                srsName?: string;
                customParams?: Record<string, any>;
                geometryName?: string;
                filters?: {
                    type: "equalTo" | "like";
                    property: string;
                    value: any;
                }[];
            };
            supermapConfig?: {
                queryMethod?: "point" | "buffer";
                bufferDistance?: number;
                datasetNames?: string[];
                featureServiceUrl?: string;
            };
            clusterDistance?: number;
            minDistance?: number;
            heatmapBlur?: number;
            heatmapRadius?: number;
            xyzMinZoom?: number;
            xyzMaxZoom?: number;
            center?: [number, number];
            locationAnimation?: {
                enabled?: boolean;
                duration?: number;
                easing?: "ease-out" | "linear" | "ease" | "ease-in" | "ease-in-out";
                maxZoom?: number;
                padding?: [number, number, number, number];
            };
            style?: {
                "fill-color"?: string | {
                    setTransform: (transform?: DOMMatrix2DInit) => void;
                } | {
                    addColorStop: (offset: number, color: string) => void;
                };
                "stroke-color"?: string | {
                    setTransform: (transform?: DOMMatrix2DInit) => void;
                } | {
                    addColorStop: (offset: number, color: string) => void;
                };
                "stroke-width"?: number;
                "text-color"?: string | {
                    setTransform: (transform?: DOMMatrix2DInit) => void;
                } | {
                    addColorStop: (offset: number, color: string) => void;
                };
                "text-size"?: number;
                "text-font"?: string;
                mixBlendMode?: GlobalCompositeOperation;
                filter?: string;
                fill?: {
                    color?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    opacity?: number;
                };
                stroke?: {
                    color?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    width?: number;
                    lineDash?: number[];
                };
                circle?: {
                    radius?: number;
                    fill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        opacity?: number;
                    };
                    stroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                    };
                };
                text?: {
                    text?: string;
                    field?: string;
                    template?: string;
                    fill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                    };
                    stroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                    };
                    font?: string;
                    fontSize?: number;
                    fontFamily?: string;
                    fontWeight?: string;
                    offsetX?: number;
                    offsetY?: number;
                    scale?: number;
                    textAlign?: CanvasTextAlign;
                    textBaseline?: CanvasTextBaseline;
                    rotation?: number;
                    backgroundFill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                    };
                    backgroundStroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                    };
                    padding?: [number, number, number, number];
                    overflow?: boolean;
                };
            };
            styleFunction?: (feature: any, resolution: number) => any;
            cssClass?: string;
            className?: string;
            fitToExtent?: boolean;
            highlight?: {
                enabled?: boolean;
                style?: {
                    fill?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        opacity?: number;
                    };
                    stroke?: {
                        color?: string | {
                            setTransform: (transform?: DOMMatrix2DInit) => void;
                        } | {
                            addColorStop: (offset: number, color: string) => void;
                        };
                        width?: number;
                        lineDash?: number[];
                    };
                    fillColor?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    strokeColor?: string | {
                        setTransform: (transform?: DOMMatrix2DInit) => void;
                    } | {
                        addColorStop: (offset: number, color: string) => void;
                    };
                    strokeWidth?: number;
                    lineDash?: number[];
                    circle?: {
                        radius?: number;
                        fill?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                            opacity?: number;
                        };
                        stroke?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                            width?: number;
                        };
                    };
                    text?: {
                        font?: string;
                        fill?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                        };
                        stroke?: {
                            color?: string | {
                                setTransform: (transform?: DOMMatrix2DInit) => void;
                            } | {
                                addColorStop: (offset: number, color: string) => void;
                            };
                            width?: number;
                        };
                        offsetX?: number;
                        offsetY?: number;
                        scale?: number;
                    };
                };
                duration?: number;
                fadeOut?: boolean;
                clearOthersOnHighlight?: boolean;
            };
            popup?: Record<string, string> | {
                type: "html";
                content: string | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string);
                template?: {
                    title?: string;
                    body?: string;
                };
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "image";
                images: string[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string[]);
                title?: string;
                description?: string;
                showThumbnails?: boolean;
                allowZoom?: boolean;
                slideshow?: boolean;
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "array";
                fields: {
                    key?: string;
                    name?: string;
                    label: string;
                    type?: "number" | "boolean" | "image" | "text" | "date" | "link";
                    format?: string | ((value: any) => string);
                    visible?: boolean | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>) => boolean);
                    sortable?: boolean;
                    width?: string | number;
                }[];
                title?: string;
                description?: string;
                showHeader?: boolean;
                striped?: boolean;
                bordered?: boolean;
                compact?: boolean;
                allowViewSwitch?: boolean;
                defaultView?: "table" | "list" | "card";
                searchable?: boolean;
                showStats?: boolean;
                pagination?: boolean;
                pageSize?: number;
                data?: any[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => any[]);
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "all";
                title?: string;
                excludeFields?: string[];
                includeFields?: string[];
                fieldLabels?: Record<string, string>;
                showEmpty?: boolean;
                groupBy?: string;
                htmlContent?: string | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string);
                images?: string[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => string[]);
                data?: any[] | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => any[]);
                fields?: {
                    key?: string;
                    name?: string;
                    label: string;
                    type?: "number" | "boolean" | "image" | "text" | "date" | "link";
                    format?: string | ((value: any) => string);
                    visible?: boolean | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>) => boolean);
                    sortable?: boolean;
                    width?: string | number;
                }[];
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            } | {
                type: "custom";
                component: any;
                props?: Record<string, any> | ((feature: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate: import('ol/coordinate').Coordinate) => Record<string, any>);
                position?: "auto" | "top" | "bottom" | "left" | "right";
                showCloseButton?: boolean;
                maxWidth?: number;
                maxHeight?: number;
                offset?: [number, number];
                className?: string;
                closable?: boolean;
                autoPan?: boolean;
                vertical?: boolean;
                priorityMode?: boolean;
                autoPanAnimation?: {
                    duration?: number;
                    source?: number[];
                };
                events?: {
                    [x: string]: any;
                    onRowClick?: (item: any, index: number) => void;
                    onClose?: () => void;
                };
                maxPopups?: number;
                defaultConfig?: {
                    type?: import('../OlMapPopup').PopupType;
                    position?: "auto" | "top" | "bottom" | "left" | "right";
                    showCloseButton?: boolean;
                    maxWidth?: number;
                    maxHeight?: number;
                    offset?: [number, number];
                    className?: string;
                    closable?: boolean;
                    autoPan?: boolean;
                    vertical?: boolean;
                    priorityMode?: boolean;
                    autoPanAnimation?: {
                        duration?: number;
                        source?: number[];
                    };
                    events?: {
                        [x: string]: any;
                        onRowClick?: (item: any, index: number) => void;
                        onClose?: () => void;
                    };
                };
                container?: HTMLElement;
                zIndex?: number;
                autoClose?: boolean;
                closeOnMapClick?: boolean;
                onShow?: (id: string, config: import('../OlMapPopup').PopupConfig, feature?: import('ol/Feature').default<import('ol/geom/Geometry').default>, coordinate?: import('ol/coordinate').Coordinate) => void;
                onHide?: (id: string) => void;
                onClose?: (id: string) => void;
            };
            isBasemap?: boolean;
            isCompare?: boolean;
            filters?: ({
                type: import("../../types").FilterType.ATTRIBUTE;
                property: string;
                operator: import('../../types').FilterOperator;
                value: any;
                caseSensitive?: boolean;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            } | {
                type: import("../../types").FilterType.SPATIAL;
                spatialType: import('../../types').SpatialFilterType;
                geometry: any;
                srid?: string;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            } | {
                type: import("../../types").FilterType.CQL;
                cqlExpression: string;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            } | {
                type: import("../../types").FilterType.CUSTOM;
                filterFunction: (feature: any) => boolean;
                id: string;
                enabled: boolean;
                name?: string;
                description?: string;
            })[];
            reuseId?: string;
            customCss?: string;
            baseImgUrl?: string;
            attribution?: string;
            minZoom?: number;
            maxZoom?: number;
        }[];
        layerGroups: any;
        onTreeCheck: (data: any, ctx?: any) => void;
        handleLayerVisibilityChange: (layer: LayerConfig) => Promise<void>;
        updateLayerOpacity: (layerData: any) => void;
        updateClusterDistance: (layerData: any) => void;
        updateSuperMapConfig: (layerData: any) => void;
        resetLayerStyle: (layerData: any) => void;
        layerManager: any;
        layerTreeManager: LayerTreeManager;
        layerConfigManager: LayerConfigManager;
        treeRef: any;
        treeData: import('../../core/LayerTreeManager').TreeNodeData[];
        treeProps: {
            children: string;
            label: string;
        };
        defaultExpandedKeys: string[];
        defaultCheckedKeys: string[];
        syncTreeCheckedState: () => void;
        getAllTreeNodes: (nodes: any[]) => any[];
        onNodeExpand: (data: any) => void;
    }): any;
}>;
export default _default;
type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: import('vue').PropType<T[K]>;
        required: true;
    };
};
type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};
//# sourceMappingURL=LayerPanel.vue.d.ts.map