@faasjs/ant-design 8.0.0-beta.17 → 8.0.0-beta.18

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { ErrorBoundaryProps, FaasDataInjection as FaasDataInjection$1, FaasDataWrapperProps as FaasDataWrapperProps$1, FaasDataWrapperRef, FaasReactClient, FaasReactClientOptions, faas, useFaas } from "@faasjs/react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
 import { ButtonProps, ConfigProviderProps as ConfigProviderProps$1, DatePickerProps, DescriptionsProps, Drawer, DrawerProps as DrawerProps$1, FormInstance, FormItemProps as FormItemProps$1, FormProps as FormProps$1, GlobalToken, InputNumberProps, InputProps, Modal, ModalProps as ModalProps$1, RadioProps, SelectProps, SwitchProps, TableColumnProps, TablePaginationConfig, TableProps as TableProps$1, TabsProps as TabsProps$1 } from "antd";
 import { BrowserRouterProps, RouteProps } from "react-router-dom";
 import * as react from "react";
 import { CSSProperties, ComponentType, Dispatch, FC, JSX, LazyExoticComponent, ReactElement, ReactNode, SetStateAction, lazy } from "react";
-import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ErrorBoundaryProps, FaasDataInjection as FaasDataInjection$1, FaasDataWrapperProps as FaasDataWrapperProps$1, FaasDataWrapperRef, FaasReactClient, FaasReactClientOptions, faas, useFaas } from "@faasjs/react";
 import { Dayjs } from "dayjs";
 import * as antd_es_form_FormItem0 from "antd/es/form/FormItem";
 import * as antd_es_form0 from "antd/es/form";
@@ -60,6 +60,8 @@ type FaasActionUnionType = Record<string, any> | string;
  * Returns the original type when `T` is a known action path,
  * otherwise falls back to `string`.
  *
+ * @template T - Candidate action path type.
+ *
  * @example
  * ```typescript
  * type A = FaasAction<'demo'> // 'demo'
@@ -69,62 +71,181 @@ type FaasActionUnionType = Record<string, any> | string;
 type FaasAction<T = any> = T extends FaasActionPaths ? T : string;
 //#endregion
 //#region src/Loading.d.ts
+/**
+ * Props for the {@link Loading} component.
+ */
 type LoadingProps = {
-  style?: React.CSSProperties;
+  /** Inline styles applied to the loading wrapper. */style?: React.CSSProperties;
+  /**
+   * Ant Design spinner size.
+   *
+   * @default 'large'
+   */
   size?: 'small' | 'default' | 'large';
-  loading?: boolean;
+  /**
+   * Whether the loading indicator should be shown.
+   *
+   * @default true
+   */
+  loading?: boolean; /** Content rendered when `loading` is `false`. */
   children?: React.ReactNode;
 };
 /**
- * Loading component based on Spin
+ * Render an Ant Design loading spinner with an optional content fallback.
+ *
+ * @param {LoadingProps} props - Loading indicator props and optional wrapped children.
  *
  * @example
  * ```tsx
- * <Loading /> // display loading
+ * import { Loading } from '@faasjs/ant-design'
  *
- * <Loading loading={ !remoteData }>
- *   <div>{remoteData}</div>
- * </Loading>
+ * export function Page({ remoteData }: { remoteData?: string }) {
+ *   return (
+ *     <>
+ *       <Loading />
+ *       <Loading loading={!remoteData}>
+ *         <div>{remoteData}</div>
+ *       </Loading>
+ *     </>
+ *   )
+ * }
  * ```
  */
 declare function Loading(props: LoadingProps): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/FaasDataWrapper.d.ts
+/**
+ * Partial data injection exposed to wrapped Ant Design components.
+ *
+ * @template T - Action path or response data type used for inference.
+ */
 type FaasDataInjection<T extends FaasActionUnionType = any> = Partial<FaasDataInjection$1<T>>;
+/**
+ * Ant Design wrapper props for the underlying `@faasjs/react` data wrapper.
+ *
+ * @template T - Action path or response data type used for inference.
+ */
 interface FaasDataWrapperProps<T extends FaasActionUnionType = any> extends FaasDataWrapperProps$1<T> {
+  /** Props forwarded to the built-in {@link Loading} fallback. */
   loadingProps?: LoadingProps;
+  /** Explicit loading element that overrides the built-in {@link Loading} fallback. */
   loading?: JSX.Element;
 }
 /**
- * FaasDataWrapper component with Loading
+ * Render the `@faasjs/react` data wrapper with an Ant Design loading fallback.
+ *
+ * When `loading` is not provided, the component renders {@link Loading} with `loadingProps` while
+ * the wrapped FaasJS request is pending.
+ *
+ * @template T - Action path or response data type used for inference.
+ * @param {FaasDataWrapperProps<T>} props - Wrapper props including loading fallbacks and request configuration.
  *
  * @example
  * ```tsx
- * function MyComponent (props: FaasDataInjection) {
- *   return <div>{ props.data }</div>
+ * import { Alert, Button } from 'antd'
+ * import { FaasDataWrapper } from '@faasjs/ant-design'
+ *
+ * type User = {
+ *   name: string
  * }
  *
- * function MyPage () {
- *   return <FaasDataWrapper action="test" params={{ a: 1 }}>
- *     <MyComponent />
- *   </FaasDataWrapper>
+ * function UserView(props: {
+ *   data?: User
+ *   error?: Error
+ *   reload?: () => void
+ * }) {
+ *   if (props.error) {
+ *     return (
+ *       <Alert
+ *         type="error"
+ *         message={props.error.message}
+ *         action={
+ *           <Button size="small" onClick={() => props.reload?.()}>
+ *             Retry
+ *           </Button>
+ *         }
+ *       />
+ *     )
+ *   }
+ *
+ *   return <div>Hello, {props.data?.name}</div>
+ * }
+ *
+ * // Render-prop mode
+ * export function UserProfile(props: { id: number }) {
+ *   return (
+ *     <FaasDataWrapper<User>
+ *       action="user/get"
+ *       params={{ id: props.id }}
+ *       loading={<div>Loading user...</div>}
+ *       render={({ data, error, reload }) => {
+ *         if (error) {
+ *           return (
+ *             <Alert
+ *               type="error"
+ *               message={error.message}
+ *               action={
+ *                 <Button size="small" onClick={() => reload()}>
+ *                   Retry
+ *                 </Button>
+ *               }
+ *             />
+ *           )
+ *         }
+ *
+ *         return <div>Hello, {data.name}</div>
+ *       }}
+ *     />
+ *   )
+ * }
+ *
+ * // Children injection mode
+ * export function UserProfileWithChildren(props: { id: number }) {
+ *   return (
+ *     <FaasDataWrapper<User>
+ *       action="user/get"
+ *       params={{ id: props.id }}
+ *       loading={<div>Loading user...</div>}
+ *     >
+ *       <UserView />
+ *     </FaasDataWrapper>
+ *   )
  * }
  * ```
  */
 declare function FaasDataWrapper<T extends FaasActionUnionType = any>(props: FaasDataWrapperProps<T>): JSX.Element;
 /**
- * HOC to wrap a component with FaasDataWrapper and Loading
+ * Wrap a component with {@link FaasDataWrapper} and its Ant Design loading fallback.
+ *
+ * @template PathOrData - Action path or response data type used for inference.
+ * @template TComponentProps - Component props including injected Faas data fields.
+ * @param {React.FC<TComponentProps & Record<string, any>>} Component - Component that consumes injected Faas data props.
+ * @param {FaasDataWrapperProps<PathOrData>} faasProps - Request configuration forwarded to {@link FaasDataWrapper}.
+ * @returns Higher-order component that injects Faas data props.
  *
  * @example
  * ```tsx
- * const MyComponent = withFaasData(({ data }) => <div>{data.name}</div>, { action: 'test', params: { a: 1 } })
+ * import { withFaasData } from '@faasjs/ant-design'
+ *
+ * const UserCard = withFaasData(
+ *   ({ data, error, reload }) =>
+ *     error ? (
+ *       <a onClick={() => reload()}>Retry</a>
+ *     ) : (
+ *       <div>{data.name}</div>
+ *     ),
+ *   { action: 'user/get', params: { id: 1 } },
+ * )
  * ```
  */
 declare function withFaasData<PathOrData extends FaasActionUnionType, TComponentProps extends Required<FaasDataInjection<PathOrData>> = Required<FaasDataInjection<PathOrData>>>(Component: React.FC<TComponentProps & Record<string, any>>, faasProps: FaasDataWrapperProps<PathOrData>): React.FC<Omit<TComponentProps, keyof FaasDataInjection<PathOrData>>>;
 //#endregion
 //#region src/Config.d.ts
+/**
+ * Fully resolved theme object consumed by `@faasjs/ant-design` components.
+ */
 type ResolvedTheme = {
-  lang: string;
+  /** Current language code used for built-in copy. */lang: string; /** Shared copy used by multiple components. */
   common: {
     blank: string;
     all: string;
@@ -135,19 +256,19 @@ type ResolvedTheme = {
     required: string;
     search: string;
     reset: string;
-  };
+  }; /** Theme values consumed by the `Blank` component. */
   Blank: {
     text: string;
-  };
+  }; /** Theme values consumed by the `Form` component. */
   Form: {
     submit: {
       text: string;
     };
-  };
+  }; /** Theme values consumed by the `Title` component. */
   Title: {
     separator: string;
     suffix: string;
-  };
+  }; /** Theme values consumed by the `Link` component. */
   Link: {
     target?: string;
     style: CSSProperties;
@@ -156,11 +277,17 @@ type ResolvedTheme = {
 type ConfigContextValue = {
   theme: ResolvedTheme;
 };
+/**
+ * Props for the `@faasjs/ant-design` {@link ConfigProvider}.
+ */
 interface ConfigProviderProps {
+  /** Optional FaasJS client options used to initialize {@link FaasReactClient}. */
   faasClientOptions?: FaasReactClientOptions;
+  /** Descendant components that consume the resolved config context. */
   children: React.ReactNode;
+  /** Theme overrides merged with the built-in defaults. */
   theme?: {
-    lang?: string;
+    /** Language code used to select localized defaults. */lang?: string; /** Common shared copy and labels used across components. */
     common?: {
       blank?: string;
       all?: string;
@@ -171,85 +298,168 @@ interface ConfigProviderProps {
       required?: string;
       search?: string;
       reset?: string;
-    };
+    }; /** Blank-component theme overrides. */
     Blank?: {
       text?: string;
-    };
+    }; /** Form-component theme overrides. */
     Form?: {
       submit?: {
         text?: string;
       };
-    };
+    }; /** Title-component theme overrides. */
     Title?: {
-      /** ' - ' as default */separator?: string;
+      /**
+       * Separator inserted between title segments.
+       *
+       * @default ' - '
+       */
+      separator?: string; /** Suffix appended to generated page titles. */
       suffix?: string;
-    };
+    }; /** Link-component theme overrides. */
     Link?: {
-      /** '_blank' as default */target?: string;
+      /**
+       * Default target used by the `Link` component when `props.target` is omitted.
+       *
+       * @default '_blank'
+       */
+      target?: string; /** Default inline styles merged into every `Link`. */
       style?: CSSProperties;
     };
   };
 }
+/**
+ * React context storing the resolved FaasJS Ant Design theme.
+ */
 declare const ConfigContext: react.Context<ConfigContextValue>;
 /**
- * Config for `@faasjs/ant-design` components.
+ * Provide theme overrides and optional FaasJS client initialization for descendants.
+ *
+ * Theme overrides are merged with the built-in defaults. When `theme.lang` is omitted, the
+ * provider infers a default language from `navigator.language`.
+ *
+ * @param {ConfigProviderProps} props - Theme overrides and optional FaasJS client configuration.
  *
  * @example
  * ```tsx
- * import { ConfigProvider } from '@faasjs/ant-design'
+ * import { Blank, ConfigProvider } from '@faasjs/ant-design'
  *
- * <ConfigProvider theme={{ common: { blank: 'Empty' } }}>
- *   <Blank />
- * </ConfigProvider>
+ * export function Page() {
+ *   return (
+ *     <ConfigProvider theme={{ common: { blank: 'Empty' } }}>
+ *       <Blank />
+ *     </ConfigProvider>
+ *   )
+ * }
  * ```
  */
 declare function ConfigProvider(props: ConfigProviderProps): react_jsx_runtime0.JSX.Element | null;
+/**
+ * Read the current `@faasjs/ant-design` config context.
+ *
+ * @returns Current config context value containing the resolved theme.
+ *
+ * @example
+ * ```tsx
+ * import { Blank, ConfigProvider, useConfigContext } from '@faasjs/ant-design'
+ *
+ * function EmptyState() {
+ *   const { theme } = useConfigContext()
+ *
+ *   return <span>{theme.common.blank}</span>
+ * }
+ *
+ * export function Page() {
+ *   return (
+ *     <ConfigProvider theme={{ common: { blank: 'N/A' } }}>
+ *       <EmptyState />
+ *     </ConfigProvider>
+ *   )
+ * }
+ * ```
+ */
 declare function useConfigContext(): ConfigContextValue;
 //#endregion
 //#region src/ErrorBoundary.d.ts
 /**
  * Styled error boundary.
+ *
+ * When `errorChildren` is not provided, the fallback UI renders an Ant Design `Alert` containing
+ * the captured error message and description.
+ *
+ * @param {ErrorBoundaryProps} props - Error boundary props forwarded to the underlying React implementation.
+ *
+ * @example
+ * ```tsx
+ * import { ErrorBoundary } from '@faasjs/ant-design'
+ *
+ * export function Page() {
+ *   return (
+ *     <ErrorBoundary>
+ *       <DangerousWidget />
+ *     </ErrorBoundary>
+ *   )
+ * }
+ * ```
  */
 declare function ErrorBoundary(props: ErrorBoundaryProps): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/App.d.ts
+/**
+ * Props for the root {@link App} shell.
+ *
+ * `App` composes the Ant Design provider tree, FaasJS config provider, shared modal and drawer
+ * state, and optional browser routing into a single wrapper component.
+ */
 interface AppProps {
+  /** Descendant elements rendered inside all configured providers. */
   children: React.ReactNode;
-  /** @see https://ant.design/components/config-provider/#API */
+  /**
+   * Props forwarded to Ant Design's `ConfigProvider`.
+   *
+   * @see https://ant.design/components/config-provider/#API
+   */
   configProviderProps?: ConfigProviderProps$1;
   /**
-   * `false` to disable BrowserRouter.
+   * Props forwarded to React Router's `BrowserRouter`, or `false` to disable browser routing.
    *
-   * Auto disable when not in browser.
+   * Routing is enabled automatically when running in a browser and this prop is not `false`.
    *
    * @see https://api.reactrouter.com/v7/interfaces/react_router.BrowserRouterProps.html
    */
   browserRouterProps?: BrowserRouterProps | false;
-  /** @see https://faasjs.com/doc/ant-design/#errorboundary */
+  /**
+   * Props forwarded to {@link ErrorBoundary}.
+   *
+   * @see https://faasjs.com/doc/ant-design/#errorboundary
+   */
   errorBoundaryProps?: Omit<ErrorBoundaryProps, 'children'>;
-  /** @see https://faasjs.com/doc/ant-design/#configprovider */
+  /**
+   * Props forwarded to {@link ConfigProvider}, or `false` to skip the FaasJS config layer.
+   *
+   * @see https://faasjs.com/doc/ant-design/#configprovider
+   */
   faasConfigProviderProps?: Omit<ConfigProviderProps, 'children'> | false;
 }
 /**
- * App component with Ant Design & FaasJS
+ * Render the root provider shell for a FaasJS Ant Design application.
+ *
+ * `App` initializes Ant Design message and notification APIs, exposes hook-managed modal and
+ * drawer state through {@link AppContext}, wraps descendants with {@link ErrorBoundary}, and
+ * optionally mounts React Router's `BrowserRouter`.
  *
- * - Based on Ant Design's [ConfigProvider](https://ant.design/components/config-provider/).
- * - Integrated Ant Design's [Message](https://ant.design/components/message/) and [Notification](https://ant.design/components/notification/).
- * - Based on FaasJS's [ConfigProvider](https://faasjs.com/doc/ant-design/#configprovider).
- * - Integrated FaasJS's [Modal](https://faasjs.com/doc/ant-design/#usemodal), [Drawer](https://faasjs.com/doc/ant-design/#usedrawer) and [ErrorBoundary](https://faasjs.com/doc/ant-design/#errorboundary).
- * - Integrated React Router's [BrowserRouter](https://api.reactrouter.com/v7/interfaces/react_router.BrowserRouterProps.html).
+ * @param {AppProps} props - App shell props including providers, routing, and error handling options.
  *
  * @example
  * ```tsx
  * import { App } from '@faasjs/ant-design'
  *
- * export default function () {
+ * export default function Page() {
  *   return (
  *     <App
- *      configProviderProps={{}} // https://ant.design/components/config-provider/#API
- *      browserRouterProps={{}} // https://api.reactrouter.com/v7/interfaces/react_router.BrowserRouterProps.html
- *      errorBoundaryProps={{}} // https://faasjs.com/doc/ant-design/#errorboundary
- *      faasConfigProviderProps={{}} // https://faasjs.com/doc/ant-design/#configprovider
+ *       configProviderProps={{}}
+ *       browserRouterProps={{}}
+ *       errorBoundaryProps={{}}
+ *       faasConfigProviderProps={{}}
  *     >
  *       <div>content</div>
  *     </App>
@@ -260,28 +470,46 @@ interface AppProps {
 declare function App(props: AppProps): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/Blank.d.ts
+/**
+ * Props for the {@link Blank} placeholder component.
+ */
 interface BlankProps {
+  /** Value to render when it is present. */
   value?: any;
+  /** Placeholder text shown when `value` is empty. */
   text?: string;
 }
 /**
- * Blank component.
+ * Render a disabled placeholder when a value is empty.
+ *
+ * Empty values include `undefined`, `null`, empty strings, and empty arrays.
  *
- * If value is undefined or null, return text, otherwise return value.
+ * @param {BlankProps} [options] - Placeholder text and value to render.
+ * @returns Rendered value or the configured placeholder text.
  *
  * @example
  * ```tsx
  * import { Blank } from '@faasjs/ant-design'
  *
- * <Blank value={undefined} text="Empty" />
+ * export function FieldPreview() {
+ *   return <Blank value={undefined} text="Empty" />
+ * }
  * ```
  */
 declare function Blank(options?: BlankProps): JSX.Element;
 //#endregion
 //#region src/FormItem.d.ts
+/**
+ * Custom renderer registration for a form item type.
+ *
+ * @template T - Value type rendered by the custom form item type.
+ */
 type ExtendFormTypeProps<T = any> = {
-  children?: UnionFaasItemElement<T>;
+  /** Custom element used to render the registered form item type. */children?: UnionFaasItemElement<T>;
 };
+/**
+ * Map of custom form item type registrations.
+ */
 type ExtendTypes = {
   [type: string]: ExtendFormTypeProps;
 };
@@ -296,39 +524,61 @@ type InputTypeMap<T> = {
   object: never;
   'object[]': never;
 };
+/**
+ * Item definition used by the `FormItem` and `Form` components.
+ *
+ * @template T - Value type rendered or edited by the form item.
+ */
 interface FormItemProps<T = any> extends BaseItemProps, Omit<FormItemProps$1<T>, 'id' | 'children' | 'render'> {
+  /**
+   * Built-in FaasJS field type used to choose the default Ant Design input.
+   *
+   * @default 'string'
+   */
   type?: FaasItemType;
+  /** Input props forwarded to the generated Ant Design control. */
   input?: InputTypeMap<T>[FaasItemType];
+  /** Maximum item count allowed for list-style field types. */
   maxCount?: number;
+  /** Nested field definitions used by `object` and `object[]` item types. */
   object?: FormItemProps[];
+  /** Whether the generated field is disabled. */
   disabled?: boolean;
+  /** Whether the generated field adds a required validation rule. */
   required?: boolean;
+  /** Grid span used by surrounding object-list layouts. */
   col?: number;
+  /** Generic custom field renderer or element. */
   children?: UnionFaasItemElement<T> | null;
+  /** Form-specific custom field renderer or element. */
   formChildren?: UnionFaasItemElement<T> | null;
+  /** Generic custom render callback. */
   render?: UnionFaasItemRender<T> | null;
+  /** Form-specific custom render callback. */
   formRender?: UnionFaasItemRender<T> | null;
+  /** Validation rules forwarded to Ant Design `Form.Item`. */
   rules?: RuleObject[];
+  /** Label override, or `false` to hide the label completely. */
   label?: string | false;
+  /** Custom form item type renderers keyed by type name. */
   extendTypes?: ExtendTypes;
-  /** trigger when current item's value changed */
+  /** Callback invoked when this field's value changes. */
   onValueChange?: (value: T, values: any, form: FormInstance) => void;
-  /** trigger when any item's value changed */
+  /** Predicate used to show or hide the item from the current form values. */
   if?: (values: Record<string, any>) => boolean;
 }
 /**
- * Extend custom form item types.
+ * Item shape used to extend `Form` with custom type names.
  *
  * @example
- * ```ts
- * import type { ExtendFormItemProps, FormProps } from '@faasjs/ant-design'
+ * ```tsx
+ * import { Form, type ExtendFormItemProps, type FormProps } from '@faasjs/ant-design'
+ * import { Input } from 'antd'
  *
- * // define custom type
  * interface ExtendTypes extends ExtendFormItemProps {
  *   type: 'password'
  * }
  *
- * // extend form
  * function ExtendForm(props: FormProps<any, ExtendTypes>) {
  *   return (
  *     <Form
@@ -338,35 +588,48 @@ interface FormItemProps<T = any> extends BaseItemProps, Omit<FormItemProps$1<T>,
  *   )
  * }
  *
- * // use custom type
- * <ExtendForm
- *   items={[
- *     {
- *       id: 'test',
- *       type: 'password',
- *     },
- *   ]}
- * />
+ * export function Page() {
+ *   return (
+ *     <ExtendForm
+ *       items={[
+ *         {
+ *           id: 'password',
+ *           type: 'password',
+ *         },
+ *       ]}
+ *     />
+ *   )
+ * }
  * ```
  */
 interface ExtendFormItemProps extends Omit<FormItemProps, 'type'> {
   type?: string;
 }
 /**
- * FormItem
+ * Render a FaasJS-aware Ant Design form field or nested field group.
+ *
+ * The component derives default labels from `id`, applies required validation messages from the
+ * active theme, supports surface-specific union renderers, and can render nested `object` or
+ * `object[]` field structures.
  *
- * - Based on [Ant Design Form.Item](https://ant.design/components/form#formitem).
- * - Can be used without [Form](https://faasjs.com/doc/ant-design/#form).
+ * @template T - Value type rendered or edited by the form item.
+ * @param {FormItemProps<T>} props - Form item props including field metadata, rules, and custom renderers.
  *
  * @example
  * ```tsx
- * // use inline type
- * <FormItem type='string' id='name' />
+ * import { FormItem } from '@faasjs/ant-design'
+ * import { Input } from 'antd'
  *
- * // use custom type
- * <FormItem id='password'>
- *   <Input.Password />
- * </>
+ * export function AccountFields() {
+ *   return (
+ *     <>
+ *       <FormItem id="name" type="string" />
+ *       <FormItem id="password">
+ *         <Input.Password />
+ *       </FormItem>
+ *     </>
+ *   )
+ * }
  * ```
  */
 declare function FormItem<T = any>(props: FormItemProps<T>): react_jsx_runtime0.JSX.Element | null;
@@ -379,25 +642,52 @@ declare namespace FormItem {
 }
 //#endregion
 //#region src/Table.d.ts
+/**
+ * Column definition used by the FaasJS Ant Design {@link Table} component.
+ *
+ * @template T - Row record type rendered by the table.
+ */
 interface TableItemProps<T = any> extends FaasItemProps, Omit<TableColumnProps<T>, 'title' | 'children' | 'render'> {
+  /** Use built-in option inference for filters when supported. */
   optionsType?: 'auto';
+  /** Generic custom element rendered when no table-specific child overrides it. */
   children?: UnionFaasItemElement<T> | null;
+  /** Table-specific custom element. */
   tableChildren?: UnionFaasItemElement<T> | null;
+  /** Generic custom render callback. */
   render?: UnionFaasItemRender<T> | null;
+  /** Table-specific custom render callback. */
   tableRender?: UnionFaasItemRender<T> | null;
+  /** Nested item definitions used by `object` and `object[]` item types. */
   object?: TableItemProps<T>[];
 }
+/**
+ * Custom renderer registration for a table item type.
+ *
+ * @template T - Row record type rendered by the custom table item type.
+ */
 type ExtendTableTypeProps<T = any> = {
-  children?: UnionFaasItemElement<T>;
+  /** Custom element used to render the registered table item type. */children?: UnionFaasItemElement<T>; /** Custom render callback used when `children` is not provided. */
   render?: UnionFaasItemRender<T>;
 };
+/**
+ * Shared fields for extending table item unions.
+ *
+ * @template T - Row record type rendered by the table.
+ */
 type ExtendTableItemProps<T = any> = BaseItemProps & Omit<TableColumnProps<T>, 'children'>;
+/**
+ * Props for the FaasJS Ant Design {@link Table} component.
+ *
+ * @template T - Row record type rendered by the table.
+ * @template ExtendTypes - Additional item prop shape accepted by `items`.
+ */
 type TableProps<T = any, ExtendTypes = any> = {
-  items: (TableItemProps | (ExtendTypes & ExtendTableItemProps))[];
+  /** Column definitions rendered by the table. */items: (TableItemProps | (ExtendTypes & ExtendTableItemProps))[]; /** Custom type renderers keyed by item type. */
   extendTypes?: {
     [key: string]: ExtendTableTypeProps;
-  };
-  faasData?: FaasDataWrapperProps<any>;
+  }; /** Request config used to fetch table data before rendering. */
+  faasData?: FaasDataWrapperProps<any>; /** Change handler that can return rewritten pagination, filter, and sorter state. */
   onChange?: (pagination: TablePaginationConfig, filters: Record<string, FilterValue | null>, sorter: SorterResult<T> | SorterResult<T>[], extra: TableCurrentDataSource<T>) => {
     pagination: TablePaginationConfig;
     filters: Record<string, FilterValue | null>;
@@ -405,41 +695,81 @@ type TableProps<T = any, ExtendTypes = any> = {
     extra: TableCurrentDataSource<T>;
   };
 } & TableProps$1<T>;
+/**
+ * Query params shape expected by table-backed FaasJS endpoints.
+ */
 type TableFaasDataParams = {
-  filters?: Record<string, any[]>;
+  /** Active filter values keyed by column field. */filters?: Record<string, any[]>; /** Pagination state sent to the endpoint. */
   pagination?: {
-    current?: number;
+    /** Current page number. */current?: number; /** Requested page size. */
     pageSize?: number;
-  };
+  }; /** Sorter state sent to the endpoint. */
   sorter?: {
-    field: string;
+    /** Column field being sorted. */field: string; /** Sort direction. */
     order: 'ascend' | 'descend';
   } | {
-    field: string;
+    /** Column field being sorted. */field: string; /** Sort direction when active. */
     order?: 'ascend' | 'descend';
   }[];
 };
+/**
+ * Paginated response shape expected by {@link Table} when using `faasData`.
+ *
+ * @template T - Row record type contained in `rows`.
+ */
 type TableFaasDataResponse<T = any> = {
-  rows: T[];
+  /** Rows rendered by the table. */rows: T[]; /** Pagination state returned by the endpoint. */
   pagination: {
-    current: number;
-    pageSize: number;
+    /** Current page number. */current: number; /** Page size used for the result set. */
+    pageSize: number; /** Total number of available rows. */
     total: number;
   };
 };
 /**
- * Table component with Ant Design & FaasJS
+ * Render an Ant Design table from FaasJS item metadata.
+ *
+ * The component can render local `dataSource` rows or resolve remote rows through `faasData`. It
+ * also generates default filters and sorters for built-in item types unless you disable them with
+ * the corresponding Ant Design column props.
+ *
+ * @template T - Row record type rendered by the table.
+ * @template ExtendTypes - Additional item prop shape accepted by `items`.
+ * @param {TableProps<T, ExtendTypes>} props - Table props including columns, data source, and optional Faas data config.
+ * @throws {Error} When an entry in `extendTypes` omits both `children` and `render`.
  *
- * - Based on [Ant Design Table](https://ant.design/components/table/).
- * - Support FaasJS injection.
- * - Auto generate filter dropdown (disable with `filterDropdown: false`).
- * - Auto generate sorter (disable with `sorter: false`).
+ * @example
+ * ```tsx
+ * import { Table } from '@faasjs/ant-design'
+ *
+ * const rows = [
+ *   { id: 1, name: 'Alice', active: true },
+ *   { id: 2, name: 'Bob', active: false },
+ * ]
+ *
+ * export function UserTable() {
+ *   return (
+ *     <Table
+ *       rowKey="id"
+ *       dataSource={rows}
+ *       items={[
+ *         { id: 'name', title: 'Name' },
+ *         { id: 'active', type: 'boolean', title: 'Active' },
+ *       ]}
+ *     />
+ *   )
+ * }
+ * ```
  */
 declare function Table<T extends Record<string, any>, ExtendTypes = any>(props: TableProps<T, ExtendTypes>): react_jsx_runtime0.JSX.Element | null;
 //#endregion
 //#region src/data.d.ts
+/**
+ * Supported built-in field types shared by form, table, and description components.
+ */
 type FaasItemType = 'string' | 'string[]' | 'number' | 'number[]' | 'boolean' | 'date' | 'time' | 'object' | 'object[]';
-/** FaasItemType's value type */
+/**
+ * Runtime value mapping for each built-in {@link FaasItemType}.
+ */
 type FaasItemTypeValue = {
   string: string;
   'string[]': string[];
@@ -451,59 +781,117 @@ type FaasItemTypeValue = {
   object: any;
   'object[]': any[];
 };
+/**
+ * Option item accepted by built-in choice inputs.
+ */
 type BaseOption = string | number | {
-  label: string;
+  /** Display label rendered by Ant Design controls. */label: string; /** Raw option value submitted or matched by components. */
   value?: any;
 };
+/**
+ * Common metadata shared by form, table, and description items.
+ */
 interface BaseItemProps {
+  /** Stable field identifier used as the default name and title source. */
   id: string | number;
+  /** Human-readable title used for labels and table headers. */
   title?: string;
+  /** Shared choice options used by select-like renderers. */
   options?: BaseOption[];
 }
+/**
+ * Base item props plus the shared built-in value type selector.
+ */
 interface FaasItemProps extends BaseItemProps {
   /**
-   * Support string, string[], number, number[], boolean, date, time, object, object[]
+   * Built-in FaasJS field type used to normalize and render values.
+   *
    * @default 'string'
    */
   type?: FaasItemType;
 }
 /**
- * Converts an identifier string to a title case string.
+ * Convert a snake_case, kebab-case, or spaced identifier into a title-style label.
  *
- * This function takes an identifier string with words separated by underscores,
- * capitalizes the first letter of each word, and joins them together without spaces.
- *
- * @param id - The identifier string to convert.
- * @returns The converted title case string.
+ * @param {string | number} id - Identifier to convert.
+ * @returns Generated label string.
  *
  * @example
- * ```typescript
- * idToTitle('example_id'); // returns 'ExampleId'
+ * ```ts
+ * idToTitle('example_id') // 'Example Id'
  * ```
  */
 declare function idToTitle(id: string | number): string;
 /**
- * convert string[] or number[] to { label, value }[]
+ * Normalize primitive options into explicit `{ label, value }` objects.
+ *
+ * String and number options are converted with {@link idToTitle}, while pre-shaped option objects
+ * are returned as-is.
+ *
+ * @param {BaseOption[]} options - Raw option list to normalize.
+ * @returns Normalized option list.
+ *
+ * @example
+ * ```ts
+ * import { transferOptions } from '@faasjs/ant-design'
+ *
+ * transferOptions(['draft', { label: 'Published', value: 'published' }])
+ * // [
+ * //   { label: 'Draft', value: 'draft' },
+ * //   { label: 'Published', value: 'published' },
+ * // ]
+ * ```
  */
 declare function transferOptions(options: BaseOption[]): {
   label: string;
   value?: string | number;
 }[];
+/**
+ * Normalize raw values into the runtime shape expected by FaasJS Ant Design components.
+ *
+ * Primitive strings such as `'null'` and `'undefined'` become `null`, comma-delimited array
+ * strings are split into arrays, and date or time values are converted to `dayjs` objects.
+ *
+ * @param {FaasItemType | null | undefined} type - Target field type.
+ * @param {any} value - Raw value to normalize.
+ * @returns Normalized value for rendering or form initialization.
+ *
+ * @example
+ * ```ts
+ * import { transferValue } from '@faasjs/ant-design'
+ *
+ * transferValue('number', '42') // 42
+ * transferValue('boolean', 'true') // true
+ * transferValue('string[]', 'a,b') // ['a', 'b']
+ * ```
+ */
 declare function transferValue(type: FaasItemType | null | undefined, value: any): any;
+/**
+ * Rendering surfaces supported by union item helpers.
+ */
 type UnionScene = 'form' | 'description' | 'table';
+/**
+ * Props injected into custom union item components.
+ *
+ * @template Value - Current item value type.
+ * @template Values - Whole record or row type that contains the value.
+ */
 type UnionFaasItemInjection<Value = any, Values = any> = {
-  scene?: UnionScene;
-  value?: Value;
-  values?: Values;
+  /** Rendering surface requesting the injected element. */scene?: UnionScene; /** Current field, cell, or item value. */
+  value?: Value; /** Full record or row containing the current value. */
+  values?: Values; /** Current row or list index when available. */
   index?: number;
 };
 /**
- * A type representing a function that renders a React node for a given item in a list.
+ * Render callback signature shared by form, description, and table item definitions.
  *
- * @param value - The value of the current item.
- * @param values - The entire list of values.
- * @param index - The index of the current item in the list.
- * @param scene - The scene in which the rendering is taking place. See {@link UnionScene}.
+ * @template Value - Current item value type.
+ * @template Values - Whole record or row type that contains the value.
+ *
+ * @param {Value} value - Current item value.
+ * @param {Values} values - Whole record or row containing the value.
+ * @param {number} index - Current row or list index.
+ * @param {UnionScene} scene - Rendering surface requesting the output.
  *
  * @example
  * ```tsx
@@ -539,9 +927,10 @@ type UnionFaasItemInjection<Value = any, Values = any> = {
  */
 type UnionFaasItemRender<Value = any, Values = any> = (value: Value, values: Values, index: number, scene: UnionScene) => React.ReactNode;
 /**
- * Represents a React element that is used in the UnionFaasItem context.
+ * Custom React component or element accepted by union item definitions.
  *
- * This type can either be a React element with the specified injection types or `null`.
+ * @template Value - Current item value type.
+ * @template Values - Whole record or row type that contains the value.
  *
  * @example
  * ```tsx
@@ -549,7 +938,6 @@ type UnionFaasItemRender<Value = any, Values = any> = (value: Value, values: Val
  *
  * const NameComponent: UnionFaasItemElement = ({ scene, value }) => {
  *   switch (scene) {
- *     switch (scene) {
  *     case 'form':
  *       return <input />
  *     case 'description':
@@ -562,49 +950,36 @@ type UnionFaasItemRender<Value = any, Values = any> = (value: Value, values: Val
  *
  * const items = [
  *   {
- *    id: 'name',
- *    children: NameComponent // both `NameComponent` and `<NameComponent />` is valid
+ *     id: 'name',
+ *     children: NameComponent, // both `NameComponent` and `<NameComponent />` are valid
  *   }
  * ]
  *
  * function App() {
- *   return <>
- *    <Form items={items} /> // Will render an input
- *    <Description items={items} dataSource={{ name: 'John' }} /> // Will render a span
- *    <Table items={items} dataSource={[{ name: 'John' }]} /> // Will render a span
- *  </>
+ *   return (
+ *     <>
+ *       <Form items={items} />
+ *       <Description items={items} dataSource={{ name: 'John' }} />
+ *       <Table items={items} dataSource={[{ name: 'John' }]} />
+ *     </>
+ *   )
  * }
  * ```
  */
 type UnionFaasItemElement<Value = any, Values = any> = ReactElement<UnionFaasItemInjection<Value, Values>> | FC<UnionFaasItemInjection<Value, Values>>;
 /**
- * Interface representing the properties of a UnionFaas item.
- *
- * The UnionFaas item can be used in a form, description, or table.
+ * Shared union item contract that can be reused across `Form`, `Description`, and `Table`.
  *
  * ### Render Priority Order
  *
- * 1. **Null Rendering** (Notice: it also doesn't render column in table and description)
- *    1. Returns `null` if specific children or render props are null:
- *        - `formChildren` / `descriptionChildren` / `tableChildren` / `formRender` / `descriptionRender` / `tableRender`
- *    2. Returns `null` if `children` or `render` prop is null
- * 2. **Children Rendering**
- *    1. First priority: Component-specific children
- *        - `formChildren` for Form
- *        - `descriptionChildren` for Description
- *        - `tableChildren` for Table
- *    2. Second priority: Generic `children` prop
- * 3. **Custom Render Functions**
- *    1. First priority: Component-specific render functions
- *        - `formRender` for Form
- *        - `descriptionRender` for Description
- *        - `tableRender` for Table
- *    2. Second priority: Generic `render` prop
- * 4. **Extended Types**
- *    - Renders based on registered extended type handlers
- * 5. **Default Rendering**
- *    - Renders primitive types (string, number, etc.)
- *    - Uses default formatting based on data type
+ * 1. Component-specific null renderers hide the item for that surface.
+ * 2. Component-specific children override generic `children`.
+ * 3. Component-specific render callbacks override generic `render`.
+ * 4. Registered extended types handle unmatched items.
+ * 5. Built-in type renderers handle primitive and object values.
+ *
+ * @template Value - Current item value type.
+ * @template Values - Whole record or row type that contains the value.
  *
  * @example
  * ```tsx
@@ -642,105 +1017,183 @@ type UnionFaasItemElement<Value = any, Values = any> = ReactElement<UnionFaasIte
  * ```
  */
 interface UnionFaasItemProps<Value = any, Values = any> extends FormItemProps, DescriptionItemProps, TableItemProps {
+  /** Shared custom element rendered when no surface-specific child overrides it. */
   children?: UnionFaasItemElement<Value, Values> | null;
+  /** Shared render callback used when no surface-specific render overrides it. */
   render?: UnionFaasItemRender<Value, Values> | null;
+  /** Nested item definitions used by `object` and `object[]` item types. */
   object?: UnionFaasItemProps<Value, Values>[];
 }
 /**
- * Clone a UnionFaasItemElement with the given props.
+ * Clone a {@link UnionFaasItemElement} with FaasJS injection props.
+ *
+ * React elements are cloned directly, while component references are first wrapped with
+ * `createElement`.
+ *
+ * @param {UnionFaasItemElement} element - Element or component to clone.
+ * @param {any} props - Injection props such as `scene`, `value`, `values`, and `index`.
+ * @returns Cloned React element ready for rendering.
+ *
+ * @example
+ * ```tsx
+ * import { cloneUnionFaasItemElement, type UnionFaasItemElement } from '@faasjs/ant-design'
  *
- * This function takes a UnionFaasItemElement and props, and returns a cloned element.
- * If the provided element is a valid React element, it clones it with the new props.
- * Otherwise, it creates a new element from the provided element and props.
+ * const Cell: UnionFaasItemElement<string> = ({ value }) => <span>{value}</span>
  *
- * @param element - The UnionFaasItemElement to be cloned.
- * @param props - The props to be applied to the cloned element.
- * @returns The cloned element with the applied props.
+ * const element = cloneUnionFaasItemElement(Cell, {
+ *   scene: 'table',
+ *   value: 'Hello',
+ *   index: 0,
+ * })
+ * ```
  */
 declare function cloneUnionFaasItemElement(element: UnionFaasItemElement, props: any): ReactElement<UnionFaasItemInjection<any, any>, string | react.JSXElementConstructor<any>>;
 //#endregion
 //#region src/Description.d.ts
+/**
+ * Custom renderer registration for a description item type.
+ *
+ * @template T - Value type rendered by the custom description item type.
+ */
 interface ExtendDescriptionTypeProps<T = any> {
+  /** Custom element used to render the registered description item type. */
   children?: UnionFaasItemElement<T>;
+  /** Custom render callback used when `children` is not provided. */
   render?: UnionFaasItemRender<T>;
 }
+/**
+ * Shared fields for extending description item unions.
+ */
 type ExtendDescriptionItemProps = BaseItemProps;
+/**
+ * Item definition used by {@link Description}.
+ *
+ * @template T - Value type rendered by the item.
+ */
 interface DescriptionItemProps<T = any> extends FaasItemProps {
+  /** Generic custom element rendered when no description-specific child overrides it. */
   children?: UnionFaasItemElement<T> | null;
+  /** Description-specific custom element. */
   descriptionChildren?: UnionFaasItemElement<T> | null;
+  /** Generic custom render callback. */
   render?: UnionFaasItemRender<T> | null;
+  /** Description-specific custom render callback. */
   descriptionRender?: UnionFaasItemRender<T> | null;
+  /** Predicate used to hide the item for the current record. */
   if?: (values: Record<string, any>) => boolean;
+  /** Nested item definitions used by `object` and `object[]` item types. */
   object?: DescriptionItemProps<T>[];
 }
+/**
+ * Props for the {@link Description} component.
+ *
+ * @template T - Data record shape rendered by the component.
+ * @template ExtendItemProps - Additional item prop shape accepted by `items`.
+ */
 interface DescriptionProps<T = any, ExtendItemProps = any> extends Omit<DescriptionsProps, 'items'> {
+  /** Callback used to derive the rendered title from the current record. */
   renderTitle?(this: void, values: T): ReactNode;
+  /** Description item definitions rendered by the component. */
   items: (DescriptionItemProps | ExtendItemProps)[];
+  /** Custom type renderers keyed by item type. */
   extendTypes?: {
     [key: string]: ExtendDescriptionTypeProps;
   };
+  /** Local data record rendered directly by the component. */
   dataSource?: T;
+  /** Request config used to fetch the record before rendering. */
   faasData?: FaasDataWrapperProps<any>;
 }
+/**
+ * Props passed to the exported `DescriptionItemContent` helper shape.
+ *
+ * @template T - Value type rendered by the item content.
+ */
 interface DescriptionItemContentProps<T = any> {
+  /** Item definition describing how the value should render. */
   item: DescriptionItemProps;
+  /** Current item value. */
   value: T;
+  /** Full record containing the current value. */
   values?: any;
+  /** Custom type renderers keyed by item type. */
   extendTypes?: {
     [key: string]: ExtendDescriptionTypeProps;
   };
 }
 /**
- * Description component
+ * Render an Ant Design description list from FaasJS item metadata.
+ *
+ * The component can render a local `dataSource` directly or resolve one through `faasData`, and
+ * it applies the same item type normalization helpers used by the form and table components.
  *
- * - Based on [Ant Design Descriptions](https://ant.design/components/descriptions/).
+ * @template T - Data record shape rendered by the component.
+ * @param {DescriptionProps<T>} props - Description props including items, data source, and optional Faas data config.
+ * @throws {Error} When an entry in `extendTypes` omits both `children` and `render`.
  *
  * @example
  * ```tsx
  * import { Description } from '@faasjs/ant-design'
  *
- * <Description
- *   title="Title"
- *   items={[
- *     {
- *       id: 'id',
- *       title: 'Title',
- *       type: 'string',
- *     },
- *   ]}
- *   dataSource={{ id: 'value' }}
- * />
+ * export function Detail() {
+ *   return (
+ *     <Description
+ *       title="Title"
+ *       items={[
+ *         {
+ *           id: 'id',
+ *           title: 'Title',
+ *           type: 'string',
+ *         },
+ *       ]}
+ *       dataSource={{ id: 'value' }}
+ *     />
+ *   )
+ * }
  * ```
  */
-declare function Description<T extends Record<string, any> = any>({
-  faasData,
-  dataSource,
-  renderTitle,
-  extendTypes,
-  ...props
-}: DescriptionProps<T>): react_jsx_runtime0.JSX.Element;
+declare function Description<T extends Record<string, any> = any>(props: DescriptionProps<T>): react_jsx_runtime0.JSX.Element;
 declare namespace Description {
   var displayName: string;
 }
 //#endregion
 //#region src/Drawer.d.ts
+/**
+ * Props accepted by the hook-managed drawer wrapper.
+ */
 interface DrawerProps extends DrawerProps$1 {
+  /** Drawer body content managed by {@link useDrawer}. */
   children?: JSX.Element | JSX.Element[];
 }
+/**
+ * State setter used to update hook-managed drawer props.
+ */
 type setDrawerProps = Dispatch<SetStateAction<DrawerProps>>;
 /**
- * Hook style drawer
+ * Create a hook-managed Ant Design drawer instance.
+ *
+ * The returned setter merges partial updates into the current drawer props instead of replacing the
+ * entire state object.
  *
+ * @param {DrawerProps} [init] - Initial drawer props.
+ * @returns Hook-managed drawer element, current props, and a state-merging setter.
+ *
+ * @example
  * ```tsx
+ * import { useDrawer } from '@faasjs/ant-design'
+ * import { Button } from 'antd'
+ *
  * function Example() {
  *   const { drawer, setDrawerProps } = useDrawer()
  *
- *   return <>
- *     <Button onClick={ () => setDrawerProps(prev => ({ open: !prev.open})) }>
- *       Toggle
- *     </Button>
- *     {drawer}
- *   </>
+ *   return (
+ *     <>
+ *       <Button onClick={() => setDrawerProps({ open: true, title: 'Details', children: <div>Content</div> })}>
+ *         Open
+ *       </Button>
+ *       {drawer}
+ *     </>
+ *   )
  * }
  * ```
  */
@@ -751,16 +1204,21 @@ declare function useDrawer(init?: DrawerProps): {
 };
 //#endregion
 //#region src/Form.d.ts
+/**
+ * Props for the built-in submit button rendered by {@link Form}.
+ */
 type FormSubmitProps = {
-  /** Default: Submit */text?: string; /** Props for the built-in submit button */
+  /** Text rendered by the built-in submit button. */text?: string; /** Additional props forwarded to the built-in submit button. */
   buttonProps?: ButtonProps;
 };
 /**
- * Built-in FaasJS submit handler for Form.
+ * Built-in FaasJS submit handler configuration for {@link Form}.
+ *
+ * @template Values - Form values shape used by submit handlers.
  *
  * @example
  * ```ts
- * {
+ * const faas = {
  *   action: 'user/create',
  *   params: (values) => ({
  *     ...values,
@@ -773,34 +1231,43 @@ type FormSubmitProps = {
  * ```
  */
 type FormFaasProps<Values extends Record<string, any> = any> = {
-  /** Action name to submit to */action: FaasAction; /** params will overwrite form values before submit */
-  params?: Record<string, any> | ((values: Record<string, any>) => Record<string, any>); /** Transform form values before sending the request */
-  transformValues?: (values: Values) => Record<string, any> | Promise<Record<string, any>>; /** Called when the request succeeds */
-  onSuccess?: (result: any, values: Record<string, any>) => void; /** Called when the request fails */
-  onError?: (error: any, values: Record<string, any>) => void; /** Called after the request settles */
+  /** Action name submitted through `faas()`. */action: FaasAction; /** Extra params merged into the submitted payload after `transformValues` runs. */
+  params?: Record<string, any> | ((values: Record<string, any>) => Record<string, any>); /** Transform form values before sending the request. */
+  transformValues?: (values: Values) => Record<string, any> | Promise<Record<string, any>>; /** Callback invoked when the request succeeds. */
+  onSuccess?: (result: any, values: Record<string, any>) => void; /** Callback invoked when the request fails. */
+  onError?: (error: any, values: Record<string, any>) => void; /** Callback invoked after the request settles. */
   onFinally?: () => void;
 };
+/**
+ * Props for the FaasJS Ant Design {@link Form} component.
+ *
+ * @template Values - Form values shape.
+ * @template ExtendItemProps - Additional item prop shape accepted by `items`.
+ */
 type FormProps<Values extends Record<string, any> = any, ExtendItemProps extends ExtendFormItemProps = ExtendFormItemProps> = Omit<FormProps$1<Values>, 'onFinish' | 'children' | 'initialValues'> & {
-  items?: ((ExtendItemProps extends ExtendFormItemProps ? ExtendItemProps | FormItemProps : FormItemProps) | JSX.Element)[]; /** Default: { text: 'Submit' }, set false to disable it */
-  submit?: false | FormSubmitProps;
-  beforeItems?: JSX.Element | JSX.Element[];
-  footer?: JSX.Element | JSX.Element[];
-  extendTypes?: ExtendTypes;
-  children?: ReactNode;
+  /** Form item definitions or custom JSX blocks rendered inside the form. */items?: ((ExtendItemProps extends ExtendFormItemProps ? ExtendItemProps | FormItemProps : FormItemProps) | JSX.Element)[]; /** Built-in submit button config, or `false` to disable the generated submit button. */
+  submit?: false | FormSubmitProps; /** Extra content rendered before generated items. */
+  beforeItems?: JSX.Element | JSX.Element[]; /** Extra content rendered after generated items. */
+  footer?: JSX.Element | JSX.Element[]; /** Custom form item type renderers keyed by type name. */
+  extendTypes?: ExtendTypes; /** Additional custom content rendered inside the form. */
+  children?: ReactNode; /** Initial values applied to the underlying Ant Design form. */
   initialValues?: Partial<Values>;
 } & ({
-  /** Built-in FaasJS submit handler, ignored when onFinish is provided */faas?: FormFaasProps<Values>;
+  /** Built-in FaasJS submit handler, ignored when `onFinish` is provided. */faas?: FormFaasProps<Values>;
   onFinish?: never;
 } | {
-  faas?: never; /** Custom submit handler, takes precedence over faas when both are provided */
+  faas?: never; /** Custom submit handler used instead of the built-in FaasJS submit flow. */
   onFinish?: (values: Values) => void | Promise<void>;
 });
 /**
- * Form component with Ant Design & FaasJS
+ * Render a data-aware Ant Design form with optional FaasJS submission helpers.
  *
- * - Based on [Ant Design Form](https://ant.design/components/form/).
- * - Use `onFinish` for custom submit logic.
- * - Use `faas` for the built-in FaasJS submit flow.
+ * The component normalizes `initialValues` with {@link transferValue}, renders item definitions
+ * through {@link FormItem}, and can either delegate submission to a custom `onFinish` handler or
+ * the built-in FaasJS request flow configured by `faas`.
+ *
+ * @template Values - Form values shape.
+ * @param {FormProps<Values>} props - Form props including items, submit behavior, and FaasJS integration.
  *
  * @example
  * ```tsx
@@ -856,48 +1323,92 @@ declare namespace Form {
 }
 //#endregion
 //#region src/Link.d.ts
+/**
+ * Props for the navigation-aware {@link Link} component.
+ */
 interface LinkProps {
+  /** Target URL or route path. */
   href: string;
+  /** Explicit link target. Absolute HTTP URLs default to `_blank`. */
   target?: '_blank';
+  /** Text rendered when `children` is not provided. */
   text?: string | number;
+  /** Custom link content rendered instead of `text`. */
   children?: ReactNode;
+  /** Inline styles merged with the theme defaults. */
   style?: CSSProperties;
+  /** Button mode config, or `true` to render with default Ant Design button props. */
   button?: ButtonProps | boolean;
+  /** Whether the rendered link or button should take the full width. */
   block?: boolean;
-  /** only use for text without button */
+  /** Whether plain-text links should enable the Typography copy action. */
   copyable?: boolean;
+  /** Custom click handler that overrides the built-in navigation behavior. */
   onClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
 }
 /**
- * Link component with button
+ * Render a navigation-aware link or button.
+ *
+ * Internal links are pushed through React Router, while links with `_blank` targets are opened
+ * with `window.open`.
+ *
+ * @param {LinkProps} props - Link props controlling navigation target, rendering mode, and button behavior.
  *
  * @example
  * ```tsx
- * // pure link
- * <Link href="/">Home</Link>
+ * import { Link } from '@faasjs/ant-design'
  *
- * // link with button
- * <Link href="/" button={{ type:'primary' }}>Home</Link>
+ * export function Navigation() {
+ *   return (
+ *     <>
+ *       <Link href="/">Home</Link>
+ *       <Link href="/users/new" button={{ type: 'primary' }}>
+ *         Create User
+ *       </Link>
+ *     </>
+ *   )
+ * }
  * ```
  */
 declare function Link(props: LinkProps): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/Modal.d.ts
+/**
+ * Props accepted by the hook-managed modal wrapper.
+ */
 interface ModalProps extends ModalProps$1 {
+  /** Modal body content managed by {@link useModal}. */
   children?: JSX.Element | JSX.Element[] | string;
 }
+/**
+ * State setter used to update hook-managed modal props.
+ */
 type setModalProps = Dispatch<SetStateAction<ModalProps>>;
 /**
- * Hook style modal
+ * Create a hook-managed Ant Design modal instance.
+ *
+ * The returned setter merges partial updates into the current modal props instead of replacing the
+ * entire state object.
  *
+ * @param {ModalProps} [init] - Initial modal props.
+ * @returns Hook-managed modal element, current props, and a state-merging setter.
+ *
+ * @example
  * ```tsx
+ * import { useModal } from '@faasjs/ant-design'
+ * import { Button } from 'antd'
+ *
  * function Example() {
  *   const { modal, setModalProps } = useModal()
  *
- *   return <>
- *     <Button onClick={() => setModalProps({ open: true })}>Open Modal</Button>
- *     {modal}
- *   </>
+ *   return (
+ *     <>
+ *       <Button onClick={() => setModalProps({ open: true, title: 'Delete', children: 'Are you sure?' })}>
+ *         Open Modal
+ *       </Button>
+ *       {modal}
+ *     </>
+ *   )
  * }
  * ```
  */
@@ -908,138 +1419,241 @@ declare function useModal(init?: ModalProps): {
 };
 //#endregion
 //#region src/Routers.d.ts
+/**
+ * Default 404 route element that uses the configured localized title.
+ *
+ * @example
+ * ```tsx
+ * import { PageNotFound, Routes } from '@faasjs/ant-design'
+ *
+ * export function AppRoutes() {
+ *   return (
+ *     <Routes
+ *       routes={[{ path: '/', element: <div>Home</div> }]}
+ *       notFound={<PageNotFound />}
+ *     />
+ *   )
+ * }
+ * ```
+ */
 declare function PageNotFound(): react_jsx_runtime0.JSX.Element;
+/**
+ * Props for the lazy-loading {@link Routes} wrapper.
+ */
 interface RoutesProps {
+  /** Route records forwarded to React Router, with optional lazy `page` components. */
   routes: (RouteProps & {
     page?: LazyExoticComponent<ComponentType<any>>;
   })[];
+  /** Fallback element rendered while lazy pages are loading. */
   fallback?: JSX.Element;
+  /** Element rendered for the generated catch-all 404 route. */
   notFound?: JSX.Element;
 }
 /**
- * Routes with lazy loading and 404 page.
+ * Render React Router routes with lazy-page support and a default 404 route.
+ *
+ * The wrapper adds a catch-all route automatically and uses an Ant Design `Skeleton` fallback when
+ * `fallback` is not provided.
+ *
+ * @param {RoutesProps} props - Route definitions and optional fallback or 404 elements.
  *
  * @example
  * ```tsx
  * import { Routes, lazy } from '@faasjs/ant-design'
  * import { BrowserRouter } from 'react-router-dom'
  *
- * export function App () {
- *   return <BrowserRouter>
- *     <Routes routes={[
- *       {
- *         path: '/',
- *         page: lazy(() => import('./pages/home'))
- *       }
- *     ]} />
- *   </BrowserRouter>
+ * export function App() {
+ *   return (
+ *     <BrowserRouter>
+ *       <Routes
+ *         routes={[
+ *           {
+ *             path: '/',
+ *             page: lazy(() => import('./pages/home')),
+ *           },
+ *         ]}
+ *       />
+ *     </BrowserRouter>
+ *   )
  * }
  * ```
  */
 declare function Routes(props: RoutesProps): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/Tabs.d.ts
+/**
+ * Tab item accepted by the FaasJS Ant Design {@link Tabs} wrapper.
+ */
 interface TabProps extends Partial<Tab> {
+  /** Stable tab identifier used as the default key and label. */
   id: string;
+  /** Title used as the default Ant Design tab label. */
   title?: React.ReactNode;
+  /** Tab panel content. */
   children: React.ReactNode;
 }
+/**
+ * Props for the FaasJS Ant Design {@link Tabs} component.
+ */
 interface TabsProps extends Omit<TabsProps$1, 'items'> {
-  /** auto skip null tab */
+  /** Tab definitions. `null` and `false` entries are skipped automatically. */
   items: (TabProps | null | false)[];
 }
 /**
- * Tabs component with Ant Design & FaasJS
+ * Render an Ant Design tabs wrapper that accepts FaasJS-style tab definitions.
  *
- * - Based on [Ant Design Tabs](https://ant.design/components/tabs/).
- * - Support auto skip null/false tab item.
- * - Support `id` as key and label.
+ * Missing `key` and `label` values are derived from each tab's `id` and `title`.
+ *
+ * @param {TabsProps} props - Tabs props including tab items and Ant Design tab options.
  *
  * @example
  * ```tsx
  * import { Tabs } from '@faasjs/ant-design'
  *
- * <Tabs
- *   items={[
- *     {
- *       id: 'id',
- *       children: 'content',
- *     },
- *     1 === 0 && {
- *       id: 'hidden',
- *       children: 'content',
- *     },
- *   ]}
- * />
+ * export function Page() {
+ *   return (
+ *     <Tabs
+ *       items={[
+ *         {
+ *           id: 'id',
+ *           children: 'content',
+ *         },
+ *         1 === 0 && {
+ *           id: 'hidden',
+ *           children: 'content',
+ *         },
+ *       ]}
+ *     />
+ *   )
+ * }
  * ```
  */
 declare function Tabs(props: TabsProps): react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/Title.d.ts
+/**
+ * Props for the document-title helper component.
+ */
 interface TitleProps {
+  /** Title text or title segments used to update `document.title`. */
   title: string | string[];
-  /** ` - ` as default */
+  /**
+   * Separator used when joining title segments.
+   *
+   * @default ' - '
+   */
   separator?: string;
+  /** Suffix appended to the generated document title. */
   suffix?: string;
-  /** return a h1 element */
+  /** Whether to render an `h1`, or the props used to style that `h1`. */
   h1?: boolean | {
     className?: string;
     style?: React.CSSProperties;
   };
-  /** return a pure text element */
+  /** Whether to render plain text instead of returning `null`. */
   plain?: boolean;
-  /** return children */
+  /** Existing element cloned with a `title` prop. */
   children?: JSX.Element;
 }
 /**
- * Title is used to change the title of the page
+ * Update `document.title` and optionally render the title inline.
  *
- * Return null by default.
+ * The component returns `null` by default and is often used only for its side effect.
  *
- * ```tsx
- * // return null
- * <Title title='hi' /> // => change the document.title to 'hi'
- * <Title title={['a', 'b']} /> // => change the document.title to 'a - b'
+ * @param {TitleProps} props - Title props controlling document title updates and optional inline rendering.
  *
- * // return h1
- * <Title title='hi' h1 /> // => <h1>hi</h1>
- * <Title title={['a', 'b']} h1 /> // => <h1>a</h1>
+ * @example
+ * ```tsx
+ * import { Title } from '@faasjs/ant-design'
  *
- * // return children
- * <Title title='hi'><CustomTitle /></Title> // => <CustomTitle />
+ * export function DetailPage() {
+ *   return (
+ *     <>
+ *       <Title title={['Orders', 'Detail']} h1 />
+ *       <div>...</div>
+ *     </>
+ *   )
+ * }
  * ```
  */
 declare function Title(props: TitleProps): JSX.Element | null;
 //#endregion
 //#region src/useApp.d.ts
+/**
+ * Shared app services exposed by {@link AppContext} and {@link useApp}.
+ */
 interface useAppProps {
+  /** Ant Design message API instance created by the root `App` component. */
   message: MessageInstance;
+  /** Ant Design notification API instance created by the root `App` component. */
   notification: NotificationInstance;
+  /** Current props of the hook-managed modal element. */
   modalProps: ModalProps;
+  /** Setter that merges updates into the hook-managed modal props. */
   setModalProps: setModalProps;
+  /** Current props of the hook-managed drawer element. */
   drawerProps: DrawerProps;
+  /** Setter that merges updates into the hook-managed drawer props. */
   setDrawerProps: setDrawerProps;
 }
+/**
+ * Shared context storing message, notification, modal, and drawer helpers.
+ */
 declare const AppContext: any;
 /**
- * Get app context.
+ * Read app-level services exposed by the root `App` component.
  *
- * ```ts
- * import { useApp } from '@faasjs/ant-design'
+ * @template NewT - Narrowed app context shape to read from `AppContext`.
+ * @returns Read-only app context value.
  *
- * const { message, notification, setModalProps, setDrawerProps } = useApp()
+ * @example
+ * ```tsx
+ * import { App, useApp } from '@faasjs/ant-design'
+ * import { Button } from 'antd'
+ *
+ * function Page() {
+ *   const { message, setModalProps } = useApp()
+ *
+ *   return (
+ *     <Button
+ *       onClick={() => {
+ *         message.success('Saved')
+ *         setModalProps({ open: true, title: 'Done', children: 'Profile updated.' })
+ *       }}
+ *     >
+ *       Save
+ *     </Button>
+ *   )
+ * }
+ *
+ * export function Root() {
+ *   return (
+ *     <App>
+ *       <Page />
+ *     </App>
+ *   )
+ * }
  * ```
  */
 declare function useApp<NewT extends useAppProps = useAppProps>(this: void): Readonly<NewT>;
 //#endregion
 //#region src/useThemeToken.d.ts
 /**
- * Hook to retrieve the theme token from the Ant Design theme configuration.
+ * Read the current Ant Design theme token.
+ *
+ * @returns Ant Design global token object for the active theme.
  *
- * This function uses the `theme.useToken` method to get the current theme configuration
- * and returns the `token` property from the configuration.
+ * @example
+ * ```tsx
+ * import { useThemeToken } from '@faasjs/ant-design'
+ *
+ * function PrimarySwatch() {
+ *   const { colorPrimary } = useThemeToken()
  *
- * @returns {GlobalToken} The theme token from the Ant Design theme configuration.
+ *   return <div style={{ width: 24, height: 24, background: colorPrimary }} />
+ * }
+ * ```
  */
 declare function useThemeToken(): GlobalToken;
 //#endregion