@qsxy/element-plus-react 1.0.0-next.1

package/dist/Form/List.js

@@ -0,0 +1,142 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/List.tsx
+var List_exports = {};
+__export(List_exports, {
+  default: () => List_default
+});
+module.exports = __toCommonJS(List_exports);
+var import_react = __toESM(require("react"));
+var import_Util = require("../Util");
+var import_FieldContext = __toESM(require("./FieldContext"));
+var import_FormItem = __toESM(require("./FormItem"));
+var import_ListContext = __toESM(require("./ListContext"));
+var import_valueUtil = require("./utils/valueUtil");
+var List = ({ name, initialValue, children, rules, validateTrigger }) => {
+  const context = (0, import_react.useContext)(import_FieldContext.default);
+  const keyRef = (0, import_react.useRef)({
+    keys: [],
+    id: 0
+  });
+  const keyManager = keyRef.current;
+  const prefixName = (0, import_react.useMemo)(() => {
+    const parentPrefixName = (0, import_valueUtil.getNamePath)(context.prefixName) || [];
+    return [...parentPrefixName, ...(0, import_valueUtil.getNamePath)(name)];
+  }, [context.prefixName, name]);
+  const fieldContext = (0, import_react.useMemo)(() => ({ ...context, prefixName }), [context, prefixName]);
+  const listContext = (0, import_react.useMemo)(
+    () => ({
+      getKey: (namePath) => {
+        const len = prefixName.length;
+        const pathName = namePath[len];
+        return [keyManager.keys[pathName], namePath.slice(len + 1)];
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [prefixName]
+  );
+  if (typeof children !== "function") {
+    (0, import_Util.warning)(false, "Form.List only accepts function as children.");
+    return null;
+  }
+  const shouldUpdate = (prevValue, nextValue, { source }) => {
+    if (source === "internal") {
+      return false;
+    }
+    return prevValue !== nextValue;
+  };
+  return /* @__PURE__ */ import_react.default.createElement(import_ListContext.default.Provider, { value: listContext }, /* @__PURE__ */ import_react.default.createElement(import_FieldContext.default.Provider, { value: fieldContext }, /* @__PURE__ */ import_react.default.createElement(import_FormItem.default, { name: [], shouldUpdate, rules, validateTrigger, initialValue, isList: true }, ({ value = [], onChange }, meta) => {
+    const { getFieldValue } = context;
+    const getNewValue = () => {
+      const values = getFieldValue(prefixName || []);
+      return values || [];
+    };
+    const operations = {
+      add: (defaultValue, index) => {
+        const newValue = getNewValue();
+        if (index >= 0 && index <= newValue.length) {
+          keyManager.keys = [...keyManager.keys.slice(0, index), keyManager.id, ...keyManager.keys.slice(index)];
+          onChange([...newValue.slice(0, index), defaultValue, ...newValue.slice(index)]);
+        } else {
+          if (process.env.NODE_ENV !== "production" && (index < 0 || index > newValue.length)) {
+            (0, import_Util.warning)(false, "The second parameter of the add function should be a valid positive number.");
+          }
+          keyManager.keys = [...keyManager.keys, keyManager.id];
+          onChange([...newValue, defaultValue]);
+        }
+        keyManager.id += 1;
+      },
+      remove: (index) => {
+        const newValue = getNewValue();
+        const indexSet = new Set(Array.isArray(index) ? index : [index]);
+        if (indexSet.size <= 0) {
+          return;
+        }
+        keyManager.keys = keyManager.keys.filter((_, keysIndex) => !indexSet.has(keysIndex));
+        onChange(newValue.filter((_, valueIndex) => !indexSet.has(valueIndex)));
+      },
+      move(from, to) {
+        if (from === to) {
+          return;
+        }
+        const newValue = getNewValue();
+        if (from < 0 || from >= newValue.length || to < 0 || to >= newValue.length) {
+          return;
+        }
+        keyManager.keys = (0, import_valueUtil.move)(keyManager.keys, from, to);
+        onChange((0, import_valueUtil.move)(newValue, from, to));
+      }
+    };
+    let listValue = value || [];
+    if (!Array.isArray(listValue)) {
+      listValue = [];
+      if (process.env.NODE_ENV !== "production") {
+        (0, import_Util.warning)(false, `Current value of '${prefixName.join(" > ")}' is not an array type.`);
+      }
+    }
+    return children(
+      listValue.map((__, index) => {
+        let key = keyManager.keys[index];
+        if (key === void 0) {
+          keyManager.keys[index] = keyManager.id;
+          key = keyManager.keys[index];
+          keyManager.id += 1;
+        }
+        return {
+          name: index,
+          key,
+          isListField: true
+        };
+      }),
+      operations,
+      meta
+    );
+  })));
+};
+var List_default = List;

package/dist/Form/ListContext.d.ts

@@ -0,0 +1,7 @@
+import { Key } from 'react';
+import type { InternalNamePath } from './typings';
+export interface ListContextProps {
+    getKey: (namePath: InternalNamePath) => [Key, InternalNamePath];
+}
+declare const ListContext: import("react").Context<ListContextProps>;
+export default ListContext;

package/dist/Form/ListContext.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/ListContext.ts
+var ListContext_exports = {};
+__export(ListContext_exports, {
+  default: () => ListContext_default
+});
+module.exports = __toCommonJS(ListContext_exports);
+var import_react = require("react");
+var ListContext = (0, import_react.createContext)(null);
+var ListContext_default = ListContext;

package/dist/Form/index.d.ts

@@ -0,0 +1,5 @@
+export { default as Form } from './Form';
+export { FormItemContext } from './FormItemContext';
+export type { FormInstance, FormProps, FormRules, InternalFormInstance, InternalNamePath, NamePath, Rule, RuleType, ValidateErrorEntity, ValidateMessages, ValidateOptions, } from './typings';
+export { default as useForm } from './useForm';
+export type { InternalFieldProps as FormItemProps } from './FormItem';

package/dist/Form/index.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/index.ts
+var Form_exports = {};
+__export(Form_exports, {
+  Form: () => import_Form.default,
+  FormItemContext: () => import_FormItemContext.FormItemContext,
+  useForm: () => import_useForm.default
+});
+module.exports = __toCommonJS(Form_exports);
+var import_Form = __toESM(require("./Form"));
+var import_FormItemContext = require("./FormItemContext");
+var import_useForm = __toESM(require("./useForm"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Form,
+  FormItemContext,
+  useForm
+});

package/dist/Form/typings.d.ts

@@ -0,0 +1,302 @@
+import React, { ComponentClass, FC } from 'react';
+import type { Options as ScrollOptions } from 'scroll-into-view-if-needed';
+import { BaseProps, ComponentChildren, NativeProps, TypeAttributes } from '../types/common';
+type BaseFormProps = Omit<React.AllHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'form' | 'size' | 'children'>;
+type RenderProps = (values: Store, form: FormInstance) => React.ReactElement;
+export type FormRules = Record<string, Rule[]>;
+export interface FormProps<Values = any> extends BaseFormProps {
+    form?: FormInstance<Values>;
+    children?: RenderProps | ComponentChildren;
+    component?: false | string | FC<any> | ComponentClass<any, any>;
+    fields?: FieldData[];
+    rules?: FormRules;
+    name?: string;
+    validateMessages?: ValidateMessages;
+    onValuesChange?: Callbacks<Values>['onValuesChange'];
+    onFieldsChange?: Callbacks<Values>['onFieldsChange'];
+    onFinish?: Callbacks<Values>['onFinish'];
+    onFinishFailed?: Callbacks<Values>['onFinishFailed'];
+    validateTrigger?: string | string[] | false;
+    preserve?: boolean;
+    colon?: boolean;
+    initialValues?: Store;
+    labelPosition?: 'left' | 'right' | 'top';
+    labelWidth?: string | number;
+    inline?: boolean;
+    flat?: boolean;
+    disabled?: boolean;
+    size?: TypeAttributes.Size;
+    onChange?: (model: any) => void;
+    formStyle?: React.CSSProperties;
+    className?: string;
+}
+export interface FormItemProps<T> extends BaseProps, NativeProps {
+    colon?: boolean;
+    label?: boolean | string | React.ReactElement;
+    size?: TypeAttributes.Size;
+    labelWidth?: string | number;
+    required?: boolean;
+    noStyle?: boolean;
+    validateStatus?: 'success' | 'warning' | 'error' | 'validating';
+    help?: string | React.ReactElement;
+    pure?: boolean;
+    center?: boolean;
+    labelStyle?: React.CSSProperties;
+    errorStyle?: React.CSSProperties;
+    warningStyle?: React.CSSProperties;
+}
+export interface FieldEntity {
+    onStoreChange: (store: Store, namePathList: InternalNamePath[] | null, info: ValuedNotifyInfo) => void;
+    isFieldTouched: () => boolean;
+    isFieldDirty: () => boolean;
+    isFieldValidating: () => boolean;
+    isListField: () => boolean;
+    isList: () => boolean;
+    isPreserve: () => boolean;
+    validateRules: (options?: ValidateOptions) => Promise<RuleError[]>;
+    getMeta: () => Meta;
+    getNamePath: () => InternalNamePath;
+    getErrors: () => string[];
+    getWarnings: () => string[];
+    props: {
+        label?: string | boolean | React.ReactElement<any>;
+        name?: NamePath;
+        rules?: Rule[];
+        dependencies?: NamePath[];
+        initialValue?: any;
+    };
+}
+interface UpdateAction {
+    type: 'updateValue';
+    namePath: InternalNamePath;
+    value: StoreValue;
+}
+interface ValidateAction {
+    type: 'validateField';
+    namePath: InternalNamePath;
+    triggerName: string;
+}
+export type ReducerAction = UpdateAction | ValidateAction;
+export type InternalNamePath = (string | number)[];
+export type NamePath = string | number | InternalNamePath;
+export type StoreValue = any;
+export type Store = Record<string, StoreValue>;
+export interface Meta {
+    touched: boolean;
+    validating: boolean;
+    errors: string[];
+    warnings: string[];
+    name: InternalNamePath;
+}
+export interface InternalFieldData extends Meta {
+    value: StoreValue;
+}
+export interface FieldData extends Partial<Omit<InternalFieldData, 'name'>> {
+    name: NamePath;
+}
+export type RuleType = 'string' | 'number' | 'boolean' | 'method' | 'regexp' | 'integer' | 'float' | 'object' | 'enum' | 'date' | 'url' | 'hex' | 'email';
+type Validator = (rule: RuleObject, value: StoreValue, callback: (error?: string) => void) => Promise<void | any> | void;
+export type RuleRender = (form: FormInstance) => RuleObject;
+export interface ValidatorRule {
+    warningOnly?: boolean;
+    message?: string | React.ReactElement;
+    validator: Validator;
+}
+interface BaseRule {
+    label?: boolean | string;
+    warningOnly?: boolean;
+    enum?: StoreValue[];
+    len?: number;
+    max?: number;
+    message?: string | React.ReactElement;
+    min?: number;
+    pattern?: RegExp;
+    required?: boolean;
+    transform?: (value: StoreValue) => StoreValue;
+    type?: RuleType;
+    whitespace?: boolean;
+    validateTrigger?: string | string[];
+    phone?: boolean;
+}
+type AggregationRule = BaseRule & Partial<ValidatorRule>;
+interface ArrayRule extends Omit<AggregationRule, 'type'> {
+    type: 'array';
+    defaultField?: RuleObject;
+}
+export type RuleObject = AggregationRule | ArrayRule;
+export type Rule = RuleObject | RuleRender;
+export interface ValidateErrorEntity<Values = any> {
+    values: Values;
+    errorFields: {
+        name: InternalNamePath;
+        errors: string[];
+    }[];
+    outOfDate: boolean;
+}
+export interface FormItem {
+    onStoreChange: (store: Store, namePathList: InternalNamePath[] | null, info: ValuedNotifyInfo) => void;
+    isFieldTouched: () => boolean;
+    isFieldDirty: () => boolean;
+    isFieldValidating: () => boolean;
+    isListField: () => boolean;
+    isList: () => boolean;
+    isPreserve: () => boolean;
+    validateRules: (options?: ValidateOptions) => Promise<RuleError[]>;
+    getMeta: () => Meta;
+    getNamePath: () => InternalNamePath;
+    getErrors: () => string[];
+    getWarnings: () => string[];
+    props: {
+        name?: NamePath;
+        rules?: Rule[];
+        dependencies?: NamePath[];
+        initialValue?: any;
+    };
+}
+export interface FieldError {
+    name: InternalNamePath;
+    errors: string[];
+    warnings: string[];
+}
+export interface RuleError {
+    errors: string[];
+    rule: RuleObject;
+}
+export interface ValidateOptions {
+    label?: string | boolean | React.ReactElement<{}>;
+    triggerName?: string;
+    validateMessages?: ValidateMessages;
+    recursive?: boolean;
+}
+export type InternalValidateFields<Values = any> = (nameList?: NamePath[], options?: ValidateOptions) => Promise<Values>;
+export type ValidateFields<Values = any> = (nameList?: NamePath[]) => Promise<Values>;
+interface ValueUpdateInfo {
+    type: 'valueUpdate';
+    source: 'internal' | 'external';
+}
+interface ValidateFinishInfo {
+    type: 'validateFinish';
+}
+interface ResetInfo {
+    type: 'reset';
+}
+interface RemoveInfo {
+    type: 'remove';
+}
+interface SetFieldInfo {
+    type: 'setField';
+    data: FieldData;
+}
+interface DependenciesUpdateInfo {
+    type: 'dependenciesUpdate';
+    relatedFields: InternalNamePath[];
+}
+export type NotifyInfo = ValueUpdateInfo | ValidateFinishInfo | ResetInfo | RemoveInfo | SetFieldInfo | DependenciesUpdateInfo;
+export type ValuedNotifyInfo = NotifyInfo & {
+    store: Store;
+};
+export interface Callbacks<Values = any> {
+    onValuesChange?: (changedValues: any, values: Values) => void;
+    onFieldsChange?: (changedFields: FieldData[], allFields: FieldData[]) => void;
+    onFinish?: (values: Values) => void;
+    onFinishFailed?: (errorInfo: ValidateErrorEntity<Values>) => void;
+}
+export type WatchCallBack = (values: Store, namePathList: InternalNamePath[]) => void;
+export interface InternalHooks {
+    dispatch: (action: ReducerAction) => void;
+    initEntityValue: (entity: FormItem) => void;
+    registerField: (entity: FormItem) => () => void;
+    useSubscribe: (subscribable: boolean) => void;
+    setInitialValues: (values: Store, init: boolean) => void;
+    destroyForm: () => void;
+    setCallbacks: (callbacks: Callbacks) => void;
+    registerWatch: (callback: WatchCallBack) => () => void;
+    getFields: (namePathList?: InternalNamePath[]) => FieldData[];
+    setValidateMessages: (validateMessages: ValidateMessages) => void;
+    setPreserve: (preserve?: boolean) => void;
+    getInitialValue: (namePath: InternalNamePath) => StoreValue;
+}
+type RecursivePartial<T> = T extends object ? {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+} : any;
+export interface FormInstance<Values = any> {
+    getFieldValue: (name: NamePath) => StoreValue;
+    getFieldsValue: (() => Values) & ((nameList: NamePath[] | true, filterFunc?: (meta: Meta) => boolean) => any);
+    getFieldError: (name: NamePath) => string[];
+    getFieldsError: (nameList?: NamePath[]) => FieldError[];
+    getFieldWarning: (name: NamePath) => string[];
+    isFieldsTouched: ((nameList?: NamePath[], allFieldsTouched?: boolean) => boolean) & ((allFieldsTouched?: boolean) => boolean);
+    isFieldTouched: (name: NamePath) => boolean;
+    isFieldValidating: (name: NamePath) => boolean;
+    isFieldsValidating: (nameList: NamePath[]) => boolean;
+    resetFields: (fields?: NamePath[]) => void;
+    setFields: (fields: FieldData[]) => void;
+    setFieldValue: (name: NamePath, value: any) => void;
+    setFieldsValue: (values: RecursivePartial<Values>) => void;
+    validateFields: ValidateFields<Values>;
+    scrollToField: (name: NamePath, options?: ScrollOptions) => void;
+    submit: () => void;
+}
+export type InternalFormInstance = Omit<FormInstance, 'validateFields'> & {
+    validateFields: InternalValidateFields;
+    prefixName?: InternalNamePath;
+    validateTrigger?: string | string[] | false;
+    getInternalHooks: (secret: string) => InternalHooks | null;
+    _init?: boolean;
+    colon?: boolean;
+    disabled?: boolean;
+    labelPosition?: 'left' | 'right' | 'top';
+    labelWidth?: string | number;
+    size?: TypeAttributes.Size;
+    rules?: FormRules;
+};
+export type EventArgs = any[];
+type ValidateMessage = string | (() => string);
+export interface ValidateMessages {
+    default?: ValidateMessage;
+    required?: ValidateMessage;
+    enum?: ValidateMessage;
+    whitespace?: ValidateMessage;
+    date?: {
+        format?: ValidateMessage;
+        parse?: ValidateMessage;
+        invalid?: ValidateMessage;
+    };
+    types?: {
+        string?: ValidateMessage;
+        method?: ValidateMessage;
+        array?: ValidateMessage;
+        object?: ValidateMessage;
+        number?: ValidateMessage;
+        date?: ValidateMessage;
+        boolean?: ValidateMessage;
+        integer?: ValidateMessage;
+        float?: ValidateMessage;
+        regexp?: ValidateMessage;
+        email?: ValidateMessage;
+        url?: ValidateMessage;
+        hex?: ValidateMessage;
+    };
+    string?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    number?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    array?: {
+        len?: ValidateMessage;
+        min?: ValidateMessage;
+        max?: ValidateMessage;
+        range?: ValidateMessage;
+    };
+    pattern?: {
+        mismatch?: ValidateMessage;
+    };
+}
+export {};

package/dist/Form/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Form/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Form/useForm.d.ts

@@ -0,0 +1,73 @@
+import type { FormInstance, InternalFormInstance, InternalNamePath, StoreValue } from './typings';
+interface UpdateAction {
+    type: 'updateValue';
+    namePath: InternalNamePath;
+    value: StoreValue;
+}
+interface ValidateAction {
+    type: 'validateField';
+    namePath: InternalNamePath;
+    triggerName: string;
+}
+export type ReducerAction = UpdateAction | ValidateAction;
+export declare class FormStore {
+    private formHooked;
+    private forceRootUpdate;
+    private subscribable;
+    private store;
+    private fieldEntities;
+    private initialValues;
+    private callbacks;
+    private validateMessages;
+    private preserve?;
+    private lastValidatePromise;
+    constructor(forceRootUpdate: () => void);
+    getForm: () => InternalFormInstance;
+    private scrollToField;
+    private getInternalHooks;
+    private useSubscribe;
+    private prevWithoutPreserves;
+    private setInitialValues;
+    private destroyForm;
+    private getInitialValue;
+    private setCallbacks;
+    private setValidateMessages;
+    private setPreserve;
+    private watchList;
+    private registerWatch;
+    private notifyWatch;
+    private timeoutId;
+    private warningUnhooked;
+    private updateStore;
+    private getFieldEntities;
+    private getFieldsMap;
+    private getFieldEntitiesForNamePathList;
+    private getFieldsValue;
+    private getFieldValue;
+    private getFieldsError;
+    private getFieldError;
+    private getFieldWarning;
+    private isFieldsTouched;
+    private isFieldTouched;
+    private isFieldsValidating;
+    private isFieldValidating;
+    private resetWithFieldInitialValue;
+    private resetFields;
+    private setFields;
+    private getFields;
+    private initEntityValue;
+    private isMergedPreserve;
+    private registerField;
+    private dispatch;
+    private notifyObservers;
+    private triggerDependenciesUpdate;
+    private updateValue;
+    private setFieldsValue;
+    private setFieldValue;
+    private getDependencyChildrenFields;
+    private triggerOnFieldsChange;
+    private validateFields;
+    private submit;
+}
+declare function useForm<Values = any>(form?: FormInstance<Values>): [FormInstance<Values>];
+export default useForm;