npm - sat-earth - Versions diffs - 0.3.2-beta5 → 0.3.2-beta6 - Mend

sat-earth 0.3.2-beta5 → 0.3.2-beta6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (89) hide show

package/dist/packages/components/location/SatLocation.vue.d.ts ADDED Viewed

@@ -0,0 +1,676 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        visible: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+    }>>;
+    emits: (event: "update:visible", ...args: any[]) => void;
+    compStateStore: import("pinia").Store<"SatCompState", import('../../store/modules/compState').CompState, {
+        getComponents: (state: {
+            SatSource?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatMapPart?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatLocation?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatMeasure?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatPlot?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatPicture?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatSpatialAnalysis?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatTerrainAnalysis?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatModelAnalysis?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatVideoFusion?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatRoam?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+            SatBallistic?: {
+                label: string;
+                name: string;
+                parentName: string;
+                enable: boolean;
+                active: boolean;
+                ready?: boolean | undefined;
+            } | undefined;
+        } & import("pinia").PiniaCustomStateProperties<import('../../store/modules/compState').CompState>) => any;
+    }, {
+        setSatSource(item: import('../../store/modules/compState').StateItem): void;
+        setSatMapPart(item: import('../../store/modules/compState').StateItem): void;
+        setSatLocation(item: import('../../store/modules/compState').StateItem): void;
+        setSatMeasure(item: import('../../store/modules/compState').StateItem): void;
+        setSatPlot(item: import('../../store/modules/compState').StateItem): void;
+        setSatPicture(item: import('../../store/modules/compState').StateItem): void;
+        setSatSpatialAnalysis(item: import('../../store/modules/compState').StateItem): void;
+        setSatTerrainAnalysis(item: import('../../store/modules/compState').StateItem): void;
+        setSatModelAnalysis(item: import('../../store/modules/compState').StateItem): void;
+        setSatVideoFusion(item: import('../../store/modules/compState').StateItem): void;
+        setSatRoam(item: import('../../store/modules/compState').StateItem): void;
+        setSatBallistic(item: import('../../store/modules/compState').StateItem): void;
+        changeCompState(itemName: string, flag: boolean): void;
+        unActiveAll(): void;
+    }>;
+    layoutStore: import("pinia").Store<"SatLayout", import('../../store/modules/layout').LayoutState, {}, {
+        setIsDark(val: boolean): void;
+        setIsMobile(val: boolean): void;
+        setIsForceHorizontal(val: boolean): void;
+        setIsRenderedMap(val: boolean): void;
+    }>;
+    name: string;
+    isInSide: boolean;
+    isNeedInit: boolean;
+    isShowInMenu: boolean;
+    isReadyRef: import("vue").ComputedRef<boolean | undefined>;
+    isActiveRef: import("vue").ComputedRef<boolean>;
+    toggleEnable: (isEnable: boolean) => void;
+    toggleActive: (isActive: boolean) => void;
+    toggleReady: (isReady: boolean) => void;
+    isInit: import("vue").ComputedRef<boolean | undefined>;
+    init: () => void;
+    destroy: () => void;
+    shrink: () => void;
+    close: () => void;
+    renderSFC: () => void;
+    SatPanel: import("vue").DefineComponent<{
+        title: {
+            type: StringConstructor;
+            required: true;
+        };
+        isShrink: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isDrag: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        shrinkEvent: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        closeEvent: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            title: {
+                type: StringConstructor;
+                required: true;
+            };
+            isShrink: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            isDrag: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            shrinkEvent: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+            closeEvent: {
+                type: FunctionConstructor;
+                default: () => void;
+            };
+        }>> & {
+            [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+        }>>;
+        isMobile: import("vue").Ref<boolean>;
+        draggable: import("vue").Ref<boolean>;
+        dragElement: import("vue").Ref<HTMLElement | null>;
+        style: import("vue").ComputedRef<string>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+            required: true;
+        };
+        isShrink: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        isDrag: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        shrinkEvent: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        closeEvent: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+    }>>, {
+        isShrink: boolean;
+        isClose: boolean;
+        isDrag: boolean;
+        shrinkEvent: Function;
+        closeEvent: Function;
+    }>;
+    SatLocationMain: import("vue").DefineComponent<{}, {
+        activeName: import("vue").Ref<string>;
+        placeLocationPng: string;
+        routePathPng: string;
+        placeSearchPng: string;
+        SatCoordinate: import("vue").DefineComponent<{}, {
+            zbdwForm: import("vue").Ref<{
+                [x: string]: any;
+                x?: number | undefined;
+                y?: number | undefined;
+            }>;
+            zbdwFormRef: import("vue").Ref<({
+                $: import("vue").ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    readonly disabled: boolean;
+                    readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                    readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                    readonly labelSuffix: string;
+                    readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly hideRequiredAsterisk: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly inline: boolean;
+                    readonly inlineMessage: boolean;
+                    readonly statusIcon: boolean;
+                    readonly scrollToError: boolean;
+                }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+                    readonly model: ObjectConstructor;
+                    readonly rules: {
+                        readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                    readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly inline: BooleanConstructor;
+                    readonly inlineMessage: BooleanConstructor;
+                    readonly statusIcon: BooleanConstructor;
+                    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly size: {
+                        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly hideRequiredAsterisk: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                    readonly scrollToError: BooleanConstructor;
+                }>> & {
+                    onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "labelPosition" | "labelWidth" | "labelSuffix" | "inline" | "inlineMessage" | "statusIcon" | "showMessage" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import("vue").Slot | undefined;
+                }>;
+                $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
+                $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
+                $emit: (event: "validate", prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
+                $el: any;
+                $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                    readonly model: ObjectConstructor;
+                    readonly rules: {
+                        readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                    readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly inline: BooleanConstructor;
+                    readonly inlineMessage: BooleanConstructor;
+                    readonly statusIcon: BooleanConstructor;
+                    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly size: {
+                        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly hideRequiredAsterisk: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                    readonly scrollToError: BooleanConstructor;
+                }>> & {
+                    onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                }, {
+                    COMPONENT_NAME: string;
+                    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                        readonly model: ObjectConstructor;
+                        readonly rules: {
+                            readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                        readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                        readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                        readonly inline: BooleanConstructor;
+                        readonly inlineMessage: BooleanConstructor;
+                        readonly statusIcon: BooleanConstructor;
+                        readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                        readonly size: {
+                            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly disabled: BooleanConstructor;
+                        readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                        readonly hideRequiredAsterisk: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                        readonly scrollToError: BooleanConstructor;
+                    }>> & {
+                        onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                    }>>;
+                    emit: (event: "validate", prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
+                    fields: import("element-plus").FormItemContext[];
+                    formSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+                    ns: {
+                        namespace: import("vue").ComputedRef<string>;
+                        b: (blockSuffix?: string | undefined) => string;
+                        e: (element?: string | undefined) => string;
+                        m: (modifier?: string | undefined) => string;
+                        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                        em: (element?: string | undefined, modifier?: string | undefined) => string;
+                        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    formClasses: import("vue").ComputedRef<(string | {
+                        [x: string]: boolean | import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                    })[]>;
+                    addField: (field: import("element-plus").FormItemContext) => void;
+                    removeField: (field: import("element-plus").FormItemContext) => void;
+                    resetFields: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined) => void;
+                    clearValidate: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined) => void;
+                    isValidatable: import("vue").ComputedRef<boolean>;
+                    obtainValidateFields: (props: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => import("element-plus").FormItemContext[];
+                    validate: (callback?: import("element-plus").FormValidateCallback | undefined) => import("element-plus").FormValidationResult;
+                    doValidateField: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined) => Promise<boolean>;
+                    validateField: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined, callback?: import("element-plus").FormValidateCallback | undefined) => import("element-plus").FormValidationResult;
+                    scrollToField: (prop: import("element-plus").FormItemProp) => void;
+                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => boolean;
+                }, string, {
+                    readonly disabled: boolean;
+                    readonly labelPosition: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                    readonly labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                    readonly labelSuffix: string;
+                    readonly showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly hideRequiredAsterisk: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly inline: boolean;
+                    readonly inlineMessage: boolean;
+                    readonly statusIcon: boolean;
+                    readonly scrollToError: boolean;
+                }> & {
+                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                    created?: ((() => void) | (() => void)[]) | undefined;
+                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                    mounted?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                    updated?: ((() => void) | (() => void)[]) | undefined;
+                    activated?: ((() => void) | (() => void)[]) | undefined;
+                    deactivated?: ((() => void) | (() => void)[]) | undefined;
+                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                    destroyed?: ((() => void) | (() => void)[]) | undefined;
+                    unmounted?: ((() => void) | (() => void)[]) | undefined;
+                    renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+                    renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+                    errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import("vue").nextTick;
+                $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+            } & Readonly<import("vue").ExtractPropTypes<{
+                readonly model: ObjectConstructor;
+                readonly rules: {
+                    readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly inline: BooleanConstructor;
+                readonly inlineMessage: BooleanConstructor;
+                readonly statusIcon: BooleanConstructor;
+                readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly hideRequiredAsterisk: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                readonly scrollToError: BooleanConstructor;
+            }>> & {
+                onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            } & import("vue").ShallowUnwrapRef<{
+                COMPONENT_NAME: string;
+                props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                    readonly model: ObjectConstructor;
+                    readonly rules: {
+                        readonly type: import("vue").PropType<Partial<Record<string, import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>>>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly labelPosition: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                    readonly labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                    readonly labelSuffix: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly inline: BooleanConstructor;
+                    readonly inlineMessage: BooleanConstructor;
+                    readonly statusIcon: BooleanConstructor;
+                    readonly showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly size: {
+                        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly validateOnRuleChange: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly hideRequiredAsterisk: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                    readonly scrollToError: BooleanConstructor;
+                }>> & {
+                    onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+                }>>;
+                emit: (event: "validate", prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => void;
+                fields: import("element-plus").FormItemContext[];
+                formSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+                ns: {
+                    namespace: import("vue").ComputedRef<string>;
+                    b: (blockSuffix?: string | undefined) => string;
+                    e: (element?: string | undefined) => string;
+                    m: (modifier?: string | undefined) => string;
+                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                    em: (element?: string | undefined, modifier?: string | undefined) => string;
+                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                formClasses: import("vue").ComputedRef<(string | {
+                    [x: string]: boolean | import("element-plus/es/utils").EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                })[]>;
+                addField: (field: import("element-plus").FormItemContext) => void;
+                removeField: (field: import("element-plus").FormItemContext) => void;
+                resetFields: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined) => void;
+                clearValidate: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined) => void;
+                isValidatable: import("vue").ComputedRef<boolean>;
+                obtainValidateFields: (props: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp>) => import("element-plus").FormItemContext[];
+                validate: (callback?: import("element-plus").FormValidateCallback | undefined) => import("element-plus").FormValidationResult;
+                doValidateField: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined) => Promise<boolean>;
+                validateField: (props?: import("element-plus/es/utils").Arrayable<import("element-plus").FormItemProp> | undefined, callback?: import("element-plus").FormValidateCallback | undefined) => import("element-plus").FormValidationResult;
+                scrollToField: (prop: import("element-plus").FormItemProp) => void;
+            }> & {} & import("vue").ComponentCustomProperties) | undefined>;
+            ucsList: string[];
+            cTypeList: string[];
+            rules_zbdw: {
+                x: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+                y: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+                degrees_x_d: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+                degrees_x_f: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+                degrees_x_m: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+                degrees_y_d: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+                degrees_y_f: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+                degrees_y_m: ({
+                    required: boolean;
+                    trigger: string;
+                    message: string;
+                    validator?: undefined;
+                } | {
+                    required: boolean;
+                    validator: (rule: any, value: any, callback: any) => any;
+                    trigger: string;
+                    message?: undefined;
+                })[];
+            };
+            searchCoordinate: () => void;
+            coordinateHelper: {
+                markerCoordinates(coord: {
+                    lng: number;
+                    lat: number;
+                    text?: string | undefined;
+                }): Promise<import("../../utils/types").SatPointEntity>;
+                removeMarkerCoordinates(): void;
+            };
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+        SatPathPlan: import("vue").DefineComponent<{}, {
+            pathForm: import("vue").Ref<{
+                start: string;
+                end: string;
+                selectWay: string;
+            }>;
+            startAddress: import("vue").Ref<string>;
+            endAddress: import("vue").Ref<string>;
+            allDiatance: import("vue").Ref<string>;
+            useTime: import("vue").Ref<string>;
+            routePath: import("vue").Ref<string>;
+            selectWayOptions: {
+                value: string;
+                label: string;
+            }[];
+            onChangeTravelWay: (value: any) => void;
+            startPoint: () => Promise<void>;
+            endPoint: () => Promise<void>;
+            btnAnalyse: () => void;
+            removeAllPath: () => void;
+            saveGeoJSON: () => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+        SatPoiQuery: import("vue").DefineComponent<{}, {
+            keyword: import("vue").Ref<string>;
+            isShowTip: import("vue").Ref<boolean>;
+            tipList: any;
+            resultList: any;
+            pageInfo: import("vue").Ref<{
+                pageNo: number;
+                pageSize: number;
+                total: number;
+            }>;
+            handleCurrentChange: (val: number) => void;
+            queryText: (text?: string | undefined) => Promise<void>;
+            autoTip: () => Promise<void>;
+            flyTo: (item: any) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:visible"[], "update:visible", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    visible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+}, {
+    visible: boolean;
+}>;
+export default _sfc_main;