prime-ui-kit 0.15.0 → 0.17.0

package/dist/components/kanban/Kanban.d.ts

@@ -33,7 +33,9 @@ export type KanbanColumnMove = {
     index: number;
 };
 /** What opened a card: a click on it, or Enter / Space on the focused card. */
-export type KanbanItemClickEvent = React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+export type KanbanItemOpenEvent = React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLElement>;
+/** The heading level of the column titles in the page outline. */
+export type KanbanColumnTitleAs = "h2" | "h3" | "h4";
 /** How columns stand on the board: bare columns of cards, or filled wells. */
 export type KanbanVariant = "plain" | "line" | "well";
 /** System strings of the board. `{token}` values are substituted. */
@@ -57,92 +59,118 @@ export type KanbanLabels = {
     /** Spoken when a column's move is refused (its `onColumnOrderChange` promise rejected): `{column}`. */
     columnMoveFailed: string;
 };
-export declare const defaultKanbanLabels: KanbanLabels;
+export declare const KANBAN_LABELS: KanbanLabels;
 export type KanbanRootProps<T> = Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "defaultValue"> & {
-    /** Every column; `columnOrder` decides their order (array order by default). */
+    /**
+     * Every column: `{ id, title, description?, color?, limit?, locked? }`, drawn in `columnOrder`. `color` is a `PaletteColor` for the count badge, `limit` a WIP limit, `locked` keeps a system stage in place.
+     */
     columns: readonly KanbanColumn[];
-    /** Every card the board can show; `value` decides where each one stands. */
+    /**
+     * Every card the board can show; `value` decides where each one stands.
+     */
     items: readonly T[];
-    /** Stable unique id of a card. */
+    /**
+     * Stable unique id of a card, the one used in `value`.
+     */
     getId: (item: T) => string;
-    /** Spoken by the live region. Defaults to the id. */
+    /**
+     * Spoken by the live region.
+     */
     getLabel?: (item: T) => string;
-    /** Card ids per column (controlled). */
+    /**
+     * Card ids per column (controlled): `{ [columnId]: id[] }`. Ids missing from `items` are skipped.
+     */
     value?: KanbanValue;
-    /** Initial card ids per column (uncontrolled). */
+    /**
+     * Initial card ids per column (uncontrolled).
+     */
     defaultValue?: KanbanValue;
     /**
-     * A card moved: the new placement first, then what moved. Return a promise to save on a server:
-     * the card stays in its new place, busy, until it settles; reject — it glides back.
+     * A card moved: the new placement, then `{ id, from, to, index }` to save. Return the save's promise: the card waits busy in its new place; a rejection glides it back.
      */
     onValueChange?: (value: KanbanValue, move: KanbanMove) => void | Promise<void>;
-    /** Column ids in their order (controlled). */
+    /**
+     * Column ids in their order (controlled). Columns it does not name follow in `columns` order.
+     */
     columnOrder?: readonly string[];
-    /** Initial column ids in their order (uncontrolled). Defaults to the order of `columns`. */
+    /**
+     * Initial column ids in their order (uncontrolled).
+     */
     defaultColumnOrder?: readonly string[];
     /**
-     * A column moved: the new order first, then what moved. Return a promise to save on a server:
-     * the column stays in its new place, busy, until it settles; reject — it glides back.
+     * A column moved: the new order, then `{ id, index }` to save. Return the save's promise: the column waits busy in its new place; a rejection glides it back.
      */
     onColumnOrderChange?: (order: readonly string[], move: KanbanColumnMove) => void | Promise<void>;
-    /** A grip in every column header moves the column by pointer, touch and keyboard. */
+    /**
+     * A grip (`Dnd.Handle`) at the end of every column header moves the column by pointer, touch hold and Alt + ← / →; the cards travel with it.
+     */
     reorderableColumns?: boolean;
-    /** Renders one card; return a `Kanban.Item`. */
+    /**
+     * Renders one card; return a `Kanban.Item`.
+     */
     renderItem: (item: T) => React.ReactNode;
     /**
-     * The card is a link: a real `<a>` named by `getLabel` covers the card and is its tab stop, so a
-     * click, ⌘/Ctrl-click, a middle click and «open in new tab» work anywhere on it. A drag never
-     * follows it; Alt + arrows still move the card from it.
+     * The card is a link: a real `<a>` named by `getLabel` covers it and is its tab stop — a click, ⌘/Ctrl-click, a middle click, a new tab. A press on it still drags the card; a drag never follows it.
      */
     getItemHref?: (item: T) => string;
     /**
-     * Opens a card in place: a click on it (never on a control inside it, never after a drag) or
-     * Enter / Space on the focused card. With `getItemHref` it gets the plain clicks only — call
-     * `event.preventDefault()` there to route in the app instead of loading the page.
+     * Opens a card in place (a Drawer): a click, Enter or Space; never from a control inside it or after a drag. With `getItemHref` it gets plain clicks: `event.preventDefault()` routes in the app.
+     */
+    onItemOpen?: (item: T, event: KanbanItemOpenEvent) => void;
+    /**
+     * Heading level of the column titles in the page outline; the look does not change.
+     */
+    columnTitleAs?: KanbanColumnTitleAs;
+    /**
+     * Trailing actions of a column header (add a card, a menu); kit controls inside take the `s` tier.
      */
-    onItemClick?: (item: T, event: KanbanItemClickEvent) => void;
-    /** Renders the trailing actions of a column header (add a card, a menu). */
     renderColumnActions?: (column: KanbanColumn) => React.ReactNode;
     /**
-     * Renders the meta line under a column's title (a stage's figures: «12 сделок · 4,8 млн ₽»).
-     * It describes the column's list, like `description`.
+     * The meta line under a column's title and description: the stage's figures («12 сделок · 4,8 млн ₽»). Like `description`, it describes the column's list.
      */
     renderColumnMeta?: (column: KanbanColumn) => React.ReactNode;
     /**
-     * Refuses a card in a column (a workflow rule): `false`, or a string that says why — spoken and
-     * shown under the carried card. The column turns `danger` before the release.
+     * A workflow rule: refuses card `id` in column `columnId` — `false`, or a string that says why (spoken and shown under the carried card). The column turns `danger` before the release.
      */
     canDrop?: (id: string, columnId: string) => boolean | string;
     /**
-     * `plain`: no wells, the cards stand on the host under a filled header plate; `line`: no wells, a
-     * bare header over a faint line; `well`: every column is a filled well.
+     * No wells: `plain` — a filled header plate over the cards, `line` — a bare header over a faint line; cards stand on the host. `well`: every column is a filled well holding its cards (bounded queues).
      */
     variant?: KanbanVariant;
-    /** Columns show skeleton cards; the cards cross-fade in when it turns off. */
+    /**
+     * Columns show skeleton cards in the card geometry; the cards cross-fade in when it turns off.
+     */
     loading?: boolean;
-    /** No drag, no keyboard moves. */
+    /**
+     * Read-only board: no drag, no keyboard moves, no column grips; `onItemOpen` and `getItemHref` still open cards.
+     */
     disabled?: boolean;
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<KanbanLabels>;
     ref?: React.Ref<HTMLDivElement>;
 };
 /**
  * A board of columns: cards move within and between columns by pointer, touch (a hold) and
- * keyboard (Alt + arrows, Dnd's linked lists). Mounts its own `Dnd.Root` unless one is already
- * above it.
+ * keyboard (Alt + arrows, Dnd's linked lists). Its `Dnd.Root` joins a drag session already above
+ * it.
  */
 declare function KanbanRoot<T>(props: KanbanRootProps<T>): import("react/jsx-runtime").JSX.Element;
 declare namespace KanbanRoot {
     var displayName: string;
 }
 export type KanbanItemProps = Omit<React.HTMLAttributes<HTMLElement>, "id"> & {
-    /** This card cannot be dragged or moved. */
+    /**
+     * This card cannot be dragged or moved.
+     */
     disabled?: boolean;
     ref?: React.Ref<HTMLElement>;
 };
 /**
  * One card: an `<li>` on a filled surface; drags by the whole card, moves with Alt + arrows. While
  * the owner saves its move it is busy: dimmed under a spinner, still. With `getItemHref` a link
- * covers it; with `onItemClick` a click, Enter or Space opens it.
+ * covers it; with `onItemOpen` a click, Enter or Space opens it.
  */
 declare function KanbanItem({ disabled, className, children, onClick, onKeyDown, ...rest }: KanbanItemProps): import("react/jsx-runtime").JSX.Element;
 declare namespace KanbanItem {

package/dist/components/kbd/Kbd.d.ts

@@ -1,7 +1,9 @@
 import type * as React from "react";
 import type { ControlSize } from "../../internal/states";
 export type KbdProps = Omit<React.HTMLAttributes<HTMLElement>, "size"> & {
-    /** Badge tier; without it the key follows the surrounding control one tier down, else `m`. */
+    /**
+     * Badge tier, 16 · 20 · 24 · 28 · 32 px high. Without it the key follows the surrounding control one tier down (m → s); outside a control it is `m`.
+     */
     size?: ControlSize;
     ref?: React.Ref<HTMLElement>;
 };

package/dist/components/label/Label.d.ts

@@ -4,21 +4,50 @@ export type LabelLabels = {
     /** Muted marker after the label text when `optional`. */
     optional: string;
 };
+export declare const LABEL_LABELS: LabelLabels;
 export type LabelRootProps = Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "size"> & {
+    /**
+     * Disabled color for the text and the markers, `aria-disabled`. A disabled `Fieldset` around the label sets it too.
+     */
     disabled?: boolean;
-    /** Tier. Default: the tier of the surrounding control (a form, a panel), else `m`. */
+    /**
+     * Size of the paired field: xs/s 12/16 · m 13/20 · l/xl 14/20, weight 500. Without it the tier of its host, else `m`; the label provides its tier to the icons inside.
+     */
     size?: ControlSize;
-    /** Appends a red `*` (decorative, `aria-hidden`). Put native `required` on the control itself. */
+    /**
+     * Appends a red `*` (`aria-hidden`). Put native `required` on the control itself.
+     */
     required?: boolean;
-    /** Appends the muted optional marker (`labels.optional`). */
+    /**
+     * Appends the muted optional marker (`labels.optional`).
+     */
     optional?: boolean;
+    /**
+     * Quieter: secondary text on one line, cut with an ellipsis — a column heading under the group's own label (FieldList).
+     */
+    secondary?: boolean;
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<LabelLabels>;
     ref?: React.Ref<HTMLLabelElement>;
 };
-declare function LabelRoot({ className, disabled, children, size: sizeProp, required, optional, labels, ref, ...rest }: LabelRootProps): import("react/jsx-runtime").JSX.Element;
+declare function LabelRoot({ className, disabled: disabledProp, children, size: sizeProp, required, optional, secondary, labels: labelsProp, ref, ...rest }: LabelRootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace LabelRoot {
     var displayName: string;
 }
+/**
+ * The marks after a field name: the red `*` of a required field (decorative, `aria-hidden`; the
+ * control carries `required`) or the muted optional marker (visible text, part of the name). The
+ * one copy of the kit — Label and the choice rows (Checkbox, Switch) draw them. Inside a Label the
+ * marks dim with it; elsewhere `disabled` dims them.
+ */
+export declare function LabelMarks({ required, optional, optionalLabel, disabled, }: {
+    required?: boolean;
+    optional?: boolean;
+    optionalLabel: string;
+    disabled?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
 export type LabelIconProps = React.HTMLAttributes<HTMLSpanElement> & {
     ref?: React.Ref<HTMLSpanElement>;
 };

package/dist/components/link-button/LinkButton.d.ts

@@ -1,20 +1,50 @@
 import type * as React from "react";
 import type { ControlSize, Tone } from "../../internal/states";
-export type LinkButtonProps = React.AnchorHTMLAttributes<HTMLAnchorElement> & {
-    /** Tier. Default: the tier of the surrounding control or text host, else `m`. */
+type LinkButtonBaseProps = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    /**
+     * Control tier: text 12 · 13 · 14 · 16 · 18, line height and icon size. Without it the tier of its host (a form, a panel, a hint), else `m`.
+     */
     size?: ControlSize;
-    /** `accent` — a regular link; `neutral` — quiet links in footers, metadata and dense navigation. */
-    tone?: Extract<Tone, "accent" | "neutral">;
-    disabled?: boolean;
     /**
-     * Merges the link look onto its single child instead of rendering `<a>`: a router link, or a
-     * `<button type="button">` for an inline action that is not navigation («выберите файл»).
-     * `disabled` becomes `aria-disabled` and swallows the click.
+     * `accent` — a regular link; `neutral` — secondary text for footers and metadata; `muted` — muted text with no underline, for trails such as a breadcrumb.
+     */
+    tone?: Extract<Tone, "accent" | "neutral"> | "muted";
+    /**
+     * A link inside running text: it takes the text's type, wraps with it and keeps its underline drawn.
      */
-    asChild?: boolean;
+    inline?: boolean;
+    /**
+     * Renders `<a role="link" aria-disabled="true">` without `href`, out of the Tab order, and swallows the click; `id`, `aria-*` and the other native props stay.
+     */
+    disabled?: boolean;
     ref?: React.Ref<HTMLAnchorElement>;
 };
-export declare function LinkButton({ size: sizeProp, tone, disabled: disabledProp, asChild, children, className, href, onClick, ref, ...rest }: LinkButtonProps): import("react/jsx-runtime").JSX.Element;
+/** A link has a URL; with `asChild` the child (a router link, a `<button>`) owns its target. */
+export type LinkButtonProps = LinkButtonBaseProps & ({
+    /**
+     * Merges the link look onto its single child instead of rendering `<a>`: a router link, or a `<button type="button">` for an inline action that is not navigation.
+     */
+    asChild?: false;
+    /**
+     * The destination. Required without `asChild`; with `asChild` the child carries its own target.
+     */
+    href: string;
+} | {
+    /**
+     * Merges the link look onto its single child instead of rendering `<a>`: a router link, or a `<button type="button">` for an inline action that is not navigation.
+     */
+    asChild: true;
+    /**
+     * The destination. Required without `asChild`; with `asChild` the child carries its own target.
+     */
+    href?: never;
+    /**
+     * Text and optional `Icon`s before or after it; the text is the accessible name. With `asChild`, the one child element.
+     */
+    children: React.ReactElement;
+});
+export declare function LinkButton({ size: sizeProp, tone, inline, disabled: disabledProp, asChild, children, className, href, ref, ...rest }: LinkButtonProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace LinkButton {
     var displayName: string;
 }
+export {};

package/dist/components/list/List.d.ts

@@ -4,40 +4,47 @@ export type ListLabels = {
     /** `aria-label` of a row's drag handle (`onReorder`); `{label}` is the row's text. */
     reorderItem: string;
 };
+export declare const LIST_LABELS: ListLabels;
 export type ListRootProps = Omit<React.HTMLAttributes<HTMLUListElement>, "children"> & {
-    /** Row tier: height, text, icon and avatar size; counts take one tier down. Default `m`. */
+    /**
+     * Row tier: height, text, icon and avatar size; counts take one tier down. Without it the tier of its host, else `m`.
+     */
     size?: ControlSize;
     /**
-     * Rows reorder by a leading handle (drag, a touch hold, Alt + ↑ / ↓): the row `id` now stands
-     * in front of `beforeId` (`List.Item` `value`s; `null` — last). Apply it with `moveBefore`.
-     * Return a promise to save on a server: the row stays in its new place with a busy handle, a
-     * rejection moves it back. Every `List.Item` then needs a `value`.
+     * Rows reorder by a leading handle (drag, touch hold, Alt + ↑ / ↓): item `value` `id` goes before `beforeId` (`null` = last). Apply with `moveBefore`; a returned promise keeps the row busy, a rejection moves it back.
      */
     onReorder?: (id: string, beforeId: string | null) => void | Promise<void>;
-    /** Built-in strings. */
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<ListLabels>;
-    /** `List.Item`s. */
+    /**
+     * `List.Item`s.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLUListElement>;
 };
 /**
- * A selectable navigation list: the master half of a list + detail screen (conversations, tickets,
- * mail, records). Rows are buttons or links; the open record is `current`.
+ * A selectable navigation list: the master half of a list + detail screen (tickets, mail,
+ * records). Rows are buttons or links; the open record is `current`; rows the data adds or takes
+ * out rise in and close up in place.
  */
-declare function ListRoot({ size, onReorder, labels, className, children, ...rest }: ListRootProps): import("react/jsx-runtime").JSX.Element;
+declare function ListRoot({ size: sizeProp, onReorder, labels, className, children, ...rest }: ListRootProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
 declare namespace ListRoot {
     var displayName: string;
 }
 export type ListItemIconProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
-    /** An `Avatar.Root` (sized by the row) or an `Icon`. */
+    /**
+     * An `Avatar.Root` or an `Icon`.
+     */
     children: React.ReactNode;
     ref?: React.Ref<HTMLSpanElement>;
 };
 /**
- * The leading picture of a row: an avatar the slot sizes to the tier, or an icon. After the text
- * it is a quiet trailing glyph. Decorative: the text names the row.
+ * The leading picture of a row: an avatar of the row tier, or an icon. After the text it is a
+ * quiet trailing glyph. Decorative: the text names the row.
  */
-declare function ListItemIcon({ className, ...rest }: ListItemIconProps): import("react/jsx-runtime").JSX.Element;
+declare function ListItemIcon({ className, children, ...rest }: ListItemIconProps): import("react/jsx-runtime").JSX.Element;
 declare namespace ListItemIcon {
     var displayName: string;
 }
@@ -66,11 +73,14 @@ declare namespace ListItemMeta {
     var displayName: string;
 }
 export type ListItemCountProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "color"> & {
-    /** Badge hue. Default `gray`; a hue for what needs attention (unread). */
+    /**
+     * Badge hue; a hue for what needs attention (unread).
+     */
     color?: PaletteColor;
-    /** The number (or a short status). */
+    /**
+     * The number or a short status.
+     */
     children: React.ReactNode;
-    /** The Badge `<span>`. */
     ref?: React.Ref<HTMLSpanElement>;
 };
 /** A count at the end of the row: a soft Badge one tier below the rows. */
@@ -79,32 +89,44 @@ declare namespace ListItemCount {
     var displayName: string;
 }
 type ListItemOwnProps = {
-    /** Stable id of the row; required in a reorderable list (`List.Root` `onReorder`). */
+    /**
+     * Stable id of the row; required in a reorderable list (`onReorder` reports it).
+     */
     value?: string;
     /**
-     * The open record: the selected fill and `aria-current` — `"true"` on a button, `"page"` on a
-     * link (`href`, `asChild`). Links rendered by a router may set it themselves.
+     * The open record: the selected fill and `aria-current` — `"true"` on a button, `"page"` on a link.
      */
     current?: boolean;
+    /**
+     * Muted and out of the Tab order: a disabled button, or `aria-disabled` and no navigation on a link.
+     */
     disabled?: boolean;
-    /** Render the single child element (a router link) as the row; its children are the content. */
+    /**
+     * Renders the single child (a router link) as the row; its children are the content.
+     */
     asChild?: boolean;
     /**
-     * Content and parts: `List.ItemIcon`, `List.ItemText`, `List.ItemDescription`, `List.ItemMeta`,
-     * `List.ItemCount`.
+     * `List.ItemIcon`, `List.ItemText`, `List.ItemDescription`, `List.ItemMeta`, `List.ItemCount`; loose text becomes the text line.
      */
     children?: React.ReactNode;
 };
 export type ListItemProps = ListItemOwnProps & Omit<React.ComponentPropsWithoutRef<"button">, keyof ListItemOwnProps> & {
-    /** Renders an `<a>` instead of a `<button>`. */
+    /**
+     * Renders an `<a>` instead of a `<button>`; dropped while `disabled`.
+     */
     href?: string;
+    /**
+     * Where the `<a>` opens (`href` only).
+     */
     target?: string;
+    /**
+     * Relationship of the `<a>` (`href` only).
+     */
     rel?: string;
-    /** The `<button>`, `<a>` or the `asChild` element (not the `<li>`). */
     ref?: React.Ref<HTMLElement>;
 };
 /** A row of the list: an `<li>` holding a full-width button or link. */
-declare function ListItem({ value, current, disabled, asChild, href, className, children, onClick, type, ref, ...rest }: ListItemProps): import("react/jsx-runtime").JSX.Element;
+declare function ListItem({ value, current, disabled, asChild, href, className, children, onClick, type, ref, target, rel, ...rest }: ListItemProps): import("react/jsx-runtime").JSX.Element;
 declare namespace ListItem {
     var displayName: string;
 }

package/dist/components/login-form/LoginForm.d.ts

@@ -1,25 +1,40 @@
-import type * as React from "react";
+import * as React from "react";
 import type { ControlSize } from "../../internal/states";
 export type LoginFormRootProps = {
-    /** Tier of spacing and type; fields and buttons inside without their own `size` take it. Default `m`. */
+    /**
+     * Tier of padding, gaps and text roles; every field and button inside without its own `size` takes it. Without it the form takes the tier of a sized host (a Modal).
+     */
     size?: ControlSize;
     /**
-     * Header layout. `start` (default): the Modal-header layout — a rounded accent tile on the left,
-     * title over description on its right. `center`: round logo above centered text.
+     * `start` — the Modal header layout (rounded accent tile left, title over description right); `center` — a round logo above centered text.
      */
     align?: "center" | "start";
-    /** Removes the card shadow, e.g. inside a modal or on a plain page. No border in either case. */
+    /**
+     * Removes the card shadow (inside a Modal or on a plain page). No border either way.
+     */
     flat?: boolean;
+    /**
+     * Class on the card.
+     */
     className?: string;
+    /**
+     * The parts: Header, Body.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLDivElement>;
 } & React.HTMLAttributes<HTMLDivElement>;
-declare function LoginFormRoot({ size, align, flat, className, children, ref, ...rest }: LoginFormRootProps): import("react/jsx-runtime").JSX.Element;
+declare function LoginFormRoot({ size: sizeProp, align, flat, className, children, ref, ...rest }: LoginFormRootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace LoginFormRoot {
     var displayName: string;
 }
 export type LoginFormHeaderProps = {
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * Logo, Title, Description.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLElement>;
 } & React.HTMLAttributes<HTMLElement>;
@@ -29,7 +44,13 @@ declare namespace LoginFormHeader {
     var displayName: string;
 }
 export type LoginFormLogoProps = {
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * The product mark or an `Icon`.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLDivElement>;
 } & React.HTMLAttributes<HTMLDivElement>;
@@ -43,9 +64,17 @@ declare namespace LoginFormLogo {
     var displayName: string;
 }
 export type LoginFormTitleProps = {
-    /** Heading element. Default `h1`; use `h2` when the form sits inside a page that already has an `h1`. */
+    /**
+     * Heading level; `h2` when the page already has an `h1`.
+     */
     as?: "h1" | "h2" | "h3";
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * The heading text.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLHeadingElement>;
 } & Omit<React.HTMLAttributes<HTMLHeadingElement>, "children">;
@@ -54,7 +83,13 @@ declare namespace LoginFormTitle {
     var displayName: string;
 }
 export type LoginFormDescriptionProps = {
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * The line text.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLParagraphElement>;
 } & Omit<React.HTMLAttributes<HTMLParagraphElement>, "children">;
@@ -63,7 +98,13 @@ declare namespace LoginFormDescription {
     var displayName: string;
 }
 export type LoginFormBodyProps = {
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * Actions, `Divider`, Form, Footer.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLDivElement>;
 } & React.HTMLAttributes<HTMLDivElement>;
@@ -73,7 +114,13 @@ declare namespace LoginFormBody {
     var displayName: string;
 }
 export type LoginFormFormProps = {
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * The fields and the Actions.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLFormElement>;
 } & React.FormHTMLAttributes<HTMLFormElement>;
@@ -83,7 +130,13 @@ declare namespace LoginFormForm {
     var displayName: string;
 }
 export type LoginFormActionsProps = {
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * The buttons.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLDivElement>;
 } & React.HTMLAttributes<HTMLDivElement>;
@@ -96,7 +149,13 @@ declare namespace LoginFormActions {
     var displayName: string;
 }
 export type LoginFormFooterProps = {
+    /**
+     * Class on the element.
+     */
     className?: string;
+    /**
+     * The line with a `LinkButton`.
+     */
     children?: React.ReactNode;
     ref?: React.Ref<HTMLParagraphElement>;
 } & Omit<React.HTMLAttributes<HTMLParagraphElement>, "children">;