@lite-code/aui-react 0.0.1

package/README.md

@@ -0,0 +1,76 @@
+# 快速上手
+
+## 安装
+
+```bash
+npm install @lite-code/aui-react
+# 或
+pnpm add @lite-code/aui-react
+```
+
+## 基础使用
+
+> 样式已内置于组件中，无需额外引入 CSS 文件。
+
+```tsx
+import { Button, Input } from '@lite-code/aui-react'
+
+export default function App() {
+  return (
+    <div>
+      <Button variant="primary">点击我</Button>
+      <Input placeholder="请输入内容" />
+    </div>
+  )
+}
+```
+
+## 主题切换
+
+使用 `ThemeProvider` 管理全局主题：
+
+```tsx
+import { ThemeProvider } from '@lite-code/aui-react'
+
+export default function App() {
+  return (
+    <ThemeProvider defaultTheme="dark" defaultAccentColor="#6366f1">
+      <YourApp />
+    </ThemeProvider>
+  )
+}
+```
+
+在子组件中使用 `useTheme` Hook：
+
+```tsx
+import { useTheme } from '@lite-code/aui-react'
+
+function MyComponent() {
+  const { theme, setTheme, accentColor, setAccentColor } = useTheme()
+
+  return (
+    <button onClick={() => setTheme(theme === 'dark' ? 'light' : 'dark')}>
+      切换为 {theme === 'dark' ? '亮色' : '暗色'} 主题
+    </button>
+  )
+}
+```
+
+## 高亮色预设
+
+```tsx
+import { ACCENT_PRESETS } from '@lite-code/aui-react'
+
+// ACCENT_PRESETS 包含 Indigo / Violet / Sky / Emerald / Rose / Amber
+```
+
+## 自定义主题色
+
+通过修改 CSS 变量可全局覆盖主题色：
+
+```css
+:root {
+  --aui-accent: #your-color;
+}
+```

package/dist/alert/index.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import "./alert.css";
+export type AlertType = "info" | "success" | "warning" | "danger";
+export interface AlertProps {
+    type?: AlertType;
+    message: React.ReactNode;
+    description?: React.ReactNode;
+    closable?: boolean;
+    showIcon?: boolean;
+    onClose?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Alert({ type, message, description, closable, showIcon, onClose, className, style, }: AlertProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/avatar/index.d.ts

@@ -0,0 +1,28 @@
+import React from "react";
+import "./avatar.css";
+export type AvatarShape = "circle" | "square";
+export type AvatarSize = "sm" | "md" | "lg" | number;
+export interface AvatarProps {
+    src?: string;
+    alt?: string;
+    icon?: React.ReactNode;
+    children?: React.ReactNode;
+    shape?: AvatarShape;
+    size?: AvatarSize;
+    color?: string;
+    background?: string;
+    gap?: number;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface AvatarGroupProps {
+    children: React.ReactNode;
+    max?: number;
+    renderMax?: (count: number) => React.ReactNode;
+    size?: AvatarSize;
+    shape?: AvatarShape;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Avatar({ src, alt, icon, children, shape, size, color, background, gap, className, style, }: AvatarProps): import("react/jsx-runtime").JSX.Element;
+export declare function AvatarGroup({ children, max, renderMax, size, shape, className, style, }: AvatarGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/badge/index.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "./badge.css";
+export type BadgeStatus = "default" | "processing" | "error" | "warning" | "success";
+export type BadgeSize = "default" | "small";
+export interface BadgeProps {
+    count?: number;
+    overflowCount?: number;
+    dot?: boolean;
+    status?: BadgeStatus;
+    text?: React.ReactNode;
+    size?: BadgeSize;
+    showZero?: boolean;
+    offset?: [number, number];
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Badge({ count, overflowCount, dot, status, text, size, showZero, offset, children, className, style, }: BadgeProps): import("react/jsx-runtime").JSX.Element;

package/dist/breadcrumb/index.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import type { DropdownItem } from "../dropdown";
+import "./breadcrumb.css";
+export interface BreadcrumbItem {
+    label: React.ReactNode;
+    href?: string;
+    onClick?: (e: React.MouseEvent) => void;
+    menu?: DropdownItem[];
+}
+export interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    separator?: React.ReactNode;
+    fontSize?: number | string;
+    max?: number;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Breadcrumb({ items, separator, fontSize, max, className, style, }: BreadcrumbProps): import("react/jsx-runtime").JSX.Element;

package/dist/button/index.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import "./button.css";
+export type ButtonVariant = "primary" | "secondary" | "outline" | "ghost";
+export type ButtonSize = "sm" | "md" | "lg";
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    loading?: boolean;
+    children?: React.ReactNode;
+}
+export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/card/index.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import "./card.css";
+export type CardSize = "sm" | "md" | "lg";
+export type CardShadow = "always" | "hover" | "never";
+export interface CardProps {
+    title?: React.ReactNode;
+    extra?: React.ReactNode;
+    cover?: React.ReactNode;
+    footer?: React.ReactNode;
+    children?: React.ReactNode;
+    collapsible?: boolean;
+    defaultCollapsed?: boolean;
+    collapsed?: boolean;
+    onCollapseChange?: (collapsed: boolean) => void;
+    bordered?: boolean;
+    shadow?: CardShadow;
+    loading?: boolean;
+    size?: CardSize;
+    /** 右侧流光彩线动画 */
+    shimmer?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    bodyStyle?: React.CSSProperties;
+}
+export declare function Card({ title, extra, cover, footer, children, collapsible, defaultCollapsed, collapsed: collapsedProp, onCollapseChange, bordered, shadow, loading, size, shimmer, className, style, bodyStyle, }: CardProps): import("react/jsx-runtime").JSX.Element;

package/dist/carousel/index.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import "./carousel.css";
+export interface CarouselProps {
+    children: React.ReactNode;
+    autoplay?: boolean;
+    autoplayInterval?: number;
+    dots?: boolean;
+    arrows?: boolean;
+    loop?: boolean;
+    defaultIndex?: number;
+    index?: number;
+    effect?: "slide" | "fade";
+    onChange?: (index: number) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Carousel({ children, autoplay, autoplayInterval, dots, arrows, loop, defaultIndex, index: controlledIndex, effect, onChange, className, style, }: CarouselProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/cascader/index.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import "./cascader.css";
+export interface CascaderOption {
+    label: string;
+    value: string | number;
+    children?: CascaderOption[];
+    disabled?: boolean;
+}
+export type CascaderValue = (string | number)[];
+export interface CascaderProps {
+    options?: CascaderOption[];
+    /** 单选时为 CascaderValue，多选时为 CascaderValue[] */
+    value?: CascaderValue | CascaderValue[];
+    onChange?: (value: CascaderValue | CascaderValue[], selectedOptions: CascaderOption[] | CascaderOption[][]) => void;
+    multiple?: boolean;
+    maxTagCount?: number;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    clearable?: boolean;
+    separator?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Cascader({ options, value, onChange, multiple, maxTagCount, placeholder, disabled, size, clearable, separator, style, className, }: CascaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/checkbox/index.d.ts

@@ -0,0 +1,33 @@
+import React from "react";
+import "./checkbox.css";
+export type CheckboxSize = "sm" | "md" | "lg";
+export interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "onChange" | "checked" | "defaultChecked" | "value"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean, e: React.ChangeEvent<HTMLInputElement>) => void;
+    indeterminate?: boolean;
+    size?: CheckboxSize;
+    children?: React.ReactNode;
+    value?: string | number;
+}
+export interface CheckboxOption {
+    label: React.ReactNode;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface CheckboxGroupProps {
+    value?: (string | number)[];
+    defaultValue?: (string | number)[];
+    onChange?: (value: (string | number)[]) => void;
+    options?: CheckboxOption[];
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function CheckboxGroup({ value, defaultValue, onChange, options, disabled, children, className, }: CheckboxGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare function Checkbox({ checked, defaultChecked, onChange, indeterminate, size, disabled, children, value, className, ...rest }: CheckboxProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Checkbox {
+    var Group: typeof CheckboxGroup;
+    var displayName: string;
+}
+export {};

package/dist/collapse/index.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import "./collapse.css";
+export interface CollapseItem {
+    key: string;
+    label: React.ReactNode;
+    children: React.ReactNode;
+    disabled?: boolean;
+}
+export interface CollapseProps {
+    items: CollapseItem[];
+    defaultActiveKeys?: string[];
+    activeKeys?: string[];
+    accordion?: boolean;
+    onChange?: (keys: string[]) => void;
+    bordered?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Collapse({ items, defaultActiveKeys, activeKeys: controlledKeys, accordion, onChange, bordered, className, style, }: CollapseProps): import("react/jsx-runtime").JSX.Element;

package/dist/datepicker/index.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import "./datepicker.css";
+export type DatePickerSize = "sm" | "md" | "lg";
+export type PickerType = "date" | "month" | "year";
+export type SingleValue = Date | string | null;
+export type RangeValue = [SingleValue, SingleValue];
+export interface DatePickerProps {
+    value?: SingleValue | RangeValue;
+    defaultValue?: SingleValue | RangeValue;
+    onChange?: (value: Date | null | [Date | null, Date | null], str: string | [string, string]) => void;
+    picker?: PickerType;
+    range?: boolean;
+    disabled?: boolean;
+    clearable?: boolean;
+    size?: DatePickerSize;
+    placeholder?: string;
+    format?: string;
+    min?: SingleValue;
+    max?: SingleValue;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function DatePicker({ value, defaultValue, onChange, picker, range, disabled, clearable, size, placeholder, format, min, max, style, className, }: DatePickerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace DatePicker {
+    var displayName: string;
+}

package/dist/descriptions/index.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import "./descriptions.css";
+export interface DescriptionItem {
+    label: string;
+    value: React.ReactNode;
+    /** 占据的列数，默认 1 */
+    span?: number;
+}
+export interface DescriptionsProps {
+    /** 标题 */
+    title?: React.ReactNode;
+    /** 数据项 */
+    items: DescriptionItem[];
+    /** 每行列数，默认 3 */
+    column?: number;
+    /** 冒号分隔符，默认 ':' */
+    colon?: string;
+    /** 是否显示边框（表格样式） */
+    bordered?: boolean;
+    labelStyle?: React.CSSProperties;
+    contentStyle?: React.CSSProperties;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Descriptions({ title, items, column, colon, bordered, labelStyle, contentStyle, style, className, }: DescriptionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/drawer/index.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import "./drawer.css";
+export type DrawerPlacement = "left" | "right" | "top" | "bottom";
+export interface DrawerProps {
+    open: boolean;
+    onClose?: () => void;
+    title?: React.ReactNode;
+    children?: React.ReactNode;
+    footer?: React.ReactNode | null;
+    placement?: DrawerPlacement;
+    width?: number | string;
+    height?: number | string;
+    closable?: boolean;
+    bodyStyle?: React.CSSProperties;
+}
+export declare function Drawer({ open, onClose, title, children, footer, placement, width, height, closable, bodyStyle, }: DrawerProps): React.ReactPortal | null;

package/dist/dropdown/index.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import "./dropdown.css";
+export type DropdownTrigger = "click" | "hover" | "contextMenu";
+export interface DropdownMenuItem {
+    key: string | number;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    danger?: boolean;
+    onClick?: () => void;
+}
+export interface DropdownDivider {
+    type: "divider";
+    key?: string | number;
+}
+export type DropdownItem = DropdownMenuItem | DropdownDivider;
+export interface DropdownProps {
+    items: DropdownItem[];
+    trigger?: DropdownTrigger;
+    disabled?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onSelect?: (key: string | number) => void;
+    children: React.ReactElement;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Dropdown({ items, trigger, disabled, open: openProp, defaultOpen, onOpenChange, onSelect, children, className, style, }: DropdownProps): import("react/jsx-runtime").JSX.Element;

package/dist/empty/index.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import "./empty.css";
+export interface EmptyProps {
+    image?: React.ReactNode | null;
+    imageStyle?: React.CSSProperties;
+    description?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Empty({ image, imageStyle, description, children, className, style, }: EmptyProps): import("react/jsx-runtime").JSX.Element;

package/dist/form/context.d.ts

@@ -0,0 +1,3 @@
+import type { FormContextValue } from "./types";
+export declare const FormContext: import("react").Context<FormContextValue>;
+export declare function useFormContext(): FormContextValue;

package/dist/form/index.d.ts

@@ -0,0 +1,39 @@
+import React from "react";
+import "./form.css";
+import { FormItem } from "./item";
+import type { FormItemProps } from "./item";
+import { FormList } from "./list";
+import type { FormInstance, FieldError, ColConfig } from "./types";
+export { FormItem };
+export type { FormItemProps, FormItemType, FormItemRenderProps, FormItemRenderFn, } from "./item";
+export { FormList };
+export type { FormListProps } from "./list";
+export declare function useForm<Values = any>(): [FormInstance<Values>];
+export interface FormProps<Values = any> {
+    form?: FormInstance<Values>;
+    onFinish?: (values: Values) => void;
+    onFinishFailed?: (info: {
+        values: Values;
+        errorFields: FieldError[];
+    }) => void;
+    initialValues?: Partial<Values>;
+    layout?: "horizontal" | "vertical" | "inline";
+    labelCol?: ColConfig;
+    wrapperCol?: ColConfig;
+    colon?: boolean;
+    requiredMark?: boolean;
+    validateTrigger?: string | string[];
+    onValuesChange?: (changed: Partial<Values>, all: Values) => void;
+    name?: string;
+    column?: number;
+    items?: FormItemProps[];
+    widget?: Record<string, React.ComponentType<any>>;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Form<Values = any>({ form, onFinish, onFinishFailed, initialValues, layout, labelCol, wrapperCol, colon, requiredMark, validateTrigger, onValuesChange, name, column, items, widget, className, style, }: FormProps<Values>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Form {
+    var Item: typeof FormItem;
+    var List: typeof FormList;
+    var useForm: typeof import(".").useForm;
+}

package/dist/form/item.d.ts

@@ -0,0 +1,87 @@
+import React from "react";
+import type { RuleItem, NamePath, ColConfig } from "./types";
+import type { InputProps } from "../input";
+import type { InputNumberProps } from "../input-number";
+import type { TextareaProps } from "../textarea";
+import type { SelectProps } from "../select";
+import type { SwitchProps } from "../switch";
+import type { CheckboxProps, CheckboxGroupProps } from "../checkbox";
+import type { RadioGroupProps } from "../radio";
+import type { SliderProps } from "../slider";
+import type { RateProps } from "../rate";
+import type { DatePickerProps } from "../datepicker";
+import type { TimePickerProps, TimeRangePickerProps } from "../timepicker";
+import type { UploadProps } from "../upload";
+import type { TreeSelectProps } from "../tree-select";
+import type { CascaderProps } from "../cascader";
+import { FormListProps } from "./list";
+export type FormItemType = "Input" | "InputNumber" | "Textarea" | "Select" | "Switch" | "Checkbox" | "CheckboxGroup" | "RadioGroup" | "Slider" | "Rate" | "DatePicker" | "TimePicker" | "TimeRangePicker" | "Upload" | "TreeSelect" | "Cascader" | "FormList";
+type ComponentPropsMap = {
+    Input: InputProps;
+    InputNumber: InputNumberProps;
+    Textarea: TextareaProps;
+    Select: SelectProps;
+    Switch: SwitchProps;
+    Checkbox: CheckboxProps;
+    CheckboxGroup: CheckboxGroupProps;
+    RadioGroup: RadioGroupProps;
+    Slider: SliderProps;
+    Rate: RateProps;
+    DatePicker: DatePickerProps;
+    TimePicker: TimePickerProps;
+    TimeRangePicker: TimeRangePickerProps;
+    Upload: UploadProps;
+    TreeSelect: TreeSelectProps;
+    Cascader: CascaderProps;
+    FormList: FormListProps;
+};
+export interface FormItemRenderProps {
+    form: import("./types").FormInstance;
+    value?: any;
+    onChange?: (...args: any[]) => void;
+    onBlur?: () => void;
+    status?: "error" | "";
+}
+export type FormItemRenderFn = React.ComponentType<FormItemRenderProps & Record<string, any>>;
+type TypedProps = {
+    [K in FormItemType]: {
+        type: K;
+        props?: Partial<ComponentPropsMap[K]>;
+    };
+}[FormItemType] | {
+    type: FormItemRenderFn;
+    props?: Record<string, any>;
+} | {
+    type: string;
+    props?: Record<string, any>;
+} | {
+    type?: undefined;
+    props?: never;
+};
+interface FormItemBaseProps {
+    name?: NamePath;
+    label?: React.ReactNode;
+    rules?: RuleItem[];
+    required?: boolean;
+    colon?: boolean;
+    labelCol?: ColConfig;
+    wrapperCol?: ColConfig;
+    validateTrigger?: string | string[];
+    valuePropName?: string;
+    getValueFromEvent?: (...args: any[]) => any;
+    help?: React.ReactNode;
+    extra?: React.ReactNode;
+    noStyle?: boolean;
+    hideMessage?: boolean;
+    span?: number;
+    effect?: NamePath[];
+    visible?: (form: import("./types").FormInstance) => boolean;
+    mergeProps?: (form: import("./types").FormInstance) => Record<string, any>;
+    normalize?: (value: any, prevValue: any, prevValues: any) => any;
+    initialValue?: any;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export type FormItemProps = FormItemBaseProps & TypedProps;
+export declare function FormItem({ name, label, rules, required, colon: colonProp, labelCol: labelColProp, wrapperCol: wrapperColProp, validateTrigger: validateTriggerProp, valuePropName: valuePropNameProp, getValueFromEvent, help, extra, noStyle, hideMessage, span, effect, visible, normalize, initialValue, type, props: componentProps, mergeProps, className, style, }: FormItemProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/form/list.d.ts

@@ -0,0 +1,8 @@
+import type { NamePath } from "./types";
+import type { FormItemProps } from "./item";
+export interface FormListProps {
+    name: NamePath;
+    items?: FormItemProps[];
+    addText?: string;
+}
+export declare function FormList({ name, items, addText }: FormListProps): import("react/jsx-runtime").JSX.Element;

package/dist/form/store.d.ts

@@ -0,0 +1,49 @@
+import type { RuleItem, FieldError, FormInstance } from "./types";
+export declare function getFormStore<V>(instance: FormInstance<V>): FormStore<V> | undefined;
+type Listener = () => void;
+export declare class FormStore<Values = Record<string, any>> {
+    private values;
+    private publicInstance;
+    private initialValues;
+    private errors;
+    private meta;
+    private fieldListeners;
+    private listPrefixes;
+    private callbacks;
+    setCallbacks(cbs: typeof this.callbacks): void;
+    setInitialValues(vals: Partial<Values>, init: boolean): void;
+    private notify;
+    registerField(name: string, rules: RuleItem[], initialValue?: any): void;
+    unregisterField(name: string): void;
+    subscribeField(name: string, listener: Listener): () => boolean | undefined;
+    getFieldValue(name: string): any;
+    registerList(prefix: string): void;
+    unregisterList(prefix: string): void;
+    private unflatten;
+    getFieldsValue(names?: string[]): Values;
+    setFieldValue(name: string, value: any): void;
+    setFieldsValue(vals: Partial<Values>): void;
+    resetFields(names?: string[]): void;
+    getFieldError(name: string): string[];
+    getFieldsError(names?: string[]): FieldError[];
+    isFieldTouched(name: string): boolean;
+    validateField(name: string): Promise<string[]>;
+    validateFields(names?: string[]): Promise<Values>;
+    submit(): void;
+    listRemove(prefix: string, index: number): void;
+    listAdd(prefix: string, index: number, initialValue: Record<string, any>): void;
+    getPublicInstance(): FormInstance<Values>;
+    getInternalHooks(): {
+        registerField: (name: string, rules: RuleItem[], initialValue?: any) => void;
+        unregisterField: (name: string) => void;
+        subscribeField: (name: string, listener: Listener) => () => boolean | undefined;
+        setCallbacks: (cbs: typeof this.callbacks) => void;
+        setInitialValues: (vals: Partial<Values>, init: boolean) => void;
+        validateField: (name: string) => Promise<string[]>;
+        listRemove: (prefix: string, index: number) => void;
+        listAdd: (prefix: string, index: number, initialValue: Record<string, any>) => void;
+        registerList: (prefix: string) => void;
+        unregisterList: (prefix: string) => void;
+    };
+}
+export {};

package/dist/form/types.d.ts

@@ -0,0 +1,47 @@
+import type React from "react";
+export type NamePath = string | (string | number)[];
+export interface Rule {
+    required?: boolean;
+    message?: string;
+    min?: number;
+    max?: number;
+    len?: number;
+    pattern?: RegExp;
+    whitespace?: boolean;
+    type?: "string" | "number" | "email" | "url" | "boolean" | "array" | "object";
+    validator?: (rule: Rule, value: any) => Promise<void> | void;
+    enum?: any[];
+}
+export type RuleItem = Rule | ((form: FormInstance) => Rule);
+export interface FieldError {
+    name: NamePath;
+    errors: string[];
+}
+export interface FormInstance<Values = any> {
+    getFieldValue(name: NamePath): any;
+    getFieldsValue(nameList?: NamePath[]): Values;
+    setFieldValue(name: NamePath, value: any): void;
+    setFieldsValue(values: Partial<Values>): void;
+    resetFields(fields?: NamePath[]): void;
+    validateFields(nameList?: NamePath[]): Promise<Values>;
+    getFieldError(name: NamePath): string[];
+    getFieldsError(nameList?: NamePath[]): FieldError[];
+    isFieldTouched(name: NamePath): boolean;
+    submit(): void;
+}
+export interface ColConfig {
+    span?: number;
+}
+export interface FormContextValue {
+    store: any;
+    layout: "horizontal" | "vertical" | "inline";
+    labelCol: ColConfig;
+    wrapperCol: ColConfig;
+    colon: boolean;
+    requiredMark: boolean;
+    validateTrigger: string[];
+    name?: string;
+    column?: number;
+    widget?: Record<string, React.ComponentType<any>>;
+}
+export declare function normalizeName(name: NamePath): string;