lyflowchart 1.0.115 → 1.0.130

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

@@ -0,0 +1,504 @@
+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;
+    };
+}>, {
+    open: import("vue").Ref<boolean, boolean>;
+    openDrawer: () => void;
+    teleportTo: import("vue").Ref<string, string>;
+}, {}, {}, {}, 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;
+    };
+    approvalConfig: {
+        type: PropType<ApprovalSetting>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    columnDataList: 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").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").ContextState, {}, {
+                init(model_type: string): import("../store/context").Context;
+                initTable(model_type: string, table_id: string): import("../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").FilterValue | null>, sorter: import("ant-design-vue/es/table/interface").SorterResult<any> | import("ant-design-vue/es/table/interface").SorterResult<any>[], extra: import("ant-design-vue/es/table/interface").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>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;