import { Props } from './interface';
type ForwardedMethod<Args extends unknown[], Result> = (...args: Args) => Result | undefined;
declare const _default: import('vue').DefineComponent<Props, {
    getZoom: ForwardedMethod<[], number>;
    setZoom: ForwardedMethod<[zoom: number], void>;
    getInstall: ForwardedMethod<[], import('ol').Map>;
    setMapClick: ForwardedMethod<[status: boolean], void>;
    getMapClick: ForwardedMethod<[], boolean>;
    getView: ForwardedMethod<[], import('ol').View>;
    setCenter: ForwardedMethod<[lon: number, lat: number], void>;
    flyTo: ForwardedMethod<[lon: number, lat: number, zoom?: number | undefined, duration?: number | undefined], void>;
    getSize: ForwardedMethod<[], number[]>;
    getCenter: ForwardedMethod<[], import('ol/coordinate').Coordinate>;
    layer: {
        setGreenTileVisible: ForwardedMethod<[show: boolean], void>;
        getGreenTileVisible: ForwardedMethod<[], boolean>;
        getShowLayerType: ForwardedMethod<[], "vector" | "satellite" | undefined>;
        setShowLayerType: ForwardedMethod<[type: "vector" | "satellite" | undefined], void>;
    };
    ship: {
        render: ForwardedMethod<[shipList: import('./interface').ShipInfoVo[]], void>;
        selected: ForwardedMethod<[ship: import('./interface').ShipInfoVo], void>;
        filter: ForwardedMethod<[shipList: import('./interface').ShipInfoVo[]], void>;
        blinking: ForwardedMethod<[ships: Record<string, boolean>, colors: Record<string, {
            blinkColors: string[];
            shipState: string;
        }>], void>;
        clear: ForwardedMethod<[], void>;
        setLableStatus: ForwardedMethod<[shipStatus: boolean, followStatus: boolean, selectedStatus: boolean], void>;
    };
    track: {
        render: ForwardedMethod<[id: string, list: import('./interface/shipTrack').ShipTrack[], color: string, options?: {
            showTime?: boolean;
            lineWidth?: number;
            showPopup?: boolean;
        } | undefined, type?: string | undefined, threshold?: number | undefined], Promise<void>>;
        remove: ForwardedMethod<[], void>;
        play: ForwardedMethod<[id: string | number, speed: number], void>;
        setCenter: ForwardedMethod<[id?: string | number | undefined], void>;
        close: ForwardedMethod<[id?: string | undefined], void>;
        getLength: ForwardedMethod<[id: string, unit?: number | undefined], {
            id: string;
            length: string;
        }>;
    };
    carTrack: {
        location: ForwardedMethod<[vehicleInfo?: import('./interface').VehicleInfo | undefined], Promise<void>>;
        remove: ForwardedMethod<[], void>;
        renderTrack: ForwardedMethod<[vclN: string, list: import('./interface/shipTrack').ShipTrack[], color: string, interval?: number | undefined], void>;
        setCenter: ForwardedMethod<[id: string | number], void>;
        closeTrack: ForwardedMethod<[], void>;
        playTrack: ForwardedMethod<[id: string | number, speed: number], void>;
    };
    port: {
        render: ForwardedMethod<[portList: import('./interface').WharfEntity[], showTitle?: boolean | undefined], void>;
        clear: ForwardedMethod<[], void>;
        selected: ForwardedMethod<[portData?: import('./interface').WharfEntity | undefined], void>;
        setRed: ForwardedMethod<[portData?: import('./interface').WharfEntity | undefined], void>;
        clearRed: ForwardedMethod<[], void>;
        clearNonRed: ForwardedMethod<[], void>;
    };
    position: {
        render: ForwardedMethod<[portList: import('./interface').LocationEntity[]], void>;
        selected: ForwardedMethod<[loactionData?: import('./interface').LocationEntity | undefined], void>;
        clearSelected: ForwardedMethod<[], void>;
        clear: ForwardedMethod<[], void>;
        renderHtml: ForwardedMethod<[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: ForwardedMethod<[id: string], void>;
    };
    drawLine: {
        open: ForwardedMethod<[], void>;
        close: ForwardedMethod<[], void>;
        deleteLine: ForwardedMethod<[id: string], void>;
        setUnit: ForwardedMethod<[unitValue: string], void>;
        getState: ForwardedMethod<[], "close" | "open">;
    };
    drawPolygon: {
        open: ForwardedMethod<[], void>;
        close: ForwardedMethod<[], void>;
        reset: ForwardedMethod<[], void>;
    };
    wharf: {
        createWharfLine: ForwardedMethod<[lineData: import('./function/wharf').WharfLineData], import('ol').Feature<import('ol/geom').LineString, {
            [x: string]: any;
        }> | null>;
        createWharfLines: ForwardedMethod<[linesData: import('./function/wharf').WharfLineData[]], void>;
        createWharfPolygon: ForwardedMethod<[polygonData: import('./function/wharf').WharfPolygonData], import('ol').Feature<import('ol/geom').Polygon, {
            [x: string]: any;
        }> | null>;
        createWharfPolygons: ForwardedMethod<[polygonsData: import('./function/wharf').WharfPolygonData[]], void>;
        createWharfPoint: ForwardedMethod<[pointData: import('./function/wharf').WharfPointData], import('ol').Feature<import('ol/geom').Point, {
            [x: string]: any;
        }> | null>;
        createWharfPoints: ForwardedMethod<[pointsData: import('./function/wharf').WharfPointData[]], void>;
        removeWharfLayer: ForwardedMethod<[], void>;
        removeWharfLine: ForwardedMethod<[id: string | number], void>;
        removeWharfLines: ForwardedMethod<[ids: (string | number)[]], void>;
        removeWharfPolygon: ForwardedMethod<[id: string | number], void>;
        removeWharfPolygons: ForwardedMethod<[ids: (string | number)[]], void>;
        removeWharfPoint: ForwardedMethod<[id: string | number], void>;
        removeWharfPoints: ForwardedMethod<[ids: (string | number)[]], void>;
        handleWharfHover: ForwardedMethod<[feature: import('ol').Feature<import('ol/geom').Geometry, {
            [x: string]: any;
        }> | null], void>;
        clearHover: ForwardedMethod<[], void>;
        selected: ForwardedMethod<[wharfData?: import('./function/wharf').WharfSelectedData | undefined], void>;
        getAllLineFeatures: ForwardedMethod<[], import('ol').Feature<import('ol/geom').LineString, {
            [x: string]: any;
        }>[]>;
        getAllPolygonFeatures: ForwardedMethod<[], import('ol').Feature<import('ol/geom').Polygon, {
            [x: string]: any;
        }>[]>;
        getAllPointFeatures: ForwardedMethod<[], import('ol').Feature<import('ol/geom').Point, {
            [x: string]: any;
        }>[]>;
        getLineFeature: ForwardedMethod<[id: string | number], import('ol').Feature<import('ol/geom').LineString, {
            [x: string]: any;
        }> | undefined>;
        getPolygonFeature: ForwardedMethod<[id: string | number], import('ol').Feature<import('ol/geom').Polygon, {
            [x: string]: any;
        }> | undefined>;
        getPointFeature: ForwardedMethod<[id: string | number], import('ol').Feature<import('ol/geom').Point, {
            [x: string]: any;
        }> | undefined>;
        highlightLine: ForwardedMethod<[id: string | number], void>;
        highlightPolygon: ForwardedMethod<[id: string | number], void>;
        highlightPoint: ForwardedMethod<[id: string | number], void>;
        clearHighlightLine: ForwardedMethod<[id: string | number], void>;
        clearHighlightPolygon: ForwardedMethod<[id: string | number], void>;
        clearHighlightPoint: ForwardedMethod<[id: string | number], void>;
        clearAllHighlight: ForwardedMethod<[], void>;
    };
    utils: {
        getCalculateExtent: ForwardedMethod<[], import('ol/extent').Extent>;
        convertSixHundredThousandToLatLng: ForwardedMethod<[valueX: string | number, valueY: string | number], [lng: number, lat: number]>;
        calculateCirclePoints: ForwardedMethod<[center: [number, number], radiusInKilometers: number], {
            leftTopPoint: {
                lng: number;
                lat: number;
            };
            rightTopPoint: {
                lng: number;
                lat: number;
            };
            rightBottomPoint: {
                lng: number;
                lat: number;
            };
            leftBottomPoint: {
                lng: number;
                lat: number;
            };
        }>;
    };
    config: {
        MAP_DEFAULT_CENTER: [number, number];
        MAP_ZOOM: {
            default: number;
            min: number;
            max: number;
            findShipMin: number;
            findShip: number;
            findTruck: number;
            shipGreenDotMax: number;
            truckDefault: number;
            truckStatistics: number;
            shipModelMin: number;
            shipTriggleMin: number;
            shipModelMax: number;
            markerPosition: number;
            scaleNum: number;
        };
        projection: {
            data: string;
            mercator: string;
        };
    };
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
    center: import('ol/coordinate').Coordinate;
    zoom: number;
    declutter: boolean;
    layerType: "vector" | "satellite";
    showGreenLayer: boolean;
    showScale: boolean;
    scaleLineUnit: "metric" | "imperial" | "nautical";
    mapMoveEnd: (zoom: number) => void;
    areaDrawEnd: (area: import('ol/coordinate').Coordinate[]) => void;
    selectShip: (id: string) => void;
    selectPort: (id: import('./interface').WharfEntity) => void;
    selectWharf: (wharfData: import('./function/wharf').WharfSelectedData) => void;
}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
    zhMapRef: HTMLDivElement;
    scaleLineRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
        setScaleLine: (mapInstall: import('ol').Map, units: import('ol/control/ScaleLine').Units) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<{}> & Readonly<{}>, {
        setScaleLine: (mapInstall: import('ol').Map, units: import('ol/control/ScaleLine').Units) => void;
    }, {}, {}, {}, {}> | null;
    zoomControlRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
        mapInstance: {
            type: ObjectConstructor;
            default: () => null;
        };
    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
        mapInstance: Record<string, any>;
    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import('vue').ExtractPropTypes<{
        mapInstance: {
            type: ObjectConstructor;
            default: () => null;
        };
    }>> & Readonly<{}>, {}, {}, {}, {}, {
        mapInstance: Record<string, any>;
    }> | null;
}, HTMLDivElement>;
export default _default;
