xgis-ol/dist/components/OLXmap/index.vue.d.ts

基于openlayers + ol-ext库进行封装

import { ViewOptions } from 'ol/view';
import { PropType } from 'vue';
import { default as XMap } from '../../core/XMap';
declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    mapid: {
        type: StringConstructor;
        default: string;
    };
    mapgroup: {
        type: StringConstructor;
        default: string;
    };
    hasLayerManager: {
        type: BooleanConstructor;
        default: boolean;
    };
    initTDTLayers: {
        type: PropType<string[]>;
        default: () => string[];
    };
    viewProjection: {
        type: (ObjectConstructor | StringConstructor)[];
        default: string;
    };
    defaultCenter: {
        type: PropType<number[]>;
        default: () => number[];
    };
    viewOptions: {
        type: PropType<ViewOptions>;
    };
    multiWorld: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableContextMenu: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    mapIDRef: import('vue').Ref<string, string>;
    mapContainerRef: import('vue').Ref<string, string>;
    mapRef: import('vue').Ref<XMap, XMap>;
    enableMenuComputed: import('vue').ComputedRef<boolean>;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "mapInited"[], "mapInited", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    mapid: {
        type: StringConstructor;
        default: string;
    };
    mapgroup: {
        type: StringConstructor;
        default: string;
    };
    hasLayerManager: {
        type: BooleanConstructor;
        default: boolean;
    };
    initTDTLayers: {
        type: PropType<string[]>;
        default: () => string[];
    };
    viewProjection: {
        type: (ObjectConstructor | StringConstructor)[];
        default: string;
    };
    defaultCenter: {
        type: PropType<number[]>;
        default: () => number[];
    };
    viewOptions: {
        type: PropType<ViewOptions>;
    };
    multiWorld: {
        type: BooleanConstructor;
        default: boolean;
    };
    enableContextMenu: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onMapInited?: (...args: any[]) => any;
}>, {
    mapid: string;
    mapgroup: string;
    hasLayerManager: boolean;
    initTDTLayers: string[];
    viewProjection: string | Record<string, any>;
    defaultCenter: number[];
    multiWorld: boolean;
    enableContextMenu: boolean;
}, {}, {
    ZoomFullBar: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        xmap: {
            type: PropType<XMap>;
        };
        hasLayerTree: {
            type: BooleanConstructor;
            default: boolean;
        };
        isInternet: {
            type: BooleanConstructor;
            default: boolean;
        };
        hasFullScreen: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        isFullScreen: import('vue').Ref<boolean, boolean>;
        toggleMapScreen: () => void;
        fullScreenTip: import('vue').ComputedRef<"退出全屏" | "地图全屏">;
        fullScreenStyle: import('vue').ComputedRef<string>;
        zoomInOut: (isIn?: boolean) => void;
        layerTreeSelected: import('vue').ComputedRef<string>;
        changeLayerTree: () => void;
        hasLayerTreeRef: import('vue').ComputedRef<boolean>;
        isInternetRef: import('vue').ComputedRef<boolean>;
        goHomeView: () => void;
        doGeoLocation: () => void;
        hasFullScreenRef: import('vue').ComputedRef<boolean>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "locate"[], "locate", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        xmap: {
            type: PropType<XMap>;
        };
        hasLayerTree: {
            type: BooleanConstructor;
            default: boolean;
        };
        isInternet: {
            type: BooleanConstructor;
            default: boolean;
        };
        hasFullScreen: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onLocate?: (...args: any[]) => any;
    }>, {
        hasLayerTree: boolean;
        isInternet: boolean;
        hasFullScreen: boolean;
    }, {}, {
        Icon: import('vue').DefineSetupFnComponent<import('@iconify/vue').IconProps, {}, {}, import('@iconify/vue').IconProps, import('vue').PublicProps>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    ContextMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        xmap: {
            type: typeof XMap;
            required: true;
        };
        replace: {
            type: BooleanConstructor;
            default: boolean;
        };
        moreMenuList: {
            type: {
                (arrayLength: number): import('../..').IMapContextItem[];
                (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                new (arrayLength: number): import('../..').IMapContextItem[];
                new (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                isArray(arg: any): arg is any[];
                readonly prototype: any[];
                from<T>(arrayLike: ArrayLike<T>): T[];
                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                of<T>(...items: T[]): T[];
                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
                readonly [Symbol.species]: ArrayConstructor;
            };
            default: any[];
        };
        target: {
            type: (StringConstructor | BooleanConstructor | {
                new (): Element;
                prototype: Element;
            })[];
            default: string;
        };
    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        itemClicked: (...args: any[]) => void;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        xmap: {
            type: typeof XMap;
            required: true;
        };
        replace: {
            type: BooleanConstructor;
            default: boolean;
        };
        moreMenuList: {
            type: {
                (arrayLength: number): import('../..').IMapContextItem[];
                (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                new (arrayLength: number): import('../..').IMapContextItem[];
                new (...items: import('../..').IMapContextItem[]): import('../..').IMapContextItem[];
                isArray(arg: any): arg is any[];
                readonly prototype: any[];
                from<T>(arrayLike: ArrayLike<T>): T[];
                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
                of<T>(...items: T[]): T[];
                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
                readonly [Symbol.species]: ArrayConstructor;
            };
            default: any[];
        };
        target: {
            type: (StringConstructor | BooleanConstructor | {
                new (): Element;
                prototype: Element;
            })[];
            default: string;
        };
    }>> & Readonly<{
        onItemClicked?: (...args: any[]) => any;
    }>, {
        target: string | boolean | Element;
        replace: boolean;
        moreMenuList: import('../..').IMapContextItem[];
    }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
declare const _default: typeof __VLS_export;
export default _default;