lyflowchart 1.0.113 → 1.0.130

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

@@ -0,0 +1,53 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    action_code_id: {
+        type: StringConstructor;
+        required: true;
+    };
+    modelType: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    loading: import("vue").Ref<boolean, boolean>;
+    oldData: import("vue").Ref<string, string>;
+    newData: import("vue").Ref<string, string>;
+    tableData: import("vue").Ref<any[], any[]>;
+    columns: {
+        title: string;
+        dataIndex: string;
+        width: number;
+    }[];
+    rowSelection: {
+        type: string;
+    };
+    dateRange: import("vue").Ref<any[], any[]>;
+    handleCompareClick: () => void;
+    selectedRowKeys: import("vue").Ref<any[], any[]>;
+    current: import("vue").Ref<number, number>;
+    pageSize: import("vue").Ref<number, number>;
+    total: import("vue").Ref<number, number>;
+    pageSelectOptions: {
+        name: string;
+        value: string;
+    }[];
+    handlePageChange: (page: number, size: number) => void;
+    pageOptions: import("vue").ComputedRef<any[]>;
+    getHistoryList: () => void;
+    handleDateChange: () => void;
+    getDiffPercent: (diff_len: number) => number;
+    handleViewHistory: (ids: Array<string>) => void;
+    handleApplyHistory: (action_code_id: any) => void;
+    height: import("vue").Ref<number, number>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "apply"[], "apply", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    action_code_id: {
+        type: StringConstructor;
+        required: true;
+    };
+    modelType: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onApply?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/approval/components/codeHistory/codeHistoryViewModal.vue.d.ts

@@ -0,0 +1,32 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    height: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    history_ids: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+}>, {
+    handleCancel: () => void;
+    handleOk: () => void;
+    loading: import("vue").Ref<boolean, boolean>;
+    history_records: import("vue").Ref<any[], any[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancel" | "ok")[], "cancel" | "ok", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    height: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    history_ids: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+}>> & Readonly<{
+    onOk?: (...args: any[]) => any;
+    onCancel?: (...args: any[]) => any;
+}>, {
+    height: number;
+    history_ids: string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,454 @@
+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;
+    };
+}>, {
+    headerRef: import("vue").Ref<any, any>;
+    contentHeight: import("vue").ComputedRef<number>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, 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;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    ApprovalTable: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        config: {
+            type: () => import("../typing.js").Table;
+            required: true;
+        };
+        modelType: {
+            type: StringConstructor;
+            required: false;
+        };
+        eventBus: {
+            type: ObjectConstructor;
+            required: false;
+        };
+        approvalConfig: {
+            type: () => import("../typing.js").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.js").Table;
+            required: true;
+        };
+        modelType: {
+            type: StringConstructor;
+            required: false;
+        };
+        eventBus: {
+            type: ObjectConstructor;
+            required: false;
+        };
+        approvalConfig: {
+            type: () => import("../typing.js").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.js").SearchConfig[];
+                    (...items: import("../typing.js").SearchConfig[]): import("../typing.js").SearchConfig[];
+                    new (arrayLength: number): import("../typing.js").SearchConfig[];
+                    new (...items: import("../typing.js").SearchConfig[]): import("../typing.js").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.js").Condition[];
+                    (...items: import("../typing.js").Condition[]): import("../typing.js").Condition[];
+                    new (arrayLength: number): import("../typing.js").Condition[];
+                    new (...items: import("../typing.js").Condition[]): import("../typing.js").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.js").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.js").SearchConfig[];
+                    (...items: import("../typing.js").SearchConfig[]): import("../typing.js").SearchConfig[];
+                    new (arrayLength: number): import("../typing.js").SearchConfig[];
+                    new (...items: import("../typing.js").SearchConfig[]): import("../typing.js").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.js").Condition[];
+                    (...items: import("../typing.js").Condition[]): import("../typing.js").Condition[];
+                    new (arrayLength: number): import("../typing.js").Condition[];
+                    new (...items: import("../typing.js").Condition[]): import("../typing.js").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.js").SearchConfig[];
+                        (...items: import("../typing.js").SearchConfig[]): import("../typing.js").SearchConfig[];
+                        new (arrayLength: number): import("../typing.js").SearchConfig[];
+                        new (...items: import("../typing.js").SearchConfig[]): import("../typing.js").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.js").Condition[];
+                        (...items: import("../typing.js").Condition[]): import("../typing.js").Condition[];
+                        new (arrayLength: number): import("../typing.js").Condition[];
+                        new (...items: import("../typing.js").Condition[]): import("../typing.js").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.js").SearchConfig[];
+                        (...items: import("../typing.js").SearchConfig[]): import("../typing.js").SearchConfig[];
+                        new (arrayLength: number): import("../typing.js").SearchConfig[];
+                        new (...items: import("../typing.js").SearchConfig[]): import("../typing.js").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.js").Condition[];
+                        (...items: import("../typing.js").Condition[]): import("../typing.js").Condition[];
+                        new (arrayLength: number): import("../typing.js").Condition[];
+                        new (...items: import("../typing.js").Condition[]): import("../typing.js").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.js").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.js").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/columnForm.vue.d.ts

@@ -0,0 +1,26 @@
+import { ApprovalSetting, FormSection } from '../typing';
+interface ApprovalEventBus {
+    on(event: string, handler: (payload: any) => void): void;
+    off(event: string, handler: (payload: any) => void): void;
+    emit(event: string, payload?: any): void;
+}
+/**
+ * 必须放在普通 <script> 块里（<script setup> 不允许 ES 模块导出）：
+ * 父组件 index.vue 的默认导出类型会引用本组件的 props 类型，类型不可命名时
+ * vue-tsc 既产不出本文件的 .d.ts，也会连锁让 index.vue 报 TS4082。
+ */
+export interface ColumnFormProps {
+    columnConfig: FormSection;
+    height: number;
+    modelType: string;
+    eventBus: ApprovalEventBus;
+    globalData: Record<string, any>;
+    topFormRef: any;
+    approvalConfig: ApprovalSetting;
+}
+declare const _default: import("vue").DefineComponent<ColumnFormProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    globalDataChange: (update: any) => any;
+}, string, import("vue").PublicProps, Readonly<ColumnFormProps> & Readonly<{
+    onGlobalDataChange?: (update: any) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;