@vue-start/pro 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,77 +1,1037 @@
-import * as axios from 'axios';
-import { AxiosRequestConfig, AxiosResponse, AxiosInstance, AxiosInterceptorManager } from 'axios';
-import { Observable, Subject, BehaviorSubject } from 'rxjs';
 import * as vue from 'vue';
-import { App } from 'vue';
+import { VNode, ExtractPropTypes, PropType } from 'vue';
+import { Ref, UnwrapNestedRefs, ComputedRef } from '@vue/reactivity';
+import { Subject } from 'rxjs';
+import { IRequestActor } from '@vue-start/request';
 
-declare type ReqType = {
-    body?: Record<string, any>;
-    [key: string]: any;
+declare type TDefaultValueType = "text" | "textarea" | "password" | "digit" | "date" | "dateRange" | "time" | "timeRange" | "select" | "treeSelect" | "checkbox" | "radio" | "slider" | "switch" | "rate" | "cascader";
+declare type TValueType = TDefaultValueType | string;
+declare type TOption = {
+    label?: string;
+    value: string | number;
+    disabled?: boolean;
+};
+declare type TOptions = TOption[];
+declare type TColumn = {
+    title?: string | VNode;
+    dataIndex?: string | number;
+    valueType?: TValueType;
+    formValueType?: TValueType;
+    showProps?: Record<string, any>;
+    formItemProps?: {
+        name?: string;
+        label?: string;
+    };
+    formFieldProps?: Record<string, any>;
+    search?: boolean;
+    hideInTable?: boolean;
+    hideInForm?: boolean;
+    hideInDetail?: boolean;
+    searchSort?: boolean;
+    tableSort?: boolean;
+    formSort?: boolean;
+    descSort?: boolean;
+    extra?: {
+        desc?: any;
+    };
 };
+declare type TColumns = TColumn[];
 /**
- * 两种模式
- * requestFromReq ：开发时候创建的
- * requestConfig： 通过配置添加
+ * 发送事件对象
  */
-interface IRequestActor<TReq = any, TRes = any, TErr = any> {
-    name: string;
-    requestFromReq?: (req: TReq) => AxiosRequestConfig;
-    requestConfig?: AxiosRequestConfig;
-    label?: string;
-    req?: TReq;
-    res?: AxiosResponse<TRes>;
-    err?: TErr;
-    stage?: "DONE" | "FAILED" | "CANCEL";
-    id?: string;
+declare type TActionEvent = {
+    type: string;
+    payload?: any;
     extra?: Record<string, any>;
+};
+/**
+ * 发送state对象
+ */
+declare type TActionState = {
+    type: string;
+    payload: any;
+    extra?: Record<string, any>;
+};
+/**
+ * 组件Map
+ */
+declare type TElementMap = Record<string, any>;
+declare type BooleanObjType = {
+    [key: string]: boolean;
+};
+declare type BooleanRulesObjType = {
+    [key: string]: (record: any) => boolean;
+};
+
+/**
+ * 获取Column的valueType，默认"text"
+ * @param column
+ */
+declare const getColumnValueType: (column: TColumn) => TValueType;
+/**
+ *获取Column的FormItem name
+ * @param column
+ */
+declare const getColumnFormItemName: (column: TColumn) => string | number | undefined;
+/**
+ * 根据Column生成FormItem VNode
+ * formFieldProps中的slots参数会以v-slots的形式传递到FormItem的录入组件（子组件）中
+ * @param formElementMap
+ * @param column
+ * @param needRules
+ */
+declare const getFormItemEl: (formElementMap: any, column: TColumn, needRules?: boolean | undefined) => VNode | null;
+/**
+ *  根据Column生成Item VNode
+ * @param elementMap
+ * @param column
+ * @param value
+ */
+declare const getItemEl: <T extends TColumn>(elementMap: any, column: T, value: any) => VNode | null;
+interface IProModuleProvide {
+    columns: Ref<TColumns>;
+    getFormItemVNode: (column: TColumn, needRules: boolean | undefined) => VNode | null;
+    getItemVNode: (column: TColumn, value: any) => VNode | null;
+    elementMap: {
+        [key: string]: any;
+    };
+    formElementMap: {
+        [key: string]: any;
+    };
+    subject$: Subject<TActionEvent>;
+    sendEvent: (action: TActionEvent) => void;
+    state: UnwrapNestedRefs<Record<string, any>>;
+    dispatch: (action: TActionState) => void;
+    requests: IRequestOpts[];
+    sendRequest: (requestNameOrAction: string, ...params: any[]) => void;
+}
+declare const useProModule: () => IProModuleProvide;
+declare const provideProModule: (ctx: IProModuleProvide) => void;
+interface IRequestOpts {
+    actor: IRequestActor;
+    /**
+     * 如果设置action，可以使用该值发起请求 住：要保证唯一性
+     * 设置该字段原因：因为actor中的name不友好，可以理解为一个备选方案
+     */
+    action?: string;
+    stateName?: string;
+    loadingName?: string;
+    convertParams?: (...params: any[]) => Record<string, any>;
+    convertData?: (actor: IRequestActor) => Record<string, any>;
+    onSuccess?: (actor?: IRequestActor) => void;
+    onFailed?: (actor?: IRequestActor) => void;
+}
+declare const RequestAction: {
+    Success: string;
+    Fail: string;
+};
+declare const proModuleProps: () => {
+    /**
+     * module状态
+     */
+    state: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     * 配置（静态）
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 配置（动态）
+     * columns动态属性兼容
+     */
+    columnState: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     * 展示组件集
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 录入组件集
+     */
+    formElementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * requests
+     */
+    requests: {
+        type: PropType<IRequestOpts[]>;
+    };
+};
+declare type ProModuleProps = Partial<ExtractPropTypes<ReturnType<typeof proModuleProps>>>;
+declare const ProModule: vue.DefineComponent<Partial<ExtractPropTypes<{
+    /**
+     * module状态
+     */
+    state: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     * 配置（静态）
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 配置（动态）
+     * columns动态属性兼容
+     */
+    columnState: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     * 展示组件集
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 录入组件集
+     */
+    formElementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * requests
+     */
+    requests: {
+        type: PropType<IRequestOpts[]>;
+    };
+}>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
+    /**
+     * module状态
+     */
+    state: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     * 配置（静态）
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 配置（动态）
+     * columns动态属性兼容
+     */
+    columnState: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     * 展示组件集
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 录入组件集
+     */
+    formElementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * requests
+     */
+    requests: {
+        type: PropType<IRequestOpts[]>;
+    };
+}>>>, {}>;
+
+declare const useModuleEvent: (cb: (action: TActionEvent) => void) => void;
+
+declare const useDoneRequestActor: (actors: (IRequestActor | string)[], callback: (actor: IRequestActor) => void) => void;
+declare const useFailedRequestActor: (actors: (IRequestActor | string)[], callback: (actor: IRequestActor) => void) => void;
+declare const useComposeRequestActor: (actors: (IRequestActor | string)[], options: {
+    onStart?: ((actor: IRequestActor) => void) | undefined;
+    onSuccess?: ((actor: IRequestActor) => void) | undefined;
+    onFailed?: ((actor: IRequestActor) => void) | undefined;
+    onFinish?: ((actor: IRequestActor) => void) | undefined;
+}, cancelWhileUnmount?: boolean | undefined) => void;
+
+interface IProTableProvideExtra extends Record<string, any> {
+}
+interface IProTableProvide extends IProTableProvideExtra {
+    columns: Ref<TTableColumns>;
+}
+declare const useProTable: () => IProTableProvide;
+declare type TTableColumn = {
+    customRender?: (opt: {
+        value: any;
+        text: any;
+        record: Record<string, any>;
+        index: number;
+        column: TTableColumn;
+    }) => VNode;
+    fixed?: boolean | string;
+} & TColumn;
+declare type TTableColumns = TTableColumn[];
+/**
+ * 单个操作描述
+ */
+interface IOperateItem {
+    value: string | number;
+    label?: string | VNode;
+    element?: (record: Record<string, any>, item: IOperateItem) => VNode;
+    show?: boolean | ((record: Record<string, any>) => boolean);
+    disabled?: boolean | ((record: Record<string, any>) => boolean);
+    onClick?: (record: Record<string, any>) => void;
+    sort?: number;
+}
+/**
+ * 整个操作栏描述
+ */
+interface ITableOperate {
+    column?: TColumn;
+    items?: IOperateItem[];
+    itemState?: {
+        [key: string]: Omit<IOperateItem, "value">;
+    };
+}
+declare const proTableProps: () => {
+    operate: {
+        type: PropType<ITableOperate>;
+    };
+    columnEmptyText: {
+        type: StringConstructor;
+    };
+    /**
+     * 公共column，会merge到columns item中
+     */
+    column: {
+        type: PropType<TTableColumn>;
+    };
+    columns: {
+        type: PropType<TTableColumns>;
+    };
+    /**
+     * 展示控件集合，readonly模式下使用这些组件渲染
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * loading
+     */
+    loading: {
+        type: BooleanConstructor;
+    };
+    /**
+     * provide传递
+     */
+    provideExtra: {
+        type: PropType<IProTableProvideExtra>;
+    };
+};
+declare type ProTableProps = Partial<ExtractPropTypes<ReturnType<typeof proTableProps>>>;
+declare const ProTable: vue.DefineComponent<Partial<ExtractPropTypes<{
+    operate: {
+        type: PropType<ITableOperate>;
+    };
+    columnEmptyText: {
+        type: StringConstructor;
+    };
+    /**
+     * 公共column，会merge到columns item中
+     */
+    column: {
+        type: PropType<TTableColumn>;
+    };
+    columns: {
+        type: PropType<TTableColumns>;
+    };
+    /**
+     * 展示控件集合，readonly模式下使用这些组件渲染
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * loading
+     */
+    loading: {
+        type: BooleanConstructor;
+    };
+    /**
+     * provide传递
+     */
+    provideExtra: {
+        type: PropType<IProTableProvideExtra>;
+    };
+}>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
+    operate: {
+        type: PropType<ITableOperate>;
+    };
+    columnEmptyText: {
+        type: StringConstructor;
+    };
+    /**
+     * 公共column，会merge到columns item中
+     */
+    column: {
+        type: PropType<TTableColumn>;
+    };
+    columns: {
+        type: PropType<TTableColumns>;
+    };
+    /**
+     * 展示控件集合，readonly模式下使用这些组件渲染
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * loading
+     */
+    loading: {
+        type: BooleanConstructor;
+    };
+    /**
+     * provide传递
+     */
+    provideExtra: {
+        type: PropType<IProTableProvideExtra>;
+    };
+}>>>, {}>;
+
+interface IListData extends Record<string, any> {
+    total: number;
+    dataSource: Record<string, any>[];
+}
+interface ICurdState extends Record<string, any> {
+    listLoading?: boolean;
+    listData?: IListData;
+    mode?: ICurdCurrentMode;
+    detailLoading?: boolean;
+    detailData?: Record<string, any>;
+    operateLoading?: boolean;
+    addAction?: ICurdAddAction;
+}
+/**
+ * action：list,detail,add,edit,delete
+ */
+interface ICurdOperateOpts extends Omit<IRequestOpts, "actor" | "action">, Omit<IOperateItem, "value"> {
+    action: ICurdAction;
+    actor?: IRequestOpts;
+}
+declare type TCurdActionEvent = {
+    action: ICurdAction;
+    type: ICurdSubAction;
+    record?: Record<string, any>;
+    values?: Record<string, any>;
+};
+declare const proCurdProps: () => {
+    /**
+     * 列表 或 详情 的唯一标识
+     */
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * operates
+     */
+    operates: {
+        type: PropType<ICurdOperateOpts[]>;
+    };
+    /************************* 子组件props *******************************/
+    listProps: {
+        type: PropType<Record<string, any>>;
+    };
+    formProps: {
+        type: PropType<Record<string, any>>;
+    };
+    descProps: {
+        type: PropType<Record<string, any>>;
+    };
+    modalProps: {
+        type: PropType<Record<string, any>>;
+    };
+};
+declare type CurdProps = Partial<ExtractPropTypes<ReturnType<typeof proCurdProps>>>;
+declare type ProCurdProps = CurdProps & Omit<ProModuleProps, "state" | "requests"> & {
+    curdState: UnwrapNestedRefs<ICurdState>;
+};
+declare const ProCurd: vue.DefineComponent<ProCurdProps, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ProCurdProps>, {}>;
+
+interface IProCurdProvide {
+    rowKey: string;
+    curdState: UnwrapNestedRefs<ICurdState>;
+    formColumns: Ref<TColumns>;
+    descColumns: Ref<TColumns>;
+    tableColumns: Ref<TColumns>;
+    searchColumns: Ref<TColumns>;
+    sendCurdEvent: (event: TCurdActionEvent) => void;
+    getOperate: (action: ICurdAction) => ICurdOperateOpts | undefined;
+    refreshList: (extra?: Record<string, any>) => void;
+    /******************子组件参数*******************/
+    listProps?: ComputedRef<Record<string, any> | undefined>;
+    formProps?: ComputedRef<Record<string, any> | undefined>;
+    descProps?: ComputedRef<Record<string, any> | undefined>;
+    modalProps?: ComputedRef<Record<string, any> | undefined>;
+}
+declare const useProCurd: <T extends IProCurdProvide>() => T;
+declare const provideProCurd: (ctx: IProCurdProvide) => void;
+/************************************ 常量 *************************************/
+/**
+ * curd 5种Action
+ */
+declare enum CurdAction {
+    LIST = "LIST",
+    DETAIL = "DETAIL",
+    ADD = "ADD",
+    EDIT = "EDIT",
+    DELETE = "DELETE"
+}
+declare type ICurdAction = keyof typeof CurdAction;
+/**
+ * 5种Action 的子事件
+ */
+declare enum CurdSubAction {
+    EMIT = "EMIT",
+    EXECUTE = "EXECUTE",
+    PAGE = "PAGE",
+    SUCCESS = "SUCCESS",
+    FAIL = "FAIL"
+}
+declare type ICurdSubAction = keyof typeof CurdSubAction;
+/**
+ * curd 操作模式
+ */
+declare enum CurdCurrentMode {
+    ADD = "ADD",
+    EDIT = "EDIT",
+    DETAIL = "DETAIL"
+}
+declare type ICurdCurrentMode = keyof typeof CurdCurrentMode;
+/**
+ * curd add 模式下 标记 "确定" "确定并继续" 触发
+ */
+declare enum CurdAddAction {
+    NORMAL = "NORMAL",
+    CONTINUE = "CONTINUE"
 }
-declare const isPreRequestActor: (actor: IRequestActor) => boolean;
-declare const isCancelRequestActor: (actor: IRequestActor) => boolean;
-declare const isFailedRequestActor: (actor: IRequestActor) => boolean;
-declare const isDoneRequestActor: (actor: IRequestActor) => boolean;
-declare const createRequestActor: <TReq extends ReqType, TRes>(name: string, requestFromReq: ((req: TReq) => AxiosRequestConfig) | undefined, extra?: Pick<IRequestActor<TReq, TRes, any>, "label"> | undefined) => IRequestActor<TReq, TRes, any>;
-declare const cancelActorIfExists: (actor: any) => void;
-declare const isCancelActor: (actor: any) => any;
-declare const createRequestFactory: (client: AxiosInstance) => (actor: IRequestActor) => {
-    (): Observable<AxiosResponse<any>>;
-    clear(): void;
-    config: AxiosRequestConfig;
+declare type ICurdAddAction = keyof typeof CurdAddAction;
+
+interface IProFormProvideExtra extends Record<string, any> {
+}
+interface IProFormProvide extends IProFormProvideExtra {
+    formState: UnwrapNestedRefs<Record<string, any>>;
+    showState: UnwrapNestedRefs<Record<string, any>>;
+    readonlyState: UnwrapNestedRefs<Record<string, any>>;
+    disableState: UnwrapNestedRefs<Record<string, any>>;
+    readonly: Ref<boolean | undefined>;
+    elementMap?: TElementMap;
+    formElementMap?: TElementMap;
+    formItemVNodes: Ref<(VNode | null)[]>;
+}
+declare const useProForm: () => IProFormProvide;
+declare const proFormProps: () => {
+    /**
+     * 同 antd 或 element  form中的model
+     */
+    model: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     *  子组件是否只读样式
+     */
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     *  FormComponent 根据此项来确定组件是否显示
+     *  rules 根据rules中方法生成showState对象
+     */
+    showState: {
+        type: PropType<BooleanObjType>;
+    };
+    showStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     * 是否只读
+     */
+    readonlyState: {
+        type: PropType<BooleanObjType>;
+    };
+    readonlyStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     * 是否disabled
+     */
+    disableState: {
+        type: PropType<BooleanObjType>;
+    };
+    disableStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     *
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 展示控件集合，readonly模式下使用这些组件渲染
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 录入控件集合
+     */
+    formElementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 是否启用rules验证
+     */
+    needRules: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * provide传递
+     */
+    provideExtra: {
+        type: PropType<IProFormProvideExtra>;
+    };
 };
-declare const createRequestObservable: (actor$: Observable<IRequestActor>, client: AxiosInstance) => Observable<IRequestActor<any, any, any>>;
+declare type ProFormProps = Partial<ExtractPropTypes<ReturnType<typeof proFormProps>>>;
+declare const ProForm: vue.DefineComponent<{
+    /**
+     * 同 antd 或 element  form中的model
+     */
+    model: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     *  子组件是否只读样式
+     */
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     *  FormComponent 根据此项来确定组件是否显示
+     *  rules 根据rules中方法生成showState对象
+     */
+    showState: {
+        type: PropType<BooleanObjType>;
+    };
+    showStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     * 是否只读
+     */
+    readonlyState: {
+        type: PropType<BooleanObjType>;
+    };
+    readonlyStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     * 是否disabled
+     */
+    disableState: {
+        type: PropType<BooleanObjType>;
+    };
+    disableStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     *
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 展示控件集合，readonly模式下使用这些组件渲染
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 录入控件集合
+     */
+    formElementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 是否启用rules验证
+     */
+    needRules: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * provide传递
+     */
+    provideExtra: {
+        type: PropType<IProFormProvideExtra>;
+    };
+}, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, Record<string, any>, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<ExtractPropTypes<{
+    /**
+     * 同 antd 或 element  form中的model
+     */
+    model: {
+        type: PropType<Record<string, any>>;
+    };
+    /**
+     *  子组件是否只读样式
+     */
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     *  FormComponent 根据此项来确定组件是否显示
+     *  rules 根据rules中方法生成showState对象
+     */
+    showState: {
+        type: PropType<BooleanObjType>;
+    };
+    showStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     * 是否只读
+     */
+    readonlyState: {
+        type: PropType<BooleanObjType>;
+    };
+    readonlyStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     * 是否disabled
+     */
+    disableState: {
+        type: PropType<BooleanObjType>;
+    };
+    disableStateRules: {
+        type: PropType<BooleanRulesObjType>;
+    };
+    /**
+     *
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 展示控件集合，readonly模式下使用这些组件渲染
+     */
+    elementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 录入控件集合
+     */
+    formElementMap: {
+        type: PropType<TElementMap>;
+    };
+    /**
+     * 是否启用rules验证
+     */
+    needRules: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * provide传递
+     */
+    provideExtra: {
+        type: PropType<IProFormProvideExtra>;
+    };
+}>>, {
+    readonly: boolean;
+    needRules: boolean;
+}>;
 
-declare type DispatchRequestType = (actor: IRequestActor, params?: IRequestActor["req"], extra?: IRequestActor["extra"]) => IRequestActor;
-declare type RequestProvideType = {
-    client: AxiosInstance;
-    requestSubject$: Subject<IRequestActor>;
-    dispatchRequest: DispatchRequestType;
+declare enum SearchMode {
+    AUTO = "AUTO",
+    MANUAL = "MANUAL"
+}
+declare type ISearchMode = keyof typeof SearchMode;
+declare const proSearchFormProps: () => {
+    /**
+     * 需要监听的对象
+     */
+    model: {
+        type: PropType<Record<string, any>>;
+        required: boolean;
+    };
+    /**
+     * 初始化触发 onFinish
+     */
+    initEmit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     *  模式 自动触发或者手动触发 onFinish
+     */
+    searchMode: {
+        type: PropType<"AUTO" | "MANUAL">;
+        default: SearchMode;
+    };
+    /**
+     * 配置 同ProForm中的columns
+     * 可以根据column中valueType计算出默认的debounceKeys
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 需要debounce处理的字段
+     */
+    debounceKeys: {
+        type: PropType<string[]>;
+    };
+    debounceTime: {
+        type: NumberConstructor;
+        default: number;
+    };
 };
-declare const useRequestProvide: () => RequestProvideType;
-declare type TRequestInterceptor = (request: AxiosInterceptorManager<AxiosRequestConfig>, response: AxiosInterceptorManager<AxiosResponse>) => void;
-declare const ContentTypeInterceptor: TRequestInterceptor;
-declare const createRequest: (options: AxiosRequestConfig, interceptors: TRequestInterceptor[]) => (app: App) => void;
+declare type ProSearchFormProps = Partial<ExtractPropTypes<ReturnType<typeof proSearchFormProps>>>;
+/**
+ * 该组件只是个模式，最终返回null，不做任何渲染，应配合着ProForm的包装类一起使用
+ * 针对传入的model（监听对象）做相应的finish（回调）处理
+ */
+declare const ProSearchForm: vue.DefineComponent<Partial<ExtractPropTypes<{
+    /**
+     * 需要监听的对象
+     */
+    model: {
+        type: PropType<Record<string, any>>;
+        required: boolean;
+    };
+    /**
+     * 初始化触发 onFinish
+     */
+    initEmit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     *  模式 自动触发或者手动触发 onFinish
+     */
+    searchMode: {
+        type: PropType<"AUTO" | "MANUAL">;
+        default: SearchMode;
+    };
+    /**
+     * 配置 同ProForm中的columns
+     * 可以根据column中valueType计算出默认的debounceKeys
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 需要debounce处理的字段
+     */
+    debounceKeys: {
+        type: PropType<string[]>;
+    };
+    debounceTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
+    /**
+     * 需要监听的对象
+     */
+    model: {
+        type: PropType<Record<string, any>>;
+        required: boolean;
+    };
+    /**
+     * 初始化触发 onFinish
+     */
+    initEmit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     *  模式 自动触发或者手动触发 onFinish
+     */
+    searchMode: {
+        type: PropType<"AUTO" | "MANUAL">;
+        default: SearchMode;
+    };
+    /**
+     * 配置 同ProForm中的columns
+     * 可以根据column中valueType计算出默认的debounceKeys
+     */
+    columns: {
+        type: PropType<TColumns>;
+    };
+    /**
+     * 需要debounce处理的字段
+     */
+    debounceKeys: {
+        type: PropType<string[]>;
+    };
+    debounceTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>>>, {}>;
 
-declare const isContentTypeMultipartFormData: (headers: any) => any;
-declare const isContentTypeFormURLEncoded: (headers: any) => any;
-declare const isContentTypeJSON: (headers: any) => any;
-declare const paramsSerializer: (params: any) => string;
-declare const transformRequest: (data: any, headers: any) => any;
-declare const transformResponse: (data: unknown, headers: {
-    [k: string]: any;
-}) => any;
-declare const getRequestConfig: (actor: IRequestActor) => axios.AxiosRequestConfig;
-declare const toUrl: (actor: IRequestActor, baseUrl?: string) => string;
-declare const generateId: () => string;
+interface FormItemProps {
+    name?: string | number | (string | number)[];
+}
+declare const proFormItemProps: () => {
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fieldProps: {
+        type: ObjectConstructor;
+    };
+    showProps: {
+        type: ObjectConstructor;
+    };
+    slots: {
+        type: ObjectConstructor;
+    };
+};
+declare type ProFormItemProps = Partial<ExtractPropTypes<ReturnType<typeof proFormItemProps>>> & Record<string, any>;
+declare const createFormItemCompFn: <T extends FormItemProps>(FormItem: any, convertInputCompProps: (value: any, setValue: (v: any) => void, disabled: boolean | undefined) => Record<string, any>) => ({ InputComp, valueType, name }: {
+    InputComp: any;
+    valueType: TValueType;
+    name?: string | undefined;
+}) => vue.DefineComponent<T & Partial<ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fieldProps: {
+        type: ObjectConstructor;
+    };
+    showProps: {
+        type: ObjectConstructor;
+    };
+    slots: {
+        type: ObjectConstructor;
+    };
+}>> & Record<string, any>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<T & Partial<ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fieldProps: {
+        type: ObjectConstructor;
+    };
+    showProps: {
+        type: ObjectConstructor;
+    };
+    slots: {
+        type: ObjectConstructor;
+    };
+}>> & Record<string, any> extends vue.ComponentPropsOptions<{
+    [x: string]: unknown;
+}> ? ExtractPropTypes<T & Partial<ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fieldProps: {
+        type: ObjectConstructor;
+    };
+    showProps: {
+        type: ObjectConstructor;
+    };
+    slots: {
+        type: ObjectConstructor;
+    };
+}>> & Record<string, any>> : T & Partial<ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fieldProps: {
+        type: ObjectConstructor;
+    };
+    showProps: {
+        type: ObjectConstructor;
+    };
+    slots: {
+        type: ObjectConstructor;
+    };
+}>> & Record<string, any>>, vue.ExtractDefaultPropTypes<T & Partial<ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    fieldProps: {
+        type: ObjectConstructor;
+    };
+    showProps: {
+        type: ObjectConstructor;
+    };
+    slots: {
+        type: ObjectConstructor;
+    };
+}>> & Record<string, any>>>;
 
-interface IUseRequestOptions<TReq, TRes, TErr> {
-    defaultLoading?: boolean;
-    onSuccess?: (actor: IRequestActor<TReq, TRes, TErr>) => void;
-    onFail?: (actor: IRequestActor<TReq, TRes, TErr>) => void;
-    onFinish?: () => void;
+interface IProFormListProvide {
+    pathList: (string | number)[];
 }
-declare const useRequest: <TReq, TRes, TErr>(requestActor: IRequestActor<TReq, TRes, TErr>, options?: IUseRequestOptions<TReq, TRes, TErr> | undefined) => readonly [(params: TReq | undefined, options?: Pick<IUseRequestOptions<TReq, TRes, TErr>, "onSuccess" | "onFail"> | undefined) => void, BehaviorSubject<boolean>];
+declare const useProFormList: () => IProFormListProvide;
+declare const proFormListProps: () => {
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: PropType<string | number | (string | number)[]>;
+        required: boolean;
+    };
+};
+declare type ProFormListProps = Partial<ExtractPropTypes<ReturnType<typeof proFormListProps>>>;
+declare const ProFormList: vue.DefineComponent<Partial<ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: PropType<string | number | (string | number)[]>;
+        required: boolean;
+    };
+}>>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, vue.EmitsOptions, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<Partial<ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: PropType<string | number | (string | number)[]>;
+        required: boolean;
+    };
+}>>>, {}>;
+
+/**
+ * 剔除showState或showStateRules规则为!true的值
+ * @param values
+ * @param showState
+ * @param showStateRules
+ */
+declare const getValidValues: (values: Record<string, any>, showState?: BooleanObjType | undefined, showStateRules?: BooleanRulesObjType | undefined) => Record<string, any>;
 /**
- * 直接发起请求
+ * string类型的path转为arr
+ * @param path
  */
-declare const useDirectRequest: <TRequestActor extends IRequestActor<any, any, any>>(requestActor: TRequestActor, params: TRequestActor["req"] | (() => TRequestActor["req"]), deps: any | any[]) => (BehaviorSubject<boolean> | vue.UnwrapNestedRefs<TRequestActor["res"]> | ((nextParams?: TRequestActor["req"] | undefined) => void))[];
+declare const convertPathToList: (path: undefined | string | number | (string | number)[]) => undefined | (string | number)[];
 
-export { ContentTypeInterceptor, DispatchRequestType, IRequestActor, IUseRequestOptions, ReqType, RequestProvideType, TRequestInterceptor, cancelActorIfExists, createRequest, createRequestActor, createRequestFactory, createRequestObservable, generateId, getRequestConfig, isCancelActor, isCancelRequestActor, isContentTypeFormURLEncoded, isContentTypeJSON, isContentTypeMultipartFormData, isDoneRequestActor, isFailedRequestActor, isPreRequestActor, paramsSerializer, toUrl, transformRequest, transformResponse, useDirectRequest, useRequest, useRequestProvide };
+export { BooleanObjType, BooleanRulesObjType, CurdAction, CurdAddAction, CurdCurrentMode, CurdSubAction, FormItemProps, ICurdAction, ICurdAddAction, ICurdCurrentMode, ICurdOperateOpts, ICurdState, ICurdSubAction, IListData, IOperateItem, IProCurdProvide, IProFormProvideExtra, IProModuleProvide, IProTableProvide, IProTableProvideExtra, IRequestOpts, ISearchMode, ITableOperate, ProCurd, ProCurdProps, ProForm, ProFormItemProps, ProFormList, ProFormListProps, ProFormProps, ProModule, ProModuleProps, ProSearchForm, ProSearchFormProps, ProTable, ProTableProps, RequestAction, SearchMode, TActionEvent, TActionState, TColumn, TColumns, TCurdActionEvent, TDefaultValueType, TElementMap, TOption, TOptions, TTableColumn, TTableColumns, TValueType, convertPathToList, createFormItemCompFn, getColumnFormItemName, getColumnValueType, getFormItemEl, getItemEl, getValidValues, provideProCurd, provideProModule, useComposeRequestActor, useDoneRequestActor, useFailedRequestActor, useModuleEvent, useProCurd, useProForm, useProFormList, useProModule, useProTable };