@xdmp-open/ui-iot 0.1.0

package/dist/modules/project/device/components/debug/deviceDebug.vue.d.ts

@@ -0,0 +1,3260 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    deviceInfo: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    deviceName: {
+        type: StringConstructor;
+        default: string;
+    };
+    productName: {
+        type: StringConstructor;
+        default: string;
+    };
+    isActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {
+    nodeType: string;
+    debugType: string;
+    subDeviceId: string;
+    subDeviceList: never[];
+    subDeviceInfo: {};
+    updateStatus: boolean;
+    updateDeviceDebugLogList: never[];
+    updateAppDebugLogList: never[];
+}, {
+    deviceTopic(): string;
+    appTopic(): string;
+}, {
+    getSubDeviceList(val: any): void;
+    handleNodeTypeChange(): void;
+    getDebugStatus(status: any): void;
+    subscribeDeviceMqtt(): void;
+    subscribeAppMqtt(): void;
+    unsubscribeMqtt(): void;
+    handleAppMqttMessage(topic: any, payload: any): void;
+    handleDeviceMqttMessage(topic: any, payload: any): void;
+    clearDeviceDebugLogList(): void;
+    clearAppDebugLogList(): void;
+    handleSubDeviceChange(val: any): void;
+    closeMonitor(): void;
+    handleBeforeUnload(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    deviceInfo: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    deviceName: {
+        type: StringConstructor;
+        default: string;
+    };
+    productName: {
+        type: StringConstructor;
+        default: string;
+    };
+    isActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    deviceName: string;
+    productName: string;
+    deviceInfo: Record<string, any>;
+    isActive: boolean;
+}, {}, {
+    deviceSimulator: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        idsObj: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        deviceName: {
+            type: StringConstructor;
+            default: string;
+        };
+        productName: {
+            type: StringConstructor;
+            default: string;
+        };
+        nodeType: {
+            type: StringConstructor;
+            default: string;
+        };
+        updateStatus: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        updateDebugLogList: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        subDeviceInfo: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+    }>, {}, {
+        activeName: string;
+        debugStatus: boolean;
+        subDebugStatus: boolean;
+        properPubList: never[];
+        deisiredGetList: never[];
+        eventPubList: never[];
+        telemetryPubList: never[];
+        telemetryGetList: never[];
+        subDeviceList: never[];
+        subDeviceProductList: never[];
+        deviceDebugLogList: never[];
+    }, {}, {
+        handleClick(e: any): void;
+        getDebugStatus(status: any): void;
+        getDeviceTsl(): void;
+        getSubDeviceTsl(): void;
+        getPropertiesPub(): void;
+        getDesiredGet(): void;
+        getTelemetryPub(): void;
+        getTelemetryGet(): void;
+        getEventPub(): void;
+        getSubDeviceList(searchValue: any): void;
+        getSubDeviceProductList(): void;
+        clearDebugLogList(): void;
+        getSubDebugStatus(status: any): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        idsObj: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        deviceName: {
+            type: StringConstructor;
+            default: string;
+        };
+        productName: {
+            type: StringConstructor;
+            default: string;
+        };
+        nodeType: {
+            type: StringConstructor;
+            default: string;
+        };
+        updateStatus: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        updateDebugLogList: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        subDeviceInfo: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+    }>> & Readonly<{}>, {
+        deviceName: string;
+        productName: string;
+        nodeType: string;
+        idsObj: Record<string, any>;
+        updateDebugLogList: unknown[];
+        subDeviceInfo: Record<string, any>;
+        updateStatus: boolean;
+    }, {}, {
+        debugLog: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            idsObj: {
+                type: ObjectConstructor;
+                default: () => void;
+            };
+            updateDebugLogList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+        }>, {}, {
+            debugLogList: never[];
+            socket: string;
+            data: {};
+        }, {}, {
+            onClear(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            idsObj: {
+                type: ObjectConstructor;
+                default: () => void;
+            };
+            updateDebugLogList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+        }>> & Readonly<{}>, {
+            idsObj: Record<string, any>;
+            updateDebugLogList: unknown[];
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        propertyReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        desiredGet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serachValue: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            btnLoading: boolean;
+            checkAll: boolean;
+            isIndeterminate: boolean;
+            checkProperties: never[];
+            tslAllList: never[];
+            list: never[];
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            handleCheckChange(checkValue: any): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+            handleIsCheck(value: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        eventReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            eventIdentifier: string;
+            isOpen: boolean;
+            isShowEvent: boolean;
+            btnLoading: boolean;
+            list: never[];
+            outputDataList: never[];
+            eventForm: {
+                event: string;
+            };
+        }, {}, {
+            getDebugStatus(status: any): void;
+            getComponentList(dataType: any): null;
+            handleSelectChange(val: any): void;
+            onSubmit(): void;
+            onReset(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        telemetryReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        telemetryDesiredGet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serachValue: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            btnLoading: boolean;
+            checkAll: boolean;
+            isIndeterminate: boolean;
+            checkProperties: never[];
+            tslAllList: never[];
+            list: never[];
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            handleCheckChange(checkValue: any): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subDeviceTopology: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            subDeviceProductList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            productList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): Promise<void>;
+            handleSubStatus(row: any, status: any): void;
+            handleUnbind(row: any): void;
+            addSubDevice(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            subDeviceProductList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceList: unknown[];
+            subDeviceProductList: unknown[];
+        }, {}, {
+            addSubDeviceDrawer: import('vue').DefineComponent<{}, {}, {
+                title: string;
+                size: string;
+                loading: boolean;
+                queryParams: {
+                    query: {
+                        deviceName: string;
+                        productId: string;
+                    };
+                    pageNo: number;
+                    pageSize: number;
+                };
+                total: number;
+                appendName: string;
+                appendDeviceList: never[];
+                preDeviceList: never[];
+                checkedList: never[];
+                productList: never[];
+                mappingList: never[];
+                rules: {
+                    productId: {
+                        required: boolean;
+                        message: string;
+                        trigger: string;
+                    }[];
+                };
+                deviceId: string;
+                checkAll: boolean;
+                isIndeterminate: boolean;
+            }, {}, {
+                init(product: any, deviceId: any): void;
+                submit(): void;
+                cancel(): void;
+                cancelForm(): void;
+                handleNodeClick(data: any, checked: any, node: any): void;
+                onSearch(): void;
+                selectOne(row: any): void;
+                selectAll(rows: any): void;
+                updateAll(): void;
+                handleSizeChange(val: any): void;
+                handleCurrentChange(val: any): void;
+                handleSearch(value: any): void;
+                getDeviceList(): void;
+                handleProductChange(val: any): void;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "refresh"[], "refresh", import('vue').PublicProps, Readonly<{}> & Readonly<{
+                onRefresh?: ((...args: any[]) => any) | undefined;
+            }>, {}, {}, {
+                uiapDrawer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    submitText: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    sureText: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    showFooter: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    title: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    size: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>, {}, {
+                    drawer: boolean;
+                    direction: "rtl";
+                    loading: boolean;
+                }, {}, {
+                    handleClose(done: () => void): void;
+                    showLoading(): void;
+                    hideLoading(): void;
+                    init(): void;
+                    submit(): void;
+                    cancelForm(): void;
+                }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("submit" | "cancel")[], "submit" | "cancel", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                    submitText: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    sureText: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    showFooter: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    title: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    size: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                }>> & Readonly<{
+                    onSubmit?: ((...args: any[]) => any) | undefined;
+                    onCancel?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    size: string;
+                    title: string;
+                    submitText: string;
+                    sureText: string;
+                    showFooter: boolean;
+                }, {}, {
+                    ElDrawer: import('element-plus/es/utils/vue/typescript.mjs').SFCWithInstall<{
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').DrawerProps> & Readonly<{
+                            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                            onOpen?: (() => any) | undefined;
+                            onOpened?: (() => any) | undefined;
+                            onClose?: (() => any) | undefined;
+                            onClosed?: (() => any) | undefined;
+                            onOpenAutoFocus?: (() => any) | undefined;
+                            onCloseAutoFocus?: (() => any) | undefined;
+                            onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                            "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                            "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                        }>, {
+                            handleClose: () => void;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            "update:modelValue": (value: boolean) => void;
+                            open: () => void;
+                            opened: () => void;
+                            close: () => void;
+                            closed: () => void;
+                            openAutoFocus: () => void;
+                            closeAutoFocus: () => void;
+                            resize: (evt: MouseEvent, size: number) => void;
+                            "resize-start": (evt: MouseEvent, size: number) => void;
+                            "resize-end": (evt: MouseEvent, size: number) => void;
+                        }, import('vue').PublicProps, {
+                            direction: "ltr" | "rtl" | "ttb" | "btt";
+                            size: string | number;
+                            title: string;
+                            appendTo: string | HTMLElement;
+                            closeOnClickModal: boolean;
+                            closeOnPressEscape: boolean;
+                            lockScroll: boolean;
+                            modal: boolean;
+                            openDelay: number;
+                            closeDelay: number;
+                            modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            headerAriaLevel: string;
+                            transition: import('element-plus').DialogTransition;
+                            alignCenter: boolean;
+                            draggable: boolean;
+                            overflow: boolean;
+                            headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            showClose: boolean;
+                            ariaLevel: string;
+                            withHeader: boolean;
+                            modalFade: boolean;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').DrawerProps> & Readonly<{
+                            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                            onOpen?: (() => any) | undefined;
+                            onOpened?: (() => any) | undefined;
+                            onClose?: (() => any) | undefined;
+                            onClosed?: (() => any) | undefined;
+                            onOpenAutoFocus?: (() => any) | undefined;
+                            onCloseAutoFocus?: (() => any) | undefined;
+                            onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                            "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                            "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                        }>, {
+                            handleClose: () => void;
+                        }, {}, {}, {}, {
+                            direction: "ltr" | "rtl" | "ttb" | "btt";
+                            size: string | number;
+                            title: string;
+                            appendTo: string | HTMLElement;
+                            closeOnClickModal: boolean;
+                            closeOnPressEscape: boolean;
+                            lockScroll: boolean;
+                            modal: boolean;
+                            openDelay: number;
+                            closeDelay: number;
+                            modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            headerAriaLevel: string;
+                            transition: import('element-plus').DialogTransition;
+                            alignCenter: boolean;
+                            draggable: boolean;
+                            overflow: boolean;
+                            headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                            showClose: boolean;
+                            ariaLevel: string;
+                            withHeader: boolean;
+                            modalFade: boolean;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').DrawerProps> & Readonly<{
+                        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+                        onOpen?: (() => any) | undefined;
+                        onOpened?: (() => any) | undefined;
+                        onClose?: (() => any) | undefined;
+                        onClosed?: (() => any) | undefined;
+                        onOpenAutoFocus?: (() => any) | undefined;
+                        onCloseAutoFocus?: (() => any) | undefined;
+                        onResize?: ((evt: MouseEvent, size: number) => any) | undefined;
+                        "onResize-start"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                        "onResize-end"?: ((evt: MouseEvent, size: number) => any) | undefined;
+                    }>, {
+                        handleClose: () => void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        "update:modelValue": (value: boolean) => void;
+                        open: () => void;
+                        opened: () => void;
+                        close: () => void;
+                        closed: () => void;
+                        openAutoFocus: () => void;
+                        closeAutoFocus: () => void;
+                        resize: (evt: MouseEvent, size: number) => void;
+                        "resize-start": (evt: MouseEvent, size: number) => void;
+                        "resize-end": (evt: MouseEvent, size: number) => void;
+                    }, string, {
+                        direction: "ltr" | "rtl" | "ttb" | "btt";
+                        size: string | number;
+                        title: string;
+                        appendTo: string | HTMLElement;
+                        closeOnClickModal: boolean;
+                        closeOnPressEscape: boolean;
+                        lockScroll: boolean;
+                        modal: boolean;
+                        openDelay: number;
+                        closeDelay: number;
+                        modalClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                        headerAriaLevel: string;
+                        transition: import('element-plus').DialogTransition;
+                        alignCenter: boolean;
+                        draggable: boolean;
+                        overflow: boolean;
+                        headerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                        bodyClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                        footerClass: string | false | Record<string, any> | import('element-plus/es/utils/typescript.mjs').ClassValue[] | null;
+                        showClose: boolean;
+                        ariaLevel: string;
+                        withHeader: boolean;
+                        modalFade: boolean;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            header?: (props: {
+                                close: () => void;
+                                titleId: string;
+                                titleClass: string;
+                            }) => any;
+                        } & {
+                            title?: (props: {}) => any;
+                        } & {
+                            default?: (props: {}) => any;
+                        } & {
+                            footer?: (props: {}) => any;
+                        };
+                    })>;
+                    ElButton: {
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                            onClick?: ((evt: MouseEvent) => any) | undefined;
+                        }>, {
+                            ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                            size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                            type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                            disabled: import('vue').ComputedRef<boolean>;
+                            shouldAddSpace: import('vue').ComputedRef<boolean>;
+                        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            click: (evt: MouseEvent) => void;
+                        }, import('vue').PublicProps, {
+                            type: import('element-plus').ButtonType;
+                            text: boolean;
+                            disabled: boolean;
+                            round: boolean;
+                            dashed: boolean;
+                            nativeType: import('element-plus').ButtonNativeType;
+                            loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                            plain: boolean;
+                            autoInsertSpace: boolean;
+                            tag: string | import('vue').Component;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').ButtonProps> & Readonly<{
+                            onClick?: ((evt: MouseEvent) => any) | undefined;
+                        }>, {
+                            ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                            size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                            type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                            disabled: import('vue').ComputedRef<boolean>;
+                            shouldAddSpace: import('vue').ComputedRef<boolean>;
+                        }, {}, {}, {}, {
+                            type: import('element-plus').ButtonType;
+                            text: boolean;
+                            disabled: boolean;
+                            round: boolean;
+                            dashed: boolean;
+                            nativeType: import('element-plus').ButtonNativeType;
+                            loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                            plain: boolean;
+                            autoInsertSpace: boolean;
+                            tag: string | import('vue').Component;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ButtonProps> & Readonly<{
+                        onClick?: ((evt: MouseEvent) => any) | undefined;
+                    }>, {
+                        ref: import('vue').Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                        size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                        type: import('vue').ComputedRef<"" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger">;
+                        disabled: import('vue').ComputedRef<boolean>;
+                        shouldAddSpace: import('vue').ComputedRef<boolean>;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        click: (evt: MouseEvent) => void;
+                    }, string, {
+                        type: import('element-plus').ButtonType;
+                        text: boolean;
+                        disabled: boolean;
+                        round: boolean;
+                        dashed: boolean;
+                        nativeType: import('element-plus').ButtonNativeType;
+                        loadingIcon: import('element-plus/es/utils/vue/icon.mjs').IconPropType;
+                        plain: boolean;
+                        autoInsertSpace: boolean;
+                        tag: string | import('vue').Component;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            loading?: (props: {}) => any;
+                        } & {
+                            icon?: (props: {}) => any;
+                        } & {
+                            default?: (props: {}) => any;
+                        };
+                    }) & import('vue').ObjectPlugin & {
+                        setPropsDefaults: (defaults: {
+                            readonly size?: "" | "default" | "small" | "large" | (() => "" | "default" | "small" | "large") | undefined;
+                            readonly disabled?: boolean | (() => boolean) | undefined;
+                            readonly type?: "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger" | (() => "" | "text" | "default" | "primary" | "success" | "warning" | "info" | "danger") | undefined;
+                            readonly icon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                                new (...args: any[]): any;
+                                __isFragment?: never;
+                                __isTeleport?: never;
+                                __isSuspense?: never;
+                            } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                            readonly nativeType?: "button" | "submit" | "reset" | (() => "button" | "submit" | "reset") | undefined;
+                            readonly loading?: boolean | (() => boolean) | undefined;
+                            readonly loadingIcon?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                                new (...args: any[]): any;
+                                __isFragment?: never;
+                                __isTeleport?: never;
+                                __isSuspense?: never;
+                            } | (() => (import('element-plus/es/utils/vue/icon.mjs').IconPropType | undefined) & {}) | undefined;
+                            readonly plain?: boolean | (() => boolean) | undefined;
+                            readonly text?: boolean | (() => boolean) | undefined;
+                            readonly link?: boolean | (() => boolean) | undefined;
+                            readonly bg?: boolean | (() => boolean) | undefined;
+                            readonly autofocus?: boolean | (() => boolean) | undefined;
+                            readonly round?: boolean | (() => boolean) | undefined;
+                            readonly circle?: boolean | (() => boolean) | undefined;
+                            readonly dashed?: boolean | (() => boolean) | undefined;
+                            readonly color?: string | (() => string) | undefined;
+                            readonly dark?: boolean | (() => boolean) | undefined;
+                            readonly autoInsertSpace?: boolean | (() => boolean) | undefined;
+                            readonly tag?: string | import('vue').FunctionalComponent<any, {}, any, {}> | {
+                                new (...args: any[]): any;
+                                __isFragment?: never;
+                                __isTeleport?: never;
+                                __isSuspense?: never;
+                            } | (() => (string | import('vue').Component | undefined) & {}) | undefined;
+                        }) => void;
+                    } & {
+                        ButtonGroup: {
+                            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                                direction: "horizontal" | "vertical";
+                                type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                                P: {};
+                                B: {};
+                                D: {};
+                                C: {};
+                                M: {};
+                                Defaults: {};
+                            }, Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                                direction: "horizontal" | "vertical";
+                                type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                            }>;
+                            __isFragment?: never;
+                            __isTeleport?: never;
+                            __isSuspense?: never;
+                        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus/es/components/button/src/button-group.mjs').ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                            direction: "horizontal" | "vertical";
+                            type: "" | "default" | "info" | "primary" | "success" | "warning" | "text" | "danger";
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                            $slots: {
+                                default?: (props: {}) => any;
+                            };
+                        });
+                    };
+                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subPropertyReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceInfo: {
+                type: ObjectConstructor;
+                default: () => void;
+            };
+            gatewayDeviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            gatewayId: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+            productKey(): any;
+            subDeviceName(): any;
+            subProductName(): any;
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getProductKey(productId: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceInfo: {
+                type: ObjectConstructor;
+                default: () => void;
+            };
+            gatewayDeviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceInfo: Record<string, any>;
+            gatewayDeviceId: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subEventReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceInfo: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+            gatewayDeviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            gatewayId: string;
+            radio1: string;
+            eventIdentifier: string;
+            isOpen: boolean;
+            isShowEvent: boolean;
+            btnLoading: boolean;
+            list: never[];
+            outputDataList: never[];
+            eventForm: {
+                event: string;
+            };
+        }, {
+            subDeviceName(): any;
+            subProductName(): any;
+            productKey(): any;
+        }, {
+            getDebugStatus(status: any): void;
+            getComponentList(dataType: any): null;
+            handleSelectChange(val: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            getProductKey(productId: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceInfo: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+            gatewayDeviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceInfo: Record<string, any>;
+            gatewayDeviceId: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subTelemetryReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            gatewayDeviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceInfo: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+        }>, {}, {
+            id: string;
+            gatewayId: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+            subDeviceName(): any;
+            subProductName(): any;
+            productKey(): any;
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getProductKey(productId: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            gatewayDeviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceInfo: {
+                type: ObjectConstructor;
+                default: () => {};
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceInfo: Record<string, any>;
+            gatewayDeviceId: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, () => {
+        componentList: ({
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                getIndex: string;
+                rulesEnum: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkEnum(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string[];
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                getIndex: string;
+                rulesDouble: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                getPlaceholder(): string;
+                reset(): void;
+                checkDouble(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string[];
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                getIndex: string;
+                rulesDate: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+                rulesText: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkText(rule: any, value: any, callback: any): any;
+                checkDate(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: null;
+                };
+                getIndex: string;
+                rulesBool: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                handleChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkBool(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                bitMapList: never[];
+                visable: boolean;
+                getIndex: string;
+                rulesBitMap: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getBitMapList(data: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkBitMap(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                name: string;
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+                functionType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: never[];
+                };
+                activeNames: string;
+                dataList: never[];
+                comp: null;
+            }, {}, {
+                showCollapse(e: any): void;
+                handleAdd(maxLength: any): void;
+                onDelete(index: any): void;
+                getComponentList(dataType: any): void;
+                reset(): void;
+                getValue(value: any, index: any): void;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                name: string;
+                identifier: string;
+                componentList: Record<string, any>;
+                dataType: Record<string, any>;
+                functionType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: {};
+                };
+                activeNames: string;
+                comp: null;
+                getIndex: string;
+            }, {}, {
+                showCollapse(e: any): void;
+                getComponentList(dataType: any): null;
+                reset(): void;
+                getValue(value: any, identifier: any): void;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                name: string;
+                identifier: string;
+                componentList: Record<string, any>;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+                functionType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        })[];
+    }, true, {}, any>;
+    applySimulator: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        idsObj: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        deviceName: {
+            type: StringConstructor;
+            default: string;
+        };
+        productName: {
+            type: StringConstructor;
+            default: string;
+        };
+        nodeType: {
+            type: StringConstructor;
+            default: string;
+        };
+        updateStatus: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        updateDebugLogList: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        subDeviceInfo: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+    }>, {}, {
+        activeName: string;
+        subDebugStatus: boolean;
+        debugStatus: boolean;
+        propertySetList: never[];
+        propertyGetList: never[];
+        deisiredSetList: never[];
+        serviceInvokeList: never[];
+        telemetrySetList: never[];
+        telemetryDesiredSetList: never[];
+        telemetryGetList: never[];
+        appDebugLogList: never[];
+    }, {}, {
+        handleClick(e: any): void;
+        getDeviceTsl(): void;
+        getPropertySet(): void;
+        getDesiredSet(): void;
+        getServiceInvoke(): void;
+        getPropertyGet(): void;
+        getTelemetrySet(): void;
+        getTelemetryGet(): void;
+        getTelemetryDesiredSet(): void;
+        clearDebugLogList(): void;
+        getDebugStatus(status: any): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        idsObj: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        deviceName: {
+            type: StringConstructor;
+            default: string;
+        };
+        productName: {
+            type: StringConstructor;
+            default: string;
+        };
+        nodeType: {
+            type: StringConstructor;
+            default: string;
+        };
+        updateStatus: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        updateDebugLogList: {
+            type: ArrayConstructor;
+            default: () => never[];
+        };
+        subDeviceInfo: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+    }>> & Readonly<{}>, {
+        deviceName: string;
+        productName: string;
+        nodeType: string;
+        idsObj: Record<string, any>;
+        updateDebugLogList: unknown[];
+        subDeviceInfo: Record<string, any>;
+        updateStatus: boolean;
+    }, {}, {
+        appDebugLog: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            idsObj: {
+                type: ObjectConstructor;
+                default: () => void;
+            };
+            updateDebugLogList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+        }>, {}, {
+            debugLogList: never[];
+            socket: string;
+            data: {};
+        }, {}, {
+            onClear(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            idsObj: {
+                type: ObjectConstructor;
+                default: () => void;
+            };
+            updateDebugLogList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+        }>> & Readonly<{}>, {
+            idsObj: Record<string, any>;
+            updateDebugLogList: unknown[];
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        propertiesSet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        desiredSet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        servicesReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serviceIdntifier: string;
+            isOpen: boolean;
+            isShowService: boolean;
+            btnLoading: boolean;
+            list: never[];
+            inputDataList: never[];
+            serviceForm: {
+                service: string;
+            };
+        }, {}, {
+            getComponentList(dataType: any): null;
+            handleSelectChange(val: any): void;
+            onSubmit(): void;
+            onReset(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        propertyGet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serachValue: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            btnLoading: boolean;
+            checkAll: boolean;
+            isIndeterminate: boolean;
+            checkProperties: never[];
+            tslAllList: never[];
+            list: never[];
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            handleCheckChange(checkValue: any): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+            handleIsCheck(value: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        telemetryDesiredSet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        telemetrySet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        telemetryGet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serachValue: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            btnLoading: boolean;
+            checkAll: boolean;
+            isIndeterminate: boolean;
+            checkProperties: never[];
+            tslAllList: never[];
+            list: never[];
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            handleCheckChange(checkValue: any): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+            handleIsCheck(value: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subServicesReport: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serviceIdntifier: string;
+            isOpen: boolean;
+            isShowService: boolean;
+            btnLoading: boolean;
+            list: never[];
+            inputDataList: never[];
+            serviceForm: {
+                service: string;
+            };
+        }, {}, {
+            getComponentList(dataType: any): null;
+            handleSelectChange(val: any): void;
+            onSubmit(): void;
+            onReset(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceName: string;
+            subProductName: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subPropertySet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceName: string;
+            subProductName: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subPropertyGet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serachValue: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            btnLoading: boolean;
+            checkAll: boolean;
+            isIndeterminate: boolean;
+            checkProperties: never[];
+            tslAllList: never[];
+            list: never[];
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            handleCheckChange(checkValue: any): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+            handleIsCheck(value: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceName: string;
+            subProductName: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subTelemetrySet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            checkAll: boolean;
+            btnLoading: boolean;
+            isIndeterminate: boolean;
+            list: never[];
+            checkProperties: never[];
+            tslAllList: never[];
+            checkbox: string;
+            serachValue: string;
+            comp: null;
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            getComponentList(dataType: any): null;
+            handleCheckChange(checkValue: any): void;
+            onSubmit(): void;
+            onReset(): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceName: string;
+            subProductName: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        subTelemetryGet: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>, {}, {
+            id: string;
+            radio1: string;
+            serachValue: string;
+            isOpen: boolean;
+            isCheck: boolean;
+            btnLoading: boolean;
+            checkAll: boolean;
+            isIndeterminate: boolean;
+            checkProperties: never[];
+            tslAllList: never[];
+            list: never[];
+        }, {
+            dataList(): any[];
+        }, {
+            getDebugStatus(status: any): void;
+            onSearch(): void;
+            handleCheckChange(checkValue: any): void;
+            handleCheckAllChange(checkType: any): void;
+            getTslAllList(): void;
+            getDesired(): void;
+            deleteDesired(): void;
+            handleIsCheck(value: any): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            debugStatus: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            deviceId: {
+                type: StringConstructor;
+                default: string;
+            };
+            tslList: {
+                type: ArrayConstructor;
+                default: () => never[];
+            };
+            deviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            productName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subDeviceName: {
+                type: StringConstructor;
+                default: string;
+            };
+            subProductName: {
+                type: StringConstructor;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            tslList: unknown[];
+            deviceId: string;
+            deviceName: string;
+            productName: string;
+            debugStatus: boolean;
+            subDeviceName: string;
+            subProductName: string;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, () => {
+        componentList: ({
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                getIndex: string;
+                rulesEnum: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkEnum(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string[];
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                getIndex: string;
+                rulesDouble: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                getPlaceholder(): string;
+                reset(): void;
+                checkDouble(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string[];
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                getIndex: string;
+                rulesDate: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+                rulesText: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkText(rule: any, value: any, callback: any): any;
+                checkDate(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: null;
+                };
+                getIndex: string;
+                rulesBool: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                handleChange(value: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkBool(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{}>, {
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: string;
+                };
+                bitMapList: never[];
+                visable: boolean;
+                getIndex: string;
+                rulesBitMap: {
+                    required: boolean;
+                    validator: Function;
+                    trigger: string;
+                }[];
+            }, {}, {
+                inputChange(value: any): void;
+                getBitMapList(data: any): void;
+                getArrayValue(value: any): void;
+                getStructValue(value: any): void;
+                reset(): void;
+                checkBitMap(rule: any, value: any, callback: any): any;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                name: string;
+                identifier: string;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+                functionType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: never[];
+                };
+                activeNames: string;
+                dataList: never[];
+                comp: null;
+            }, {}, {
+                showCollapse(e: any): void;
+                handleAdd(maxLength: any): void;
+                onDelete(index: any): void;
+                getComponentList(dataType: any): void;
+                reset(): void;
+                getValue(value: any, index: any): void;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                name: string;
+                identifier: string;
+                componentList: Record<string, any>;
+                dataType: Record<string, any>;
+                functionType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        } | {
+            key: string;
+            components: import('vue').Raw<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>, {}, {
+                valueForm: {
+                    key: string;
+                    value: {};
+                };
+                activeNames: string;
+                comp: null;
+                getIndex: string;
+            }, {}, {
+                showCollapse(e: any): void;
+                getComponentList(dataType: any): null;
+                reset(): void;
+                getValue(value: any, identifier: any): void;
+                validate(): Promise<unknown>;
+            }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+                identifier: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                dataType: {
+                    type: ObjectConstructor;
+                    default: () => void;
+                };
+                componentList: {
+                    type: ObjectConstructor;
+                    default: () => never[];
+                };
+                name: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                arrayIndex: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                functionType: {
+                    type: StringConstructor;
+                    default: string;
+                };
+            }>> & Readonly<{}>, {
+                name: string;
+                identifier: string;
+                componentList: Record<string, any>;
+                dataType: Record<string, any>;
+                arrayIndex: number;
+                functionType: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+        })[];
+    }, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;