npm - @geelato/gl-ui-web-arco - Versions diffs - 0.0.1 - Mend

@geelato/gl-ui-web-arco 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (201) hide show

package/dist/types/components/gl-workflow/GlWorkflowModal.vue.d.ts ADDED Viewed

@@ -0,0 +1,2086 @@
+import { Ref, CreateComponentPublicInstanceWithMixins, ExtractPropTypes, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, PropType, ComputedRef, ComponentProvideOptions, DefineComponent } from '../../../vue/dist/vue.esm-bundler.js';
+import { FieldRule, ValidatedError } from '@arco-design/web-vue';
+import { FieldData } from '@arco-design/web-vue/es/form/interface';
+import { Options } from 'scroll-into-view-if-needed';
+import { WorkflowStartFormProps, LayoutModeType } from './types';
+import { WorkflowUser, WorkflowNextStep, PageCustomType, PagePermission } from '@geelato/gl-runtime-core';
+import { IComponentInstance } from '@geelato/gl-types';
+import { ComponentInstance } from '@geelato/gl-ui-schema';
+import { TabsPosition } from '@arco-design/web-vue/es/tabs/interface';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {
+        workflowApprove: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+            procId: {
+                type: StringConstructor;
+                required: boolean;
+            };
+            taskId: {
+                type: StringConstructor;
+                required: boolean;
+            };
+            readonly: BooleanConstructor;
+            disabled: BooleanConstructor;
+        }>> & Readonly<{
+            "onUpdate:tran"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            validate: () => any;
+            submitApproval: () => Promise<void>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            "update:tran": (...args: any[]) => void;
+            "update:remark": (...args: any[]) => void;
+            "update:attachIds": (...args: any[]) => void;
+        }, PublicProps, {
+            disabled: boolean;
+            readonly: boolean;
+        }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+            myForm: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+                model: {
+                    type: ObjectConstructor;
+                    required: true;
+                };
+                layout: {
+                    type: PropType<"inline" | "horizontal" | "vertical">;
+                    default: string;
+                };
+                size: {
+                    type: PropType<"mini" | "small" | "medium" | "large">;
+                };
+                labelColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                wrapperColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                labelColStyle: ObjectConstructor;
+                wrapperColStyle: ObjectConstructor;
+                labelAlign: {
+                    type: PropType<"left" | "right">;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                rules: {
+                    type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+                };
+                autoLabelWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                id: {
+                    type: StringConstructor;
+                };
+                scrollToFirstError: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onSubmit?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError> | undefined;
+                }, ev: Event) => any) | undefined;
+                onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+                onSubmitFailed?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError>;
+                }, ev: Event) => any) | undefined;
+            }>, {
+                cls: ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+                handleSubmit: (e: Event) => void;
+                innerValidate: (callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerValidateField: (field: string | string[], callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerResetFields: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerClearValidate: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerSetFields: (data: Record<string, FieldData>) => void;
+                innerScrollToField: (field: string, options
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: Options<any> | undefined) => void;
+            }, {}, {}, {
+                validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                resetFields(field?: string | string[] | undefined): void;
+                clearValidate(field?: string | string[] | undefined): void;
+                setFields(data: Record<string, FieldData>): void;
+                scrollToField(field: string): void;
+            }, ComponentOptionsMixin, ComponentOptionsMixin, {
+                submit: (data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError> | undefined;
+                }, ev: Event) => true;
+                submitSuccess: (values: Record<string, any>, ev: Event) => true;
+                submitFailed: (data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError>;
+                }, ev: Event) => true;
+            }, PublicProps, {
+                disabled: boolean;
+                layout: "inline" | "horizontal" | "vertical";
+                labelColProps: Record<string, any>;
+                wrapperColProps: Record<string, any>;
+                labelAlign: "left" | "right";
+                autoLabelWidth: boolean;
+                scrollToFirstError: boolean;
+            }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly< ExtractPropTypes<{
+                model: {
+                    type: ObjectConstructor;
+                    required: true;
+                };
+                layout: {
+                    type: PropType<"inline" | "horizontal" | "vertical">;
+                    default: string;
+                };
+                size: {
+                    type: PropType<"mini" | "small" | "medium" | "large">;
+                };
+                labelColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                wrapperColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                labelColStyle: ObjectConstructor;
+                wrapperColStyle: ObjectConstructor;
+                labelAlign: {
+                    type: PropType<"left" | "right">;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                rules: {
+                    type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+                };
+                autoLabelWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                id: {
+                    type: StringConstructor;
+                };
+                scrollToFirstError: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onSubmit?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError> | undefined;
+                }, ev: Event) => any) | undefined;
+                onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+                onSubmitFailed?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError>;
+                }, ev: Event) => any) | undefined;
+            }>, {
+                cls: ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+                handleSubmit: (e: Event) => void;
+                innerValidate: (callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerValidateField: (field: string | string[], callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerResetFields: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerClearValidate: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerSetFields: (data: Record<string, FieldData>) => void;
+                innerScrollToField: (field: string, options
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: Options<any> | undefined) => void;
+            }, {}, {}, {
+                validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                resetFields(field?: string | string[] | undefined): void;
+                clearValidate(field?: string | string[] | undefined): void;
+                setFields(data: Record<string, FieldData>): void;
+                scrollToField(field: string): void;
+            }, {
+                disabled: boolean;
+                layout: "inline" | "horizontal" | "vertical";
+                labelColProps: Record<string, any>;
+                wrapperColProps: Record<string, any>;
+                labelAlign: "left" | "right";
+                autoLabelWidth: boolean;
+                scrollToFirstError: boolean;
+            }> | null;
+        }, any, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< ExtractPropTypes<{
+            procId: {
+                type: StringConstructor;
+                required: boolean;
+            };
+            taskId: {
+                type: StringConstructor;
+                required: boolean;
+            };
+            readonly: BooleanConstructor;
+            disabled: BooleanConstructor;
+        }>> & Readonly<{
+            "onUpdate:tran"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            validate: () => any;
+            submitApproval: () => Promise<void>;
+        }, {}, {}, {}, {
+            disabled: boolean;
+            readonly: boolean;
+        }> | null;
+        workflowStartForm: CreateComponentPublicInstanceWithMixins<Readonly< WorkflowStartFormProps> & Readonly<{
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            validate: () => Promise<boolean>;
+            getFormData: () => {
+                remark: string;
+                attachIds: string;
+                selectedSteps: {
+                    stepUserList: WorkflowUser[] | undefined;
+                    stepName: string;
+                    stepTargetName: string;
+                    targetRef: string;
+                    subStepList: WorkflowNextStep[] | null;
+                    isAgree: boolean | null;
+                    selected?: boolean;
+                    selectedUsers?: string[];
+                }[];
+            };
+            submit: () => Promise<boolean>;
+            onStepSelectionChange: (step: WorkflowNextStep) => Promise<void>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            submit: (...args: any[]) => void;
+            "update:remark": (...args: any[]) => void;
+            "update:attachIds": (...args: any[]) => void;
+        }, PublicProps, {
+            disabled: boolean;
+            readonly: boolean;
+            remark: string;
+            attachIds: string;
+            hideSubmitButton: boolean;
+            submitButtonText: string;
+        }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+            myForm: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+                model: {
+                    type: ObjectConstructor;
+                    required: true;
+                };
+                layout: {
+                    type: PropType<"inline" | "horizontal" | "vertical">;
+                    default: string;
+                };
+                size: {
+                    type: PropType<"mini" | "small" | "medium" | "large">;
+                };
+                labelColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                wrapperColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                labelColStyle: ObjectConstructor;
+                wrapperColStyle: ObjectConstructor;
+                labelAlign: {
+                    type: PropType<"left" | "right">;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                rules: {
+                    type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+                };
+                autoLabelWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                id: {
+                    type: StringConstructor;
+                };
+                scrollToFirstError: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onSubmit?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError> | undefined;
+                }, ev: Event) => any) | undefined;
+                onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+                onSubmitFailed?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError>;
+                }, ev: Event) => any) | undefined;
+            }>, {
+                cls: ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+                handleSubmit: (e: Event) => void;
+                innerValidate: (callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerValidateField: (field: string | string[], callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerResetFields: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerClearValidate: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerSetFields: (data: Record<string, FieldData>) => void;
+                innerScrollToField: (field: string, options
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: Options<any> | undefined) => void;
+            }, {}, {}, {
+                validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                resetFields(field?: string | string[] | undefined): void;
+                clearValidate(field?: string | string[] | undefined): void;
+                setFields(data: Record<string, FieldData>): void;
+                scrollToField(field: string): void;
+            }, ComponentOptionsMixin, ComponentOptionsMixin, {
+                submit: (data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError> | undefined;
+                }, ev: Event) => true;
+                submitSuccess: (values: Record<string, any>, ev: Event) => true;
+                submitFailed: (data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError>;
+                }, ev: Event) => true;
+            }, PublicProps, {
+                disabled: boolean;
+                layout: "inline" | "horizontal" | "vertical";
+                labelColProps: Record<string, any>;
+                wrapperColProps: Record<string, any>;
+                labelAlign: "left" | "right";
+                autoLabelWidth: boolean;
+                scrollToFirstError: boolean;
+            }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly< ExtractPropTypes<{
+                model: {
+                    type: ObjectConstructor;
+                    required: true;
+                };
+                layout: {
+                    type: PropType<"inline" | "horizontal" | "vertical">;
+                    default: string;
+                };
+                size: {
+                    type: PropType<"mini" | "small" | "medium" | "large">;
+                };
+                labelColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                wrapperColProps: {
+                    type: ObjectConstructor;
+                    default: () => {
+                        span: number;
+                        offset: number;
+                    };
+                };
+                labelColStyle: ObjectConstructor;
+                wrapperColStyle: ObjectConstructor;
+                labelAlign: {
+                    type: PropType<"left" | "right">;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                rules: {
+                    type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+                };
+                autoLabelWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                id: {
+                    type: StringConstructor;
+                };
+                scrollToFirstError: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onSubmit?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError> | undefined;
+                }, ev: Event) => any) | undefined;
+                onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+                onSubmitFailed?: ((data: {
+                    values: Record<string, any>;
+                    errors: Record<string, ValidatedError>;
+                }, ev: Event) => any) | undefined;
+            }>, {
+                cls: ComputedRef<(string | {
+                    [x: string]: boolean;
+                })[]>;
+                formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+                handleSubmit: (e: Event) => void;
+                innerValidate: (callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerValidateField: (field: string | string[], callback
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+                innerResetFields: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerClearValidate: (field
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: string | string[] | undefined) => void;
+                innerSetFields: (data: Record<string, FieldData>) => void;
+                innerScrollToField: (field: string, options
+                /**
+                 *  基于状态机实现的审批模板
+                 *
+                 *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+                 *  1、新流程时，会传流程定义id（key），打开本界面;
+                 *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+                 *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+                 *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+                 *     - 基于业务表单id加载表单数据;
+                 *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+                 *     - 这里可分为单步骤，还有多步骤。
+                 *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+                 *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+                 *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+                 *     - 填完信息，调用接口runWorkflow提交表单。
+                 *
+                 *
+                 *
+                 *  对内嵌入的组件，可以调和如下方法：
+                 *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+                 */
+                ?: Options<any> | undefined) => void;
+            }, {}, {}, {
+                validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+                resetFields(field?: string | string[] | undefined): void;
+                clearValidate(field?: string | string[] | undefined): void;
+                setFields(data: Record<string, FieldData>): void;
+                scrollToField(field: string): void;
+            }, {
+                disabled: boolean;
+                layout: "inline" | "horizontal" | "vertical";
+                labelColProps: Record<string, any>;
+                wrapperColProps: Record<string, any>;
+                labelAlign: "left" | "right";
+                autoLabelWidth: boolean;
+                scrollToFirstError: boolean;
+            }> | null;
+        }, HTMLDivElement, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< WorkflowStartFormProps> & Readonly<{
+            onSubmit?: ((...args: any[]) => any) | undefined;
+            "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+            "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            validate: () => Promise<boolean>;
+            getFormData: () => {
+                remark: string;
+                attachIds: string;
+                selectedSteps: {
+                    stepUserList: WorkflowUser[] | undefined;
+                    stepName: string;
+                    stepTargetName: string;
+                    targetRef: string;
+                    subStepList: WorkflowNextStep[] | null;
+                    isAgree: boolean | null;
+                    selected?: boolean;
+                    selectedUsers?: string[];
+                }[];
+            };
+            submit: () => Promise<boolean>;
+            onStepSelectionChange: (step: WorkflowNextStep) => Promise<void>;
+        }, {}, {}, {}, {
+            disabled: boolean;
+            readonly: boolean;
+            remark: string;
+            attachIds: string;
+            hideSubmitButton: boolean;
+            submitButtonText: string;
+        }> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ExtractPropTypes<{
+    parentId: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    glComponentInst: {
+        type: PropType<IComponentInstance>;
+        default(): ComponentInstance;
+    };
+    glChildren: {
+        type: PropType<Array< IComponentInstance>>;
+        default(): never[];
+    };
+    glCtx: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    glIsRuntime: {
+        type: BooleanConstructor;
+        default(): boolean;
+    };
+    glRuntimeFlag: {
+        type: StringConstructor;
+        default(): string;
+    };
+    glIndex: {
+        type: NumberConstructor;
+    };
+    glLoopItem: ObjectConstructor;
+    glLoopIndex: NumberConstructor;
+    glIgnoreInjectPageProxy: {
+        type: BooleanConstructor;
+        default(): boolean;
+    };
+    componentStoreId: {
+        type: StringConstructor;
+        default(): string;
+    };
+    pageCustom: PropType<PageCustomType>;
+    pagePermission: PropType<PagePermission>;
+    glDoAction: {
+        type: FunctionConstructor;
+        required: boolean;
+    };
+    procDefId: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    procInstId: StringConstructor;
+    procTaskId: StringConstructor;
+    bizId: StringConstructor;
+    slotMode: BooleanConstructor;
+    label: StringConstructor;
+    subLabel: StringConstructor;
+    layoutMode: {
+        type: PropType<LayoutModeType>;
+        default(): string;
+    };
+    tabsPosition: {
+        type: PropType<TabsPosition>;
+        required: boolean;
+    };
+    enabledStatusImage: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+}>, {
+    startNewWorkflow: (formData: Record<string, any>) => Promise<boolean>;
+    submitAndStartWorkflow: () => Promise<boolean>;
+    submitWorkflowTask: () => Promise<boolean>;
+    saveFormAndSubmitTask: () => Promise<boolean>;
+    onStepSelectionChange: (step: any) => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    parentId: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    glComponentInst: {
+        type: PropType<IComponentInstance>;
+        default(): ComponentInstance;
+    };
+    glChildren: {
+        type: PropType<Array< IComponentInstance>>;
+        default(): never[];
+    };
+    glCtx: {
+        type: ObjectConstructor;
+        default(): {};
+    };
+    glIsRuntime: {
+        type: BooleanConstructor;
+        default(): boolean;
+    };
+    glRuntimeFlag: {
+        type: StringConstructor;
+        default(): string;
+    };
+    glIndex: {
+        type: NumberConstructor;
+    };
+    glLoopItem: ObjectConstructor;
+    glLoopIndex: NumberConstructor;
+    glIgnoreInjectPageProxy: {
+        type: BooleanConstructor;
+        default(): boolean;
+    };
+    componentStoreId: {
+        type: StringConstructor;
+        default(): string;
+    };
+    pageCustom: PropType<PageCustomType>;
+    pagePermission: PropType<PagePermission>;
+    glDoAction: {
+        type: FunctionConstructor;
+        required: boolean;
+    };
+    procDefId: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    procInstId: StringConstructor;
+    procTaskId: StringConstructor;
+    bizId: StringConstructor;
+    slotMode: BooleanConstructor;
+    label: StringConstructor;
+    subLabel: StringConstructor;
+    layoutMode: {
+        type: PropType<LayoutModeType>;
+        default(): string;
+    };
+    tabsPosition: {
+        type: PropType<TabsPosition>;
+        required: boolean;
+    };
+    enabledStatusImage: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    glComponentInst: IComponentInstance;
+    glChildren: IComponentInstance[];
+    glCtx: Record<string, any>;
+    glIsRuntime: boolean;
+    glRuntimeFlag: string;
+    glIgnoreInjectPageProxy: boolean;
+    componentStoreId: string;
+    readonly: boolean;
+    layoutMode: LayoutModeType;
+    enabledStatusImage: boolean;
+    slotMode: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {
+    workflowApprove: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        procId: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        taskId: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        readonly: BooleanConstructor;
+        disabled: BooleanConstructor;
+    }>> & Readonly<{
+        "onUpdate:tran"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        validate: () => any;
+        submitApproval: () => Promise<void>;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        "update:tran": (...args: any[]) => void;
+        "update:remark": (...args: any[]) => void;
+        "update:attachIds": (...args: any[]) => void;
+    }, PublicProps, {
+        disabled: boolean;
+        readonly: boolean;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        myForm: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+            model: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            layout: {
+                type: PropType<"inline" | "horizontal" | "vertical">;
+                default: string;
+            };
+            size: {
+                type: PropType<"mini" | "small" | "medium" | "large">;
+            };
+            labelColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            wrapperColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            labelColStyle: ObjectConstructor;
+            wrapperColStyle: ObjectConstructor;
+            labelAlign: {
+                type: PropType<"left" | "right">;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            rules: {
+                type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+            };
+            autoLabelWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+            };
+            scrollToFirstError: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError> | undefined;
+            }, ev: Event) => any) | undefined;
+            onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+            onSubmitFailed?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError>;
+            }, ev: Event) => any) | undefined;
+        }>, {
+            cls: ComputedRef<(string | {
+                [x: string]: boolean;
+            })[]>;
+            formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+            handleSubmit: (e: Event) => void;
+            innerValidate: (callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerValidateField: (field: string | string[], callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerResetFields: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerClearValidate: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerSetFields: (data: Record<string, FieldData>) => void;
+            innerScrollToField: (field: string, options
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: Options<any> | undefined) => void;
+        }, {}, {}, {
+            validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            resetFields(field?: string | string[] | undefined): void;
+            clearValidate(field?: string | string[] | undefined): void;
+            setFields(data: Record<string, FieldData>): void;
+            scrollToField(field: string): void;
+        }, ComponentOptionsMixin, ComponentOptionsMixin, {
+            submit: (data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError> | undefined;
+            }, ev: Event) => true;
+            submitSuccess: (values: Record<string, any>, ev: Event) => true;
+            submitFailed: (data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError>;
+            }, ev: Event) => true;
+        }, PublicProps, {
+            disabled: boolean;
+            layout: "inline" | "horizontal" | "vertical";
+            labelColProps: Record<string, any>;
+            wrapperColProps: Record<string, any>;
+            labelAlign: "left" | "right";
+            autoLabelWidth: boolean;
+            scrollToFirstError: boolean;
+        }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< ExtractPropTypes<{
+            model: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            layout: {
+                type: PropType<"inline" | "horizontal" | "vertical">;
+                default: string;
+            };
+            size: {
+                type: PropType<"mini" | "small" | "medium" | "large">;
+            };
+            labelColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            wrapperColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            labelColStyle: ObjectConstructor;
+            wrapperColStyle: ObjectConstructor;
+            labelAlign: {
+                type: PropType<"left" | "right">;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            rules: {
+                type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+            };
+            autoLabelWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+            };
+            scrollToFirstError: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError> | undefined;
+            }, ev: Event) => any) | undefined;
+            onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+            onSubmitFailed?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError>;
+            }, ev: Event) => any) | undefined;
+        }>, {
+            cls: ComputedRef<(string | {
+                [x: string]: boolean;
+            })[]>;
+            formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+            handleSubmit: (e: Event) => void;
+            innerValidate: (callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerValidateField: (field: string | string[], callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerResetFields: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerClearValidate: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerSetFields: (data: Record<string, FieldData>) => void;
+            innerScrollToField: (field: string, options
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: Options<any> | undefined) => void;
+        }, {}, {}, {
+            validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            resetFields(field?: string | string[] | undefined): void;
+            clearValidate(field?: string | string[] | undefined): void;
+            setFields(data: Record<string, FieldData>): void;
+            scrollToField(field: string): void;
+        }, {
+            disabled: boolean;
+            layout: "inline" | "horizontal" | "vertical";
+            labelColProps: Record<string, any>;
+            wrapperColProps: Record<string, any>;
+            labelAlign: "left" | "right";
+            autoLabelWidth: boolean;
+            scrollToFirstError: boolean;
+        }> | null;
+    }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        procId: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        taskId: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        readonly: BooleanConstructor;
+        disabled: BooleanConstructor;
+    }>> & Readonly<{
+        "onUpdate:tran"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        validate: () => any;
+        submitApproval: () => Promise<void>;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        readonly: boolean;
+    }> | null;
+    workflowStartForm: CreateComponentPublicInstanceWithMixins<Readonly< WorkflowStartFormProps> & Readonly<{
+        onSubmit?: ((...args: any[]) => any) | undefined;
+        "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        validate: () => Promise<boolean>;
+        getFormData: () => {
+            remark: string;
+            attachIds: string;
+            selectedSteps: {
+                stepUserList: WorkflowUser[] | undefined;
+                stepName: string;
+                stepTargetName: string;
+                targetRef: string;
+                subStepList: WorkflowNextStep[] | null;
+                isAgree: boolean | null;
+                selected?: boolean;
+                selectedUsers?: string[];
+            }[];
+        };
+        submit: () => Promise<boolean>;
+        onStepSelectionChange: (step: WorkflowNextStep) => Promise<void>;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        submit: (...args: any[]) => void;
+        "update:remark": (...args: any[]) => void;
+        "update:attachIds": (...args: any[]) => void;
+    }, PublicProps, {
+        disabled: boolean;
+        readonly: boolean;
+        remark: string;
+        attachIds: string;
+        hideSubmitButton: boolean;
+        submitButtonText: string;
+    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        myForm: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+            model: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            layout: {
+                type: PropType<"inline" | "horizontal" | "vertical">;
+                default: string;
+            };
+            size: {
+                type: PropType<"mini" | "small" | "medium" | "large">;
+            };
+            labelColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            wrapperColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            labelColStyle: ObjectConstructor;
+            wrapperColStyle: ObjectConstructor;
+            labelAlign: {
+                type: PropType<"left" | "right">;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            rules: {
+                type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+            };
+            autoLabelWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+            };
+            scrollToFirstError: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError> | undefined;
+            }, ev: Event) => any) | undefined;
+            onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+            onSubmitFailed?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError>;
+            }, ev: Event) => any) | undefined;
+        }>, {
+            cls: ComputedRef<(string | {
+                [x: string]: boolean;
+            })[]>;
+            formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+            handleSubmit: (e: Event) => void;
+            innerValidate: (callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerValidateField: (field: string | string[], callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerResetFields: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerClearValidate: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerSetFields: (data: Record<string, FieldData>) => void;
+            innerScrollToField: (field: string, options
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: Options<any> | undefined) => void;
+        }, {}, {}, {
+            validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            resetFields(field?: string | string[] | undefined): void;
+            clearValidate(field?: string | string[] | undefined): void;
+            setFields(data: Record<string, FieldData>): void;
+            scrollToField(field: string): void;
+        }, ComponentOptionsMixin, ComponentOptionsMixin, {
+            submit: (data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError> | undefined;
+            }, ev: Event) => true;
+            submitSuccess: (values: Record<string, any>, ev: Event) => true;
+            submitFailed: (data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError>;
+            }, ev: Event) => true;
+        }, PublicProps, {
+            disabled: boolean;
+            layout: "inline" | "horizontal" | "vertical";
+            labelColProps: Record<string, any>;
+            wrapperColProps: Record<string, any>;
+            labelAlign: "left" | "right";
+            autoLabelWidth: boolean;
+            scrollToFirstError: boolean;
+        }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly< ExtractPropTypes<{
+            model: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            layout: {
+                type: PropType<"inline" | "horizontal" | "vertical">;
+                default: string;
+            };
+            size: {
+                type: PropType<"mini" | "small" | "medium" | "large">;
+            };
+            labelColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            wrapperColProps: {
+                type: ObjectConstructor;
+                default: () => {
+                    span: number;
+                    offset: number;
+                };
+            };
+            labelColStyle: ObjectConstructor;
+            wrapperColStyle: ObjectConstructor;
+            labelAlign: {
+                type: PropType<"left" | "right">;
+                default: string;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            rules: {
+                type: PropType<Record<string, FieldRule<any> | FieldRule<any>[]>>;
+            };
+            autoLabelWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+            };
+            scrollToFirstError: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            onSubmit?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError> | undefined;
+            }, ev: Event) => any) | undefined;
+            onSubmitSuccess?: ((values: Record<string, any>, ev: Event) => any) | undefined;
+            onSubmitFailed?: ((data: {
+                values: Record<string, any>;
+                errors: Record<string, ValidatedError>;
+            }, ev: Event) => any) | undefined;
+        }>, {
+            cls: ComputedRef<(string | {
+                [x: string]: boolean;
+            })[]>;
+            formRef: Ref<HTMLFormElement | undefined, HTMLFormElement | undefined>;
+            handleSubmit: (e: Event) => void;
+            innerValidate: (callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerValidateField: (field: string | string[], callback
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined) => Promise<Record<string, ValidatedError> | undefined>;
+            innerResetFields: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerClearValidate: (field
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: string | string[] | undefined) => void;
+            innerSetFields: (data: Record<string, FieldData>) => void;
+            innerScrollToField: (field: string, options
+            /**
+             *  基于状态机实现的审批模板
+             *
+             *  准备新启动流程时会打开该界面，处理流程步骤，如审批、加签、转交等也会使用该界面
+             *  1、新流程时，会传流程定义id（key），打开本界面;
+             *     - 基于流程定义id，通过接口（queryNextStepPrediction）加载下一步信息及发送人，列出可选的步骤，选择发送人。
+             *     - 保存时，先保存表单，获取表单数据，然后调用接口（startWorkflowAtomicity）启动流程。
+             *  2、流程处理时，会传流程实例id、任务id、业务表单id，打开本界面;
+             *     - 基于业务表单id加载表单数据;
+             *     - 基于流程procId、taskId，通过接口（queryNextStep）加载下一步信息，列出可选的步骤。
+             *     - 这里可分为单步骤，还有多步骤。
+             *        - 单步骤时，选择步骤后，进一步可以选择发送人（通过queryNextStep获取发送人）。
+             *        - 多步骤时，需要为每一个步骤，选择发送人（通过queryNextStep获取发送人）。
+             *        - 提交表单时，会传流程实例id、任务id、业务表单id；则基于业务表单id加载表单数据;
+             *     - 填完信息，调用接口runWorkflow提交表单。
+             *
+             *
+             *
+             *  对内嵌入的组件，可以调和如下方法：
+             *  pageProvideProxy.pageTemplate?.onBeforeSubmit
+             */
+            ?: Options<any> | undefined) => void;
+        }, {}, {}, {
+            validate(callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            validateField(field: string | string[], callback?: ((errors: Record<string, ValidatedError> | undefined) => void) | undefined): Promise<Record<string, ValidatedError> | undefined>;
+            resetFields(field?: string | string[] | undefined): void;
+            clearValidate(field?: string | string[] | undefined): void;
+            setFields(data: Record<string, FieldData>): void;
+            scrollToField(field: string): void;
+        }, {
+            disabled: boolean;
+            layout: "inline" | "horizontal" | "vertical";
+            labelColProps: Record<string, any>;
+            wrapperColProps: Record<string, any>;
+            labelAlign: "left" | "right";
+            autoLabelWidth: boolean;
+            scrollToFirstError: boolean;
+        }> | null;
+    }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< WorkflowStartFormProps> & Readonly<{
+        onSubmit?: ((...args: any[]) => any) | undefined;
+        "onUpdate:remark"?: ((...args: any[]) => any) | undefined;
+        "onUpdate:attachIds"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        validate: () => Promise<boolean>;
+        getFormData: () => {
+            remark: string;
+            attachIds: string;
+            selectedSteps: {
+                stepUserList: WorkflowUser[] | undefined;
+                stepName: string;
+                stepTargetName: string;
+                targetRef: string;
+                subStepList: WorkflowNextStep[] | null;
+                isAgree: boolean | null;
+                selected?: boolean;
+                selectedUsers?: string[];
+            }[];
+        };
+        submit: () => Promise<boolean>;
+        onStepSelectionChange: (step: WorkflowNextStep) => Promise<void>;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        readonly: boolean;
+        remark: string;
+        attachIds: string;
+        hideSubmitButton: boolean;
+        submitButtonText: string;
+    }> | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};