lyflowchart 1.0.115 → 1.0.133

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

@@ -0,0 +1,416 @@
+import { Table, ApprovalSetting } from '../typing';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    config: {
+        type: () => 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("@/components/approval/store/context").ContextState, {}, {
+        init(model_type: string): import("@/components/approval/store/context").Context;
+        initTable(model_type: string, table_id: string): import("@/components/approval/store/context").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: () => 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>;
+export default _default;

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

@@ -0,0 +1,84 @@
+import { PropType } from 'vue';
+import { ApprovalSetting } from '../typing';
+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;
+    };
+    tables: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    title: {
+        type: StringConstructor;
+        required: true;
+    };
+    hideAllButtons: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    open: {
+        type: PropType<boolean>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: (...args: any[]) => void;
+    ok: (...args: any[]) => void;
+    "update:open": (value: boolean) => void;
+}, 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;
+    };
+    approvalConfig: {
+        type: PropType<ApprovalSetting>;
+        required: true;
+    };
+    tables: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    title: {
+        type: StringConstructor;
+        required: true;
+    };
+    hideAllButtons: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    open: {
+        type: PropType<boolean>;
+    };
+}>> & Readonly<{
+    onCancel?: (...args: any[]) => any;
+    onOk?: (...args: any[]) => any;
+    "onUpdate:open"?: (value: boolean) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/approval/configs/approval/default.d.ts

@@ -0,0 +1,11 @@
+import { ApprovalSetting, DataListSection } from '../../typing';
+/**
+ * 「审批列表」列的默认配置。
+ *
+ * 不带任何入参：配置里与节点相关的东西一律用 {{xxx}} 占位符表示（见 menu_flag 条件），
+ * 实际值由执行查询处注入（src/views/approval/utils.ts::resolveParamValue）。
+ * 这样同一份配置可以直接同步到其他节点，不需要按节点改写。
+ */
+export declare const getDataListConfig: () => DataListSection;
+declare const _default: () => ApprovalSetting;
+export default _default;

package/dist/components/approval/configs/approval/recordActions.d.ts

@@ -0,0 +1,22 @@
+import { Action } from '../../typing';
+/**
+ * 修改审批（edit_approve）。
+ *
+ * 每次调用返回**新对象**：页面配置处理链（`approval/index.ts::processAction`）会往 action 上写
+ * `action_code_id` 等运行时字段，共用单例会把脏状态带到下一次取配置。
+ */
+export declare const getEditApproveAction: () => Action;
+/**
+ * 删除审批（cancel_agree_approve）—— 语义是「作废已通过的审批」，需要填作废原因，
+ * 前端弹 `CancelModal`，落到后端 `/approve/cancel_agree_approve_record`。
+ */
+export declare const getCancelAgreeApproveAction: () => Action;
+/**
+ * 详情场景用到的两个 action，按 action 名索引。
+ * 供 `useApprovalRecordActions`（→ `Cell_click_approve` / `Cell_click_data_source` 的外置按钮）
+ * 取默认的显示判断逻辑与点击取数代码。
+ */
+export declare const getApproveRecordActions: () => {
+    edit_approve: Action;
+    cancel_agree_approve: Action;
+};

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

@@ -0,0 +1,53 @@
+import './style.less';
+/**
+ * 审批「左中右三栏」核心组件 —— **不依赖路由**。
+ *
+ * 为什么要有这一层：审批页原本只有「路由页面」一种用法，`modelType` 是从 `route.path`
+ * 末段推出来的。现在详情页/列表单元格要把它当作**全屏模态框**弹出来（修改、删除后编辑），
+ * 那里没有对应路由，所以把「一切靠参数控制」的部分抽成本组件：
+ *
+ *   - `modelType`（= 页面配置的 menu_flag）：**prop 传入**，不再读路由；
+ *   - `approveRecordId`：**可选**。传了就表示「打开即进入编辑态」，见 onMounted 的说明。
+ *
+ * 两种用法：
+ *   1. 路由页面 → `approval/index.vue`（薄壳，从路由推出 modelType）；
+ *   2. 全屏模态 → `approval/ApprovalEditorModal.vue`（传 modelType + approveRecordId）。
+ * 两者共用本组件，逻辑只有一份。
+ *
+ * ⚠️ props 必须放在普通 `<script>` 块里 export（与 columnForm.vue 的 ColumnFormProps 同理）：
+ * 模态框组件会持有本组件的模板 ref，TS 需要能**命名**这个 props 类型；放在 <script setup> 里
+ * 无法 export，会导致本文件产不出 .d.ts，并连锁让引用方报 TS4082。
+ */
+export interface ApprovalCoreProps {
+    /** 页面配置的菜单标识（menu_flag）。原来从 route.path 末段取，现在由调用方传入 */
+    modelType: string;
+    /**
+     * 打开即进入编辑态的审批记录 id（ApproveRecord.id）。
+     * 不传 = 普通用法，编辑态由页面自身事件驱动（路由页面的用法）。
+     */
+    approveRecordId?: number | null;
+}
+declare global {
+    interface Window {
+        setDebugCode?: (checked: boolean) => void;
+    }
+}
+declare const _default: import("vue").DefineComponent<ApprovalCoreProps, {
+    /** 按审批记录 id 进入编辑态（编辑态种类由记录字段派生，见上方注释） */
+    applyApproveRecord: (id: number) => Promise<void>;
+    /** 重新拉取页面配置与全局数据 */
+    reinit: () => Promise<void>;
+    /** 供外部（模态框）在需要时重新量一次高度 */
+    resize: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    saved: (payload: {
+        isEdit?: boolean;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<ApprovalCoreProps> & Readonly<{
+    onSaved?: (payload: {
+        isEdit?: boolean;
+    }) => any;
+}>, {
+    approveRecordId: number | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/approval/example_code/example_code.d.ts

@@ -0,0 +1,11 @@
+export declare const exampleCodeList: ({
+    label: string;
+    value: string;
+    actions: string[];
+    types: string[];
+} | {
+    label: string;
+    value: string;
+    types: string[];
+    actions?: undefined;
+})[];

package/dist/components/approval/index.d.ts

@@ -0,0 +1,18 @@
+import { ApprovalSetting, DataStoreConfigType } from './typing';
+export declare const getApprovalConfig: (key: string, detial?: Array<any> | null, history_id?: Number | null) => Promise<{
+    config: ApprovalSetting;
+    current_history_id: any;
+}>;
+export declare const getFlowConfig: (key: string, history_id?: Number | null) => Promise<{
+    content: any;
+    name: any;
+    enable_flow: any;
+    cc_approval_position: any;
+    cc_position: any;
+    cc_users: any;
+    current_history_id: any;
+}>;
+export declare const getDataStoreConfig: (key: string, history_id?: Number | null) => Promise<{
+    config: DataStoreConfigType;
+    current_history_id: any;
+}>;

package/dist/components/approval/index.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;

package/dist/components/approval/migrate/index.d.ts

@@ -0,0 +1 @@
+export declare const migrate: (data: any) => Promise<any>;

package/dist/components/approval/migrate/v0001.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (data: any) => any;
+export default _default;