lyflowchart 1.0.113 → 1.0.130

package/dist/components/approval/components/columnTables.vue.d.ts

@@ -0,0 +1,502 @@
+import { PropType } from 'vue';
+import { ApprovalSetting } from '../typing';
+import { TableSelectLimit } from '../utils';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    columnConfig: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    eventBus: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    modelType: {
+        type: StringConstructor;
+        required: true;
+    };
+    approvalConfig: {
+        type: PropType<ApprovalSetting>;
+        required: true;
+    };
+    groupTitle: {
+        type: StringConstructor;
+        required: false;
+    };
+    filterTables: {
+        type: PropType<any[]>;
+        default: () => any[];
+        required: false;
+    };
+    hideAllButtons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    activeKey: import("vue").Ref<any[], any[]>;
+    filterTables: import("vue").ComputedRef<any>;
+    rowSelectionTypeMap: import("vue").ComputedRef<{}>;
+    getSelectLimit: (tableId: string) => TableSelectLimit | null;
+    getSelectLimitText: (tableId: string) => string;
+    getSelectedCount: (tableId: string) => number;
+    isSelectCountInvalid: (tableId: string) => boolean;
+    handleSelectionChange: (tableId: string, count: number) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "selected-counts-change"[], "selected-counts-change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    columnConfig: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    eventBus: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    modelType: {
+        type: StringConstructor;
+        required: true;
+    };
+    approvalConfig: {
+        type: PropType<ApprovalSetting>;
+        required: true;
+    };
+    groupTitle: {
+        type: StringConstructor;
+        required: false;
+    };
+    filterTables: {
+        type: PropType<any[]>;
+        default: () => any[];
+        required: false;
+    };
+    hideAllButtons: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onSelected-counts-change"?: (...args: any[]) => any;
+}>, {
+    hideAllButtons: boolean;
+    filterTables: any[];
+}, {}, {
+    ApprovalTable: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        config: {
+            type: () => import("../typing").Table;
+            required: true;
+        };
+        modelType: {
+            type: StringConstructor;
+            required: false;
+        };
+        eventBus: {
+            type: ObjectConstructor;
+            required: false;
+        };
+        approvalConfig: {
+            type: () => ApprovalSetting;
+            required: false;
+        };
+        rowSelectionType: {
+            type: StringConstructor;
+            required: false;
+        };
+        hideAllButtons: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        dataSource: import("vue").Ref<any[], any[]>;
+        selectedRowKeys: import("vue").Ref<any[], any[]>;
+        loading: import("vue").Ref<boolean, boolean>;
+        state: {
+            current: number;
+            pageSize: number;
+            total: number;
+        };
+        handlePageChange: (page: any, pageSize: any) => void;
+        handleRowAction: (action: any, record: any) => Promise<void>;
+        callRowActionByTitle: (title: any, record: any) => void;
+        pageSizeOptions: import("vue").Ref<string[], string[]>;
+        columns: import("vue").ComputedRef<({
+            minWidth: number;
+            width: any;
+            filteredValue: any;
+            sortOrder: any;
+            key: string;
+            title: string;
+            dataIndex: string;
+            ellipsis: boolean;
+            resizable: boolean;
+            fixed?: boolean;
+            autoHeight: boolean;
+            autoWidth: boolean;
+            cellComponent?: string;
+            approve_summary?: boolean;
+            cellSummaryComponent?: string;
+            colorMap?: Record<string, any>;
+            contentMap?: Record<string, any>;
+            filterMultiple?: boolean;
+            filters?: Array<{
+                text: string;
+                value: any;
+            }>;
+            sorter?: any;
+            defaultSortOrder?: "ascend" | "descend";
+            defaultSortIndex?: number;
+        } | {
+            width: number;
+            minWidth: any;
+            filteredValue: any;
+            sortOrder: any;
+            key: string;
+            title: string;
+            dataIndex: string;
+            ellipsis: boolean;
+            resizable: boolean;
+            fixed?: boolean;
+            autoHeight: boolean;
+            autoWidth: boolean;
+            cellComponent?: string;
+            approve_summary?: boolean;
+            cellSummaryComponent?: string;
+            colorMap?: Record<string, any>;
+            contentMap?: Record<string, any>;
+            filterMultiple?: boolean;
+            filters?: Array<{
+                text: string;
+                value: any;
+            }>;
+            sorter?: any;
+            defaultSortOrder?: "ascend" | "descend";
+            defaultSortIndex?: number;
+        } | {
+            title: string;
+            dataIndex: string;
+            width: number;
+            resizable: boolean;
+            fixed: string;
+        })[]>;
+        searchConditions: import("vue").Ref<any[], any[]>;
+        delayGetDate: import("lodash").DebouncedFunc<() => Promise<void>>;
+        selfEventBus: import("mitt").Emitter<Record<import("mitt").EventType, unknown>>;
+        row_selection: any;
+        handleAction: (action: any) => Promise<void>;
+        searchRef: import("vue").Ref<any, any>;
+        actionRef: import("vue").Ref<any, any>;
+        searchHeight: import("vue").Ref<any, any>;
+        actionHeight: import("vue").Ref<any, any>;
+        tableHeight: import("vue").ComputedRef<number>;
+        rowActionWidth: import("vue").Ref<number, number>;
+        context: import("pinia").Store<"approval_context", import("../store/context.js").ContextState, {}, {
+            init(model_type: string): import("../store/context.js").Context;
+            initTable(model_type: string, table_id: string): import("../store/context.js").TableContext;
+            SET_SEARCH_CONDITIONS(model_type: string, table_id: string, searchConditions: any[]): void;
+            SET_SELECTED_ROWKEYS(model_type: string, table_id: string, selectedRowKeys: any[], selectedRecord: any[]): void;
+            SET_DATASOURCE(model_type: string, table_id: string, datasource: any[]): void;
+            SET_FORM_MODEL(model_type: string, formModel: any): void;
+            SET_GLOBAL_DATA(model_type: string, globalData: any): void;
+            SET_RAW(model_type: string, data: any): void;
+            SET_CURRENT_HISTORY_ID(model_type: string, current_history_id: any): void;
+            SET_REQUST_HISTORY_ID(model_type: string, request_history_id: any): void;
+            SET_CURRENT_FLOW_HISTORY_ID(model_type: string, current_flow_history_id: any): void;
+            SET_REQUST_FLOW_HISTORY_ID(model_type: string, request_flow_history_id: any): void;
+            SET_EDIT(model_type: string, isEdit: boolean, editState: any): void;
+            CLEAR_CONTEXT(model_type: string): void;
+        }>;
+        summaryColumns: import("vue").ComputedRef<any[]>;
+        preserveRow: () => boolean;
+        handleChange: (pagination: import("ant-design-vue").TablePaginationConfig, filters: Record<string, import("ant-design-vue/es/table/interface.js").FilterValue | null>, sorter: import("ant-design-vue/es/table/interface.js").SorterResult<any> | import("ant-design-vue/es/table/interface.js").SorterResult<any>[], extra: import("ant-design-vue/es/table/interface.js").TableCurrentDataSource<any>) => void;
+        tableWraperHeight: import("vue").Ref<any, any>;
+        tableWraperRef: import("vue").Ref<any, any>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "selection-change"[], "selection-change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        config: {
+            type: () => import("../typing").Table;
+            required: true;
+        };
+        modelType: {
+            type: StringConstructor;
+            required: false;
+        };
+        eventBus: {
+            type: ObjectConstructor;
+            required: false;
+        };
+        approvalConfig: {
+            type: () => ApprovalSetting;
+            required: false;
+        };
+        rowSelectionType: {
+            type: StringConstructor;
+            required: false;
+        };
+        hideAllButtons: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onSelection-change"?: (...args: any[]) => any;
+    }>, {
+        hideAllButtons: boolean;
+    }, {}, {
+        Search: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            searchConfig: {
+                type: {
+                    (arrayLength: number): import("../typing").SearchConfig[];
+                    (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                    new (arrayLength: number): import("../typing").SearchConfig[];
+                    new (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                required: true;
+            };
+            searchConditions: {
+                type: {
+                    (arrayLength: number): import("../typing").Condition[];
+                    (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                    new (arrayLength: number): import("../typing").Condition[];
+                    new (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                required: true;
+            };
+            eventBus: {
+                type: any;
+                required: false;
+            };
+        }>, {
+            isShowForm: import("vue").Ref<boolean, boolean>;
+            searchModel: import("vue").Ref<{}, {}>;
+            dataSource: import("vue").ComputedRef<{
+                value: any;
+                operator: any;
+                model: string;
+                type: string;
+                label: string;
+                format: string;
+                inputType?: string;
+                allowClear: boolean;
+                class_name: string;
+                field_name: string;
+                autocomplete: string;
+                operator_list: string[];
+                default_operator?: string;
+                dateFormat?: string;
+                options?: any[];
+                required_condition?: any;
+                showTime?: boolean;
+                size?: any;
+                valueFormat?: string;
+                mode?: string;
+            }[]>;
+            onChange: (field_name: string, type: "value" | "operator", newValue: any, array_index?: number | undefined) => void;
+            operator_type_map: Record<string, string>;
+            formModel: import("vue").Ref<{}, {}>;
+            is_or_not_blank_or_null_options: import("vue").Ref<{
+                value: string;
+                label: string;
+            }[], {
+                value: string;
+                label: string;
+            }[] | {
+                value: string;
+                label: string;
+            }[]>;
+            validateInfos: import("vue").Ref<{}, {}>;
+            options_for_date_eq: {
+                value: string;
+                label: string;
+            }[];
+            handleUpdateSearchConditions: (newConditions: import("../typing").Condition[]) => void;
+            handleRefresh: () => void;
+            getValue: (configItemAndValue: any) => any;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:searchConditions"[], "update:searchConditions", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            searchConfig: {
+                type: {
+                    (arrayLength: number): import("../typing").SearchConfig[];
+                    (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                    new (arrayLength: number): import("../typing").SearchConfig[];
+                    new (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                required: true;
+            };
+            searchConditions: {
+                type: {
+                    (arrayLength: number): import("../typing").Condition[];
+                    (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                    new (arrayLength: number): import("../typing").Condition[];
+                    new (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                required: true;
+            };
+            eventBus: {
+                type: any;
+                required: false;
+            };
+        }>> & Readonly<{
+            "onUpdate:searchConditions"?: (...args: any[]) => any;
+        }>, {
+            eventBus: any;
+        }, {}, {
+            searchSummary: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                searchConfig: {
+                    type: {
+                        (arrayLength: number): import("../typing").SearchConfig[];
+                        (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                        new (arrayLength: number): import("../typing").SearchConfig[];
+                        new (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                searchConditions: {
+                    type: {
+                        (arrayLength: number): import("../typing").Condition[];
+                        (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                        new (arrayLength: number): import("../typing").Condition[];
+                        new (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                eventBus: {
+                    type: any;
+                    required: false;
+                };
+            }>, {
+                dataSource: import("vue").ComputedRef<{
+                    field_name: string;
+                    summary: any;
+                }[]>;
+                handleClose: (fieldName: string) => void;
+                handleRefresh: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:searchConditions"[], "update:searchConditions", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                searchConfig: {
+                    type: {
+                        (arrayLength: number): import("../typing").SearchConfig[];
+                        (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                        new (arrayLength: number): import("../typing").SearchConfig[];
+                        new (...items: import("../typing").SearchConfig[]): import("../typing").SearchConfig[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                searchConditions: {
+                    type: {
+                        (arrayLength: number): import("../typing").Condition[];
+                        (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                        new (arrayLength: number): import("../typing").Condition[];
+                        new (...items: import("../typing").Condition[]): import("../typing").Condition[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                    required: true;
+                };
+                eventBus: {
+                    type: any;
+                    required: false;
+                };
+            }>> & Readonly<{
+                "onUpdate:searchConditions"?: (...args: any[]) => any;
+            }>, {
+                eventBus: any;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        actionsBar: import("vue").DefineComponent<{
+            actions: import("../typing").Action[];
+            action_width?: number;
+            params?: any;
+        }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+            click: (action: any) => any;
+            "update:action_width": (width: number) => any;
+        }, string, import("vue").PublicProps, Readonly<{
+            actions: import("../typing").Action[];
+            action_width?: number;
+            params?: any;
+        }> & Readonly<{
+            onClick?: (action: any) => any;
+            "onUpdate:action_width"?: (width: number) => any;
+        }>, {
+            action_width: number;
+            params: any;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/approval/components/columnUnknown.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;