import { Extent } from 'ol/extent';
import { Props } from './interface';
import { useMapInitializer } from './function/map';
import { useCarTrackManager } from './function/carTrack';
import { useTrackManager } from './function/shipTrack';
import { useShipManager } from './function/ship';
import { convertSixHundredThousandToLatLng, calculateCirclePoints } from './utils/track';
import { useLayerManager } from './function/layers';
import { usePositionManager } from './function/position';
import { useDrawLineManager } from './function/drawLine';
import { useDrawPolygonManager } from './function/drawPolygon';
import { usePortManager } from './function/port';
import { useWharfManager } from './function/wharf';
import { default as Map } from 'ol/Map';
type PortMethods = Pick<ReturnType<typeof usePortManager>, "render" | "clear" | "selected" | "setRed" | "clearNonRed" | "clearRed">;
type MapMethods = ReturnType<typeof useMapInitializer> & {
    layer: ReturnType<typeof useLayerManager>;
    ship: ReturnType<typeof useShipManager>;
    track: ReturnType<typeof useTrackManager>;
    carTrack: ReturnType<typeof useCarTrackManager>;
    port: PortMethods;
    position: ReturnType<typeof usePositionManager>;
    drawLine: ReturnType<typeof useDrawLineManager>;
    drawPolygon: ReturnType<typeof useDrawPolygonManager>;
    wharf: ReturnType<typeof useWharfManager>;
    utils: {
        getCalculateExtent: () => Extent;
        convertSixHundredThousandToLatLng: typeof convertSixHundredThousandToLatLng;
        calculateCirclePoints: typeof calculateCirclePoints;
    };
};
export interface MapInstance {
    id: symbol;
    map: Map;
    destroy: () => void;
    methods: MapMethods;
}
export declare const useMapController: () => {
    createInstance: (element: HTMLDivElement, props: Props) => MapInstance;
    destroyInstance: (id: symbol) => void;
    destroyAll: () => void;
    getAllInstances: () => {
        id: symbol;
        map: {
            on: import('ol/Map').MapEventHandler<import('ol/events').EventsKey>;
            once: import('ol/Map').MapEventHandler<import('ol/events').EventsKey>;
            un: import('ol/Map').MapEventHandler<void>;
            viewport_: HTMLDivElement | undefined;
            addControl: (control: import('ol/control').default) => void;
            addInteraction: (interaction: import('ol/interaction').default) => void;
            addLayer: (layer: import('ol/layer/Base').default) => void;
            addOverlay: (overlay: import('ol').default) => void;
            forEachFeatureAtPixel: <T>(pixel: import('ol/pixel').Pixel, callback: (arg0: import('ol/Feature').FeatureLike, arg1: import('ol/layer').default<import('ol/source').default>, arg2: import('ol/geom').default) => T, options?: import('ol/Map').AtPixelOptions) => T | undefined;
            getFeaturesAtPixel: (pixel: import('ol/pixel').Pixel, options?: import('ol/Map').AtPixelOptions) => Array<import('ol/Feature').FeatureLike>;
            getAllLayers: () => Array<import('ol/layer').default>;
            hasFeatureAtPixel: (pixel: import('ol/pixel').Pixel, options?: import('ol/Map').AtPixelOptions) => boolean;
            getEventCoordinate: (event: MouseEvent) => import('ol/coordinate').Coordinate;
            getEventCoordinateInternal: (event: MouseEvent) => import('ol/coordinate').Coordinate;
            getEventPixel: (event: UIEvent | {
                clientX: number;
                clientY: number;
            }) => import('ol/pixel').Pixel;
            getTarget: () => HTMLElement | string | undefined;
            getTargetElement: () => HTMLElement;
            getCoordinateFromPixel: (pixel: import('ol/pixel').Pixel) => import('ol/coordinate').Coordinate;
            getCoordinateFromPixelInternal: (pixel: import('ol/pixel').Pixel) => import('ol/coordinate').Coordinate;
            getControls: () => import('ol').Collection<import('ol/control').default>;
            getOverlays: () => import('ol').Collection<import('ol').default>;
            getOverlayById: (id: string | number) => import('ol').default | null;
            getInteractions: () => import('ol').Collection<import('ol/interaction').default>;
            getLayerGroup: () => import('ol/layer').Group;
            setLayers: (layers: Array<import('ol/layer/Base').default> | import('ol').Collection<import('ol/layer/Base').default>) => void;
            getLayers: () => import('ol').Collection<import('ol/layer/Base').default>;
            getLoadingOrNotReady: () => boolean;
            getPixelFromCoordinate: (coordinate: import('ol/coordinate').Coordinate) => import('ol/pixel').Pixel;
            getPixelFromCoordinateInternal: (coordinate: import('ol/coordinate').Coordinate) => import('ol/pixel').Pixel;
            getPixelRatio: () => number;
            setPixelRatio: (pixelRatio: number) => void;
            getRenderer: () => import('ol/renderer/Map').default | null;
            getSize: () => import('ol/size').Size | undefined;
            getView: () => import('ol').View;
            getViewport: () => HTMLElement;
            getOverlayContainer: () => HTMLElement;
            getOverlayContainerStopEvent: () => HTMLElement;
            getOwnerDocument: () => Document;
            getTilePriority: (tile: import('ol').default, tileSourceKey: string, tileCenter: import('ol/coordinate').Coordinate, tileResolution: number) => number;
            handleBrowserEvent: (browserEvent: PointerEvent | KeyboardEvent | WheelEvent, type?: string) => void;
            handleMapBrowserEvent: (mapBrowserEvent: import('ol').MapBrowserEvent) => void;
            isRendered: () => boolean;
            renderSync: () => void;
            redrawText: () => void;
            render: () => void;
            removeControl: (control: import('ol/control').default) => import('ol/control').default | undefined;
            removeInteraction: (interaction: import('ol/interaction').default) => import('ol/interaction').default | undefined;
            removeLayer: (layer: import('ol/layer/Base').default) => import('ol/layer/Base').default | undefined;
            removeOverlay: (overlay: import('ol').default) => import('ol').default | undefined;
            setLayerGroup: (layerGroup: import('ol/layer').Group) => void;
            setSize: (size: import('ol/size').Size | undefined) => void;
            setTarget: (target?: HTMLElement | string) => void;
            setView: (view: import('ol').View | Promise<import('ol/View').ViewOptions> | null) => void;
            updateSize: () => void;
            get: (key: string) => any;
            getKeys: () => Array<string>;
            getProperties: () => NoInfer<{
                [x: string]: any;
            }>;
            getPropertiesInternal: () => Partial<NoInfer<{
                [x: string]: any;
            }>> | null;
            hasProperties: () => boolean;
            notify: (key: string, oldValue: any) => void;
            addChangeListener: (key: string, listener: import('ol/events').Listener) => void;
            removeChangeListener: (key: string, listener: import('ol/events').Listener) => void;
            set: (key: string, value: any, silent?: boolean) => void;
            setProperties: (values: Partial<NoInfer<{
                [x: string]: any;
            }>>, silent?: boolean) => void;
            unset: (key: string, silent?: boolean) => void;
            changed: () => void;
            getRevision: () => number;
            addEventListener: (type: string, listener: import('ol/events').Listener) => void;
            dispatchEvent: (event: import('ol/events/Event').default | string) => boolean | undefined;
            getListeners: (type: string) => Array<import('ol/events').Listener> | undefined;
            hasListener: (type?: string) => boolean;
            removeEventListener: (type: string, listener: import('ol/events').Listener) => void;
            dispose: () => void;
        };
        destroy: () => void;
        methods: {
            getInstall: () => Map;
            getView: () => import('ol').View;
            getZoom: () => number;
            setZoom: (zoom: number) => void;
            setCenter: (lon: number, lat: number) => void;
            flyTo: (lon: number, lat: number, zoom?: number, duration?: number) => void;
            getCenter: () => import('ol/coordinate').Coordinate;
            getSize: () => number[];
            initMap: (element: HTMLDivElement, props: Props) => void;
            setBaseLayerMap: (props: Props) => void;
            setMapClick: (status: boolean) => void;
            getMapClick: () => boolean;
            layer: {
                getLayers: () => import('ol').Collection<import('ol/layer/Base').default<{
                    [x: string]: any;
                }>>;
                getGreenTileVisible: () => boolean;
                setGreenTileVisible: (show: boolean) => void;
                getShowLayerType: () => "vector" | "satellite" | undefined;
                setShowLayerType: (type: Props["layerType"]) => void;
            };
            ship: {
                render: (shipList: import('./interface').ShipInfoVo[]) => void;
                selected: (ship: import('./interface').ShipInfoVo) => void;
                filter: (shipList: import('./interface').ShipInfoVo[]) => void;
                blinking: (ships: Record<string, boolean>, colors: Record<string, {
                    blinkColors: string[];
                    shipState: string;
                }>) => void;
                clear: () => void;
                setLableStatus: (shipStatus: boolean, followStatus: boolean, selectedStatus: boolean) => void;
                handleShipMapEvent: import('lodash-es').DebouncedFunc<(shipsFeature: import('ol').Feature | null, type: string, callback?: (id: string) => void) => void>;
                changeShipScale: () => void;
            };
            track: {
                render: (id: string, list: import('./interface/shipTrack').ShipTrack[], color: string, options?: {
                    showTime?: boolean;
                    lineWidth?: number;
                    showPopup?: boolean;
                }, type?: string, threshold?: number) => Promise<void>;
                remove: () => void;
                play: (id: number | string, speed: number) => void;
                setCenter: (id?: number | string) => void;
                close: (id?: string) => void;
                getLength: (id: string, unit?: number) => {
                    id: string;
                    length: string;
                };
                handleTrackMapEvent: (trunkFeature: import('ol').Feature | null, type: string, event?: import('ol').MapBrowserEvent<PointerEvent | KeyboardEvent | WheelEvent>) => void;
                reRenderTrackLine: () => void;
                getTrackStatus: () => boolean | null;
            };
            carTrack: {
                location: (vehicleInfo?: import('./interface').VehicleInfo) => Promise<void>;
                remove: () => void;
                renderTrack: (vclN: string, list: import('./interface/shipTrack').ShipTrack[], color: string, interval?: number) => void;
                setCenter: (id: string | number) => void;
                closeTrack: () => void;
                playTrack: (id: number | string, speed: number) => void;
            };
            port: {
                clear: () => void;
                render: (portList: import('./interface').WharfEntity[], showTitle?: boolean) => void;
                selected: (portData?: import('./interface').WharfEntity) => void;
                setRed: (portData?: import('./interface').WharfEntity) => void;
                clearNonRed: () => void;
                clearRed: () => void;
            };
            position: {
                render: (portList: import('./interface').LocationEntity[]) => void;
                renderHtml: (id: string, lonLat: [number, number], html: string, options: {
                    positioning?: "top-left" | "bottom-left" | "bottom-center" | "bottom-right" | "center-left" | "center-center" | "center-right" | "top-center" | "top-right";
                    offset?: number[];
                }) => void;
                removeHtml: (id: string) => void;
                selected: (loactionData?: import('./interface').LocationEntity) => void;
                clearSelected: () => void;
                clear: () => void;
            };
            drawLine: {
                open: () => void;
                close: () => void;
                deleteLine: (id: string) => void;
                setUnit: (unitValue: string) => void;
                getState: () => "close" | "open";
            };
            drawPolygon: {
                open: () => void;
                close: () => void;
                reset: () => void;
                getState: () => "close" | "open";
            };
            wharf: {
                createWharfLine: (lineData: import('./function/wharf').WharfLineData) => import('ol').Feature<import('ol/geom').LineString, {
                    [x: string]: any;
                }> | null;
                createWharfLines: (linesData: import('./function/wharf').WharfLineData[]) => void;
                createWharfPolygon: (polygonData: import('./function/wharf').WharfPolygonData) => import('ol').Feature<import('ol/geom').Polygon, {
                    [x: string]: any;
                }> | null;
                createWharfPolygons: (polygonsData: import('./function/wharf').WharfPolygonData[]) => void;
                createWharfPoint: (pointData: import('./function/wharf').WharfPointData) => import('ol').Feature<import('ol/geom').Point, {
                    [x: string]: any;
                }> | null;
                createWharfPoints: (pointsData: import('./function/wharf').WharfPointData[]) => void;
                removeWharfLayer: () => void;
                removeWharfLine: (id: string | number) => void;
                removeWharfLines: (ids: (string | number)[]) => void;
                removeWharfPolygon: (id: string | number) => void;
                removeWharfPolygons: (ids: (string | number)[]) => void;
                removeWharfPoint: (id: string | number) => void;
                removeWharfPoints: (ids: (string | number)[]) => void;
                handleWharfHover: (feature: import('ol').Feature | null) => void;
                clearHover: () => void;
                selected: (wharfData?: import('./function/wharf').WharfSelectedData) => void;
                highlightLine: (id: string | number) => void;
                highlightPolygon: (id: string | number) => void;
                highlightPoint: (id: string | number) => void;
                clearHighlightLine: (id: string | number) => void;
                clearHighlightPolygon: (id: string | number) => void;
                clearHighlightPoint: (id: string | number) => void;
                clearAllHighlight: () => void;
                getAllLineFeatures: () => import('ol').Feature<import('ol/geom').LineString>[];
                getAllPolygonFeatures: () => import('ol').Feature<import('ol/geom').Polygon>[];
                getAllPointFeatures: () => import('ol').Feature<import('ol/geom').Point>[];
                getLineFeature: (id: string | number) => import('ol').Feature<import('ol/geom').LineString> | undefined;
                getPolygonFeature: (id: string | number) => import('ol').Feature<import('ol/geom').Polygon> | undefined;
                getPointFeature: (id: string | number) => import('ol').Feature<import('ol/geom').Point> | undefined;
                getSelectedWharf: () => import('./function/wharf').WharfSelectedData | null;
                getLayer: () => import('ol/layer').Vector<import('ol/source').Vector<any>, any>;
                getSource: () => import('ol/source').Vector<import('ol').Feature<import('ol/geom').Geometry, {
                    [x: string]: any;
                }>>;
            };
            utils: {
                getCalculateExtent: () => Extent;
                convertSixHundredThousandToLatLng: typeof convertSixHundredThousandToLatLng;
                calculateCirclePoints: typeof calculateCirclePoints;
            };
        };
    }[];
};
export {};
