@tailor-platform/app-shell 1.17.0 → 1.19.0

package/dist/app-shell.d.ts

@@ -124,7 +124,7 @@ declare interface ActionItem {
  * />
  * ```
  */
-export declare function ActionPanel({ title, actions, className }: ActionPanelProps): JSX.Element;
+export declare function ActionPanel({ title, actions, emptyContent, className }: ActionPanelProps): JSX.Element;
 
 /**
  * Props for the ActionPanel component.
@@ -134,6 +134,12 @@ export declare interface ActionPanelProps {
     title: string;
     /** List of actions to render */
     actions: ActionItem[];
+    /**
+     * Content shown with consistent padding when actions is empty. Defaults to a localized "No actions available" message.
+     * Strings use the default body text styling; other React nodes render unchanged.
+     * Pass null to hide the empty content and its additional vertical spacing while keeping the card and title.
+     */
+    emptyContent?: ReactNode;
     /** Additional CSS classes for the card container */
     className?: string;
 }
@@ -151,7 +157,7 @@ declare type ActionsProps = React_2.ComponentProps<"div">;
 export declare const ActivityCard: typeof ActivityCardStandalone & {
     Root: typeof Root_3;
     Items: typeof Items;
-    Item: typeof Item;
+    Item: typeof Item_2;
 };
 
 /**
@@ -239,6 +245,44 @@ export declare interface ActivityCardRootProps<T extends ActivityCardBaseItem> {
  */
 declare function ActivityCardStandalone({ items, title, maxVisible, overflowLabel, groupBy, className, }: ActivityCardProps): JSX.Element;
 
+/** A reusable aggregation over selected row values, optionally followed by a result transformation. */
+export declare type Aggregation<TRow, TResult = number | null> = (context: {
+    rows: readonly TRow[];
+}) => TResult;
+
+/**
+ * Create reusable callbacks over `{ rows }`, independent of UI and column definitions.
+ * Selectors choose each row's value; an optional transformer receives the final
+ * result once, including empty or invalid results. Neither callback should mutate rows.
+ */
+export declare const aggregations: {
+    /** Sum finite selected numbers. Empty input returns zero; invalid input returns null. */
+    sum: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Average non-nullish finite selected numbers; empty or invalid input returns null. */
+    avg: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Minimum finite selected number; empty or invalid input returns null. */
+    min: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Maximum finite selected number; empty or invalid input returns null. */
+    max: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Count non-nullish selected values, including zero, false, and empty strings. */
+    count: {
+        <TRow>(selector: (row: TRow) => unknown, transformer?: undefined): Aggregation<TRow, number>;
+        <TRow, TResult>(selector: (row: TRow) => unknown, transformer: (value: number) => TResult): Aggregation<TRow, TResult>;
+    };
+};
+
 export declare const AIChat: AIChatComponent;
 
 export declare type AIChatCompletionEvent = {
@@ -1012,6 +1056,20 @@ export declare const avatarVariants: (props?: ({
 
 export declare function Badge({ className, variant, children, ...props }: BadgeProps): JSX.Element;
 
+/**
+ * `edit` config for `type: "badge"` columns: a dropdown whose choices render as
+ * the same badges the cell shows. Picking one notifies its `value`; a "None"
+ * choice notifies `null`. Single-value columns only.
+ */
+export declare interface BadgeCellEditOptions<TRow extends Record<string, unknown>> extends CellEditBase<TRow, string> {
+    /**
+     * The choices. Default: the entries of `typeOptions.badgeLabelMap`, else the
+     * column's enum `filter` options. A badge column with neither can't be
+     * edited.
+     */
+    options?: readonly SelectOption[];
+}
+
 /** Options for `type: "badge"` cells. */
 declare interface BadgeCellOptions extends BadgeOptions {
     /** Maximum number of badges to display before showing a "+N" overflow indicator */
@@ -1046,7 +1104,7 @@ export declare interface BadgeProps extends React_2.HTMLAttributes<HTMLDivElemen
 export declare type BadgeVariant = NonNullable<BadgeProps["variant"]>;
 
 export declare const badgeVariants: (props?: ({
-    variant?: "default" | "error" | "success" | "warning" | "neutral" | "info" | "subtle-success" | "subtle-warning" | "subtle-error" | "subtle-info" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
+    variant?: "default" | "error" | "success" | "warning" | "neutral" | "info" | "subtle-success" | "subtle-warning" | "subtle-error" | "subtle-info" | "subtle-neutral" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export { Blocker }
@@ -1190,6 +1248,64 @@ declare namespace Cell {
 
 declare type CellAlign = "left" | "center" | "right";
 
+declare interface CellEditBase<TRow extends Record<string, unknown>, TValue, TDraft = TValue | null> {
+    /**
+     * Decides, per row, whether the cell can be edited. Receives the row and
+     * whether it is selected, so "editable once selected" is
+     * `(_, { selected }) => selected`. Default: every row with an `id`.
+     */
+    canEdit?: (row: TRow, state: CellEditState) => boolean;
+    /**
+     * Observes editor drafts, including incomplete input and restored drafts on
+     * cancellation. Direct inputs emit raw strings; choices emit selected values,
+     * not search text or highlights. Updating `data` here is outside the supported
+     * coordination contract. A failed change check retains its draft and blocks
+     * confirmation; pending change checks finish before `onValueCommitted` runs.
+     * Cancellation notifications cannot create a new cell error after discarding
+     * the draft. Pass `error: false` for unobserved callback behavior.
+     */
+    onValueChange?: (row: TRow, draft: TDraft) => void;
+    /**
+     * Attempts to confirm a changed editor output, compared with current `data`.
+     * Empty cells confirm `null`. A normal return or fulfilled Promise completes
+     * the edit; throw/rejection retains the draft and error for correction or retry.
+     * Focus may leave while pending. Update `data` here to adopt a successful value;
+     * DataTable does not persist or roll back consumer state. Output types follow
+     * the editor, not the row field's runtime type.
+     */
+    onValueCommitted: (row: TRow, value: TValue | null) => void;
+    /**
+     * Callback failures automatically open an error popover without moving focus.
+     * Only non-empty `CellEditError` messages are displayed by the standard UI;
+     * other failures use localized generic feedback. Translate messages before throwing.
+     * Pass `false` to disable interception and retain eager edit completion, or
+     * `render` to replace the popover's body. Closing the details retains the draft
+     * and error; reopen with the error icon or Alt+ArrowDown. Esc closes open details
+     * first, then restores current data and clears the error. The standard popover
+     * adds no reset action; custom content may include consumer-owned actions.
+     */
+    error?: false | {
+        render: (ctx: {
+            row: TRow;
+            error: unknown;
+        }) => ReactNode;
+    };
+}
+
+/**
+ * A cell-editing failure whose message is safe to display to the user.
+ * Translate the message before throwing; other errors use generic feedback.
+ */
+export declare class CellEditError extends globalThis.Error {
+    name: string;
+}
+
+/** Row state passed to `edit.canEdit` alongside the row. */
+export declare interface CellEditState {
+    /** Whether the row is selected. Always `false` when row selection is off. */
+    selected: boolean;
+}
+
 declare type CellProps = React_2.ComponentProps<"td"> & {
     align?: CellAlign;
 };
@@ -1630,6 +1746,17 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
      * across spread-then-override patterns like `column({ ...inferred, render })`.
      */
     render?: (row: TRow) => ReactNode;
+    /**
+     * Sets `className`, `style`, and `title` on the data cell's `<td>`, including
+     * its padding, based on the row. Return `undefined` to keep the defaults.
+     * Classes are merged with the built-in classes; CSS specificity still applies.
+     * An inline `style.backgroundColor` remains visible during row hover and
+     * selection, including on pinned cells. Use an opaque background for pinned
+     * cells to prevent content bleeding through. Column `width` and sticky
+     * positioning take precedence over `style`. Content stays owned by `render`;
+     * events, refs, and cell spanning are not configurable through this hook.
+     */
+    cellProps?: (row: TRow) => Pick<ComponentProps<"td">, "className" | "style" | "title"> | undefined;
     /**
      * Custom header renderer.
      *
@@ -1642,6 +1769,40 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
      * still driven by `label`, `sort`, and other column metadata.
      */
     header?: (ctx: HeaderRenderContext) => ReactNode;
+    /**
+     * Sets `className`, `style`, and `title` on this column's header `<th>`.
+     * Receives the same context as `header`; return `undefined` to keep the defaults.
+     * Classes are merged with the built-in classes; column `width` and sticky
+     * positioning take precedence over `style`. Use an opaque background for
+     * pinned headers. Content stays owned by `header` or the default renderer;
+     * sorting and context-menu behavior are unchanged. Built-in selection,
+     * expansion, and action headers are not affected.
+     */
+    headerProps?: (ctx: HeaderRenderContext) => Pick<ComponentProps<"th">, "className" | "style" | "title"> | undefined;
+    /**
+     * Content for this column's cell in a sticky table footer: a static string
+     * or a renderer receiving the current `data.rows` (the current page, not all
+     * records or only selected rows). `type` and `typeOptions` do not apply.
+     *
+     * A footer row appears when any visible column defines a footer, including
+     * an empty string. Columns without one leave a blank cell; hidden columns'
+     * callbacks are not called.
+     * Loading keeps the footer row with skeletons without calling renderers.
+     * Hidden during errors; loaded empty data receives `rows: []`.
+     * Separate from `DataTable.Footer`, the pagination / bulk-action container.
+     */
+    footer?: string | ((ctx: FooterRenderContext<TRow>) => ReactNode);
+    /**
+     * Sets `className`, `style`, and `title` on this column's footer `<td>`.
+     * Receives the same context as `footer`; return `undefined` to keep the defaults.
+     * Classes are merged with the built-in classes; column `width` and sticky
+     * positioning take precedence over `style`. Use an opaque background for
+     * pinned footer cells. Content stays owned by `footer`; events, refs, and
+     * cell spanning are not configurable through this hook.
+     * Does not create a footer row by itself. Not called while loading, on errors,
+     * or for hidden columns. Built-in utility footer cells are not affected.
+     */
+    footerProps?: (ctx: FooterRenderContext<TRow>) => Pick<ComponentProps<"td">, "className" | "style" | "title"> | undefined;
     /**
      * Stable identifier used for column visibility toggling, persisted layout
      * state, raw-value fallback (`row[col.id]`), and as the React key. Falls
@@ -1806,6 +1967,12 @@ declare type Columns = 3 | 4;
  * and `undefined` are always allowed: every built-in renderer maps them to the
  * `—` placeholder.
  *
+ * `edit` makes the cells editable in place and also narrows per branch, so
+ * `onValueCommitted` receives the editor's output type, not necessarily the
+ * original row field's runtime type. Text / link / badge output strings or null.
+ * Every typed column
+ * supports it; untyped (`render`-only) columns don't.
+ *
  * Prefer `Column<TRow>` in most cases; this is exported so consumers can
  * compose more specific column types.
  */
@@ -1813,30 +1980,37 @@ declare type ColumnTypeBranch<TRow extends Record<string, unknown>> = {
     type?: undefined;
     typeOptions?: never;
     accessor?: (row: TRow) => unknown;
+    edit?: never;
 } | {
     type: "text";
     typeOptions?: never;
     accessor?: (row: TRow) => string | number | boolean | bigint | null | undefined;
+    edit?: TextCellEditOptions<TRow>;
 } | {
     type: "number";
     typeOptions?: NumberCellOptions;
     accessor?: (row: TRow) => number | null | undefined;
+    edit?: NumberCellEditOptions<TRow>;
 } | {
     type: "money";
     typeOptions?: MoneyCellOptions<TRow>;
     accessor?: (row: TRow) => number | null | undefined;
+    edit?: NumberCellEditOptions<TRow>;
 } | {
     type: "date";
     typeOptions?: DateCellOptions;
     accessor?: (row: TRow) => Date | string | number | null | undefined;
+    edit?: DateCellEditOptions<TRow>;
 } | {
     type: "badge";
     typeOptions?: BadgeCellOptions;
     accessor?: (row: TRow) => string | string[] | number | boolean | null | undefined;
+    edit?: BadgeCellEditOptions<TRow>;
 } | {
     type: "link";
     typeOptions: LinkCellOptions<TRow>;
     accessor?: (row: TRow) => string | number | boolean | null | undefined;
+    edit?: TextCellEditOptions<TRow>;
 };
 
 export declare const Combobox: ComboboxComponent;
@@ -2303,11 +2477,15 @@ export declare type ContextData = AppShellRegister extends {
 } ? T : Record<string, unknown>;
 
 /**
- * A styled input control for the field.
+ * A styled text input for the field.
  *
- * Can be omitted when using another Base UI-backed AppShell input component
- * (e.g. Select, Combobox, Autocomplete) as a sibling — those components
- * register themselves with the Field context automatically.
+ * Use it for plain text-like inputs, or pass a native element to `render`
+ * (e.g. `render={<textarea />}`). `Select`, `Combobox`, `Autocomplete`,
+ * `Checkbox`, `Textarea`, `DateField`, `DatePicker` and `DateRangePicker` go
+ * directly under `Field.Root` instead: each draws its own frame and registers
+ * with the Field context itself. Passing one to `render` draws a second frame
+ * and logs a warning. `Input` does not connect to `Field.Root` — use
+ * `Field.Control` in its place inside a field.
  */
 declare function Control({ className, ...props }: React_2.ComponentProps<typeof Field_2.Control>): JSX.Element;
 
@@ -2628,7 +2806,8 @@ export declare const DataTable: {
     /** Built-in column visibility, ordering, and pinning controls. */
     readonly ColumnSettings: typeof DataTableColumnSettings;
     /**
-     * Renders `<table>` with built-in `Headers` and `Body`.
+     * Renders `<table>` with built-in headers, body, and a sticky footer row
+     * when a visible column defines `footer`.
      * Place inside `DataTable.Root`.
      */
     readonly Table: typeof DataTableTable;
@@ -2928,6 +3107,16 @@ declare type DataTableUiFilterOperatorByType = {
 
 declare type DataTableUuidFilterOperator = Extract<OperatorForFilterType["uuid"], "eq">;
 
+/**
+ * `edit` config for `type: "date"` columns: a calendar that opens from the
+ * cell. Picking a day commits `"YYYY-MM-DD"`. With `dateFormat: "datetime"`
+ * the calendar emits complete `DateTimeDraft` snapshots and Done confirms an
+ * ISO 8601 timestamp in the AppShell timezone only with a valid day and time.
+ * Outside closing / Esc cancels; Clear explicitly confirms `null`.
+ * Date-only drafts are `"YYYY-MM-DD" | null`.
+ */
+export declare type DateCellEditOptions<TRow extends Record<string, unknown>> = CellEditBase<TRow, string, string | DateTimeDraft | null>;
+
 /** Options for `type: "date"` cells. */
 declare interface DateCellOptions {
     /**
@@ -3116,6 +3305,12 @@ declare type DateSection<TField extends string = string> = FieldSectionBase<TFie
     max?: string;
 };
 
+/** Incomplete date-time editor state, interpreted in the AppShell timezone. */
+export declare interface DateTimeDraft {
+    day: string | null;
+    time: string | null;
+}
+
 export { DateValue }
 
 /**
@@ -3634,6 +3829,23 @@ declare type DynamicLocales<Def extends Record<string, LabelValue>> = {
     [locale: string]: Partial<LabelDefinition<Def>> | undefined;
 };
 
+/**
+ * The role each element component applies when no `variant` is given. They
+ * follow `defaultTagNames`: body roles render `p`, label roles render `span`.
+ * `div` is a block element like `p`, so it gets the default role of `Text`.
+ */
+declare const elementDefaultVariants: {
+    readonly h1: "heading-lg";
+    readonly h2: "heading-md";
+    readonly h3: "heading-sm";
+    readonly h4: "heading-sm";
+    readonly h5: "heading-sm";
+    readonly h6: "heading-sm";
+    readonly p: "body-md";
+    readonly span: "label-md";
+    readonly div: "body-md";
+};
+
 /**
  * Behavior when a field value is empty/null/undefined
  */
@@ -4157,6 +4369,12 @@ declare namespace Footer_3 {
     var displayName: string;
 }
 
+/** Context passed to custom column `footer` renderers and `footerProps` callbacks. */
+export declare interface FooterRenderContext<TRow extends Record<string, unknown>> {
+    /** Current `data.rows` (the current page, not all records or only selected rows). */
+    rows: readonly TRow[];
+}
+
 /**
  * A form element with consolidated error handling and validation.
  *
@@ -4481,17 +4699,20 @@ export declare interface GridProps extends React_2.ComponentProps<"div"> {
     justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
 }
 
+/** An expandable group with optional separation of its heading action and expand control. */
+declare function Group({ title, icon, render, isActive, onClick, expandOnClick, defaultOpen, children, ...props }: GroupProps): JSX.Element;
+
 /** Groups related menu items with the corresponding label. */
-declare function Group({ ...props }: React_2.ComponentProps<typeof Menu_2.Group>): JSX.Element;
+declare function Group_2({ ...props }: React_2.ComponentProps<typeof Menu_2.Group>): JSX.Element;
 
-declare namespace Group {
+declare namespace Group_2 {
     var displayName: string;
 }
 
 /** A related group of controls within a toolbar row. */
-declare function Group_2({ className, ...props }: ToolbarGroupProps): JSX.Element;
+declare function Group_3({ className, ...props }: ToolbarGroupProps): JSX.Element;
 
-declare namespace Group_2 {
+declare namespace Group_3 {
     var displayName: string;
 }
 
@@ -4502,6 +4723,23 @@ declare namespace GroupLabel {
     var displayName: string;
 }
 
+declare type GroupProps = Omit<React_2.ComponentProps<"li">, "title" | "onClick"> & {
+    /** Group label with meaningful accessible text; do not nest interactive elements. */
+    title: React_2.ReactNode;
+    icon?: React_2.ReactNode;
+    /** Replaces the main heading operation without changing expansion behavior. */
+    render?: React_2.ReactElement;
+    isActive?: boolean;
+    /** Runs only for the heading operation, not children or a separate expand button. */
+    onClick?: React_2.MouseEventHandler<HTMLButtonElement>;
+    /** Whether clicking the heading toggles the child list; false requires an operation. @default true */
+    expandOnClick?: boolean;
+    /** Whether the child list starts expanded. @default true */
+    defaultOpen?: boolean;
+} & ({
+    expandOnClick?: true;
+} | RequiredOperation);
+
 /**
  * Guard function type.
  * Guards are executed in order and stop on the first non-pass result.
@@ -4640,7 +4878,7 @@ declare type HeaderProps_2 = {
 };
 
 /**
- * Context passed to custom `header` renderers.
+ * Context passed to custom `header` renderers and `headerProps` callbacks.
  */
 export declare type HeaderRenderContext = NonSortableHeaderRenderContext | SortableHeaderRenderContext;
 
@@ -4734,16 +4972,19 @@ declare namespace Interval {
  */
 declare type IsEmptyObject<T> = keyof T extends never ? true : false;
 
-declare function Item({ indicator, children, className }: ActivityCardItemProps): JSX.Element;
+/** A compact link or action row. No AppShell, router, or Sidebar provider is required. */
+declare function Item({ icon, children, disabled, render, tabIndex, className, ...props }: ItemProps): JSX.Element;
 
-declare namespace Item {
+declare function Item_2({ indicator, children, className }: ActivityCardItemProps): JSX.Element;
+
+declare namespace Item_2 {
     var displayName: string;
 }
 
 /** An individual interactive item in the menu. */
-declare function Item_2({ className, ...props }: React_2.ComponentProps<typeof Menu_2.Item>): JSX.Element;
+declare function Item_3({ className, ...props }: React_2.ComponentProps<typeof Menu_2.Item>): JSX.Element;
 
-declare namespace Item_2 {
+declare namespace Item_3 {
     var displayName: string;
 }
 
@@ -4759,6 +5000,24 @@ export declare interface ItemGroup<T> {
     items: T[];
 }
 
+/** Compact icon-and-label lists with links, actions, groups, sections, and separators. */
+export declare const ItemList: {
+    Root: typeof ListRoot;
+    Item: typeof Item;
+    Group: typeof Group;
+    Section: typeof Section;
+    Separator: typeof Separator;
+};
+
+declare type ItemProps = React_2.ComponentProps<"button"> & {
+    /** Optional decorative leading icon. */
+    icon?: React_2.ReactNode;
+    /** Visual emphasis only; aria-current="page" also supplies active styling. */
+    isActive?: boolean;
+    /** Replaces the inner button, not the containing list item. */
+    render?: React_2.ReactElement;
+} & RequiredOperation;
+
 declare function Items<T extends ActivityCardBaseItem>({ children }: ActivityCardItemsProps<T>): JSX.Element;
 
 declare namespace Items {
@@ -4941,6 +5200,8 @@ declare namespace List {
     var displayName: string;
 }
 
+declare function ListRoot({ className, ...props }: React_2.ComponentProps<"ul">): JSX.Element;
+
 declare type LoaderHandler = (args: LoaderFunctionArgs) => Promise<unknown> | unknown;
 
 declare type LocalizedString = string | ((locale: string) => string);
@@ -4966,14 +5227,14 @@ export declare const Menu: {
     Root: typeof Root_10;
     Trigger: typeof Trigger_3;
     Content: typeof Content_4;
-    Item: typeof Item_2;
+    Item: typeof Item_3;
     LinkItem: typeof LinkItem;
     CheckboxItem: typeof CheckboxItem;
     CheckboxItemIndicator: typeof CheckboxItemIndicator;
     RadioItem: typeof RadioItem;
     RadioItemIndicator: typeof RadioItemIndicator;
     RadioGroup: typeof RadioGroup;
-    Group: typeof Group;
+    Group: typeof Group_2;
     GroupLabel: typeof GroupLabel;
     Separator: typeof MenuSeparator;
     SubmenuRoot: typeof SubmenuRoot;
@@ -5161,6 +5422,16 @@ declare interface NonSortableHeaderRenderContext {
     sortable: false;
 }
 
+/**
+ * `edit` config for `type: "number"` and `type: "money"` columns. Drafts are raw
+ * strings (including incomplete input); confirmation emits a JavaScript number
+ * or `null`, not an arbitrary-precision Decimal. Editing uses `.` as the decimal
+ * separator, independently of display locale. Full-width digits and valid comma
+ * grouping are normalized on confirmation. Display precision does not constrain
+ * input; business rules belong to the consumer.
+ */
+export declare type NumberCellEditOptions<TRow extends Record<string, unknown>> = CellEditBase<TRow, number, string>;
+
 /** Options for `type: "number"` cells. */
 declare interface NumberCellOptions {
     /** Minimum decimal places. Default: `0`. */
@@ -5182,6 +5453,8 @@ declare type NumberRangeSection<TField extends string = string> = FieldSectionBa
     unit?: ReactNode;
 };
 
+declare type NumericValue = number | null | undefined;
+
 export declare type OpenCommandPaletteOptions = {
     /** Optional initial text to prefill into the palette input. */
     search?: string;
@@ -5515,6 +5788,12 @@ declare type ReasoningTriggerProps = Omit<ComponentProps<typeof DisclosureTrigge
  */
 export declare const redirectTo: (to: string) => GuardResult;
 
+declare type RequiredOperation = {
+    onClick: React_2.MouseEventHandler<HTMLButtonElement>;
+} | {
+    render: React_2.ReactElement;
+};
+
 /** Color theme after resolving `system` to a concrete value. */
 export declare type ResolvedColorTheme = "light" | "dark";
 
@@ -6075,6 +6354,9 @@ export declare type SearchSource = {
     }) => Promise<CommandPaletteSearchResult[]>;
 };
 
+/** A static heading and a flat list, without group indentation or an expand control. */
+declare function Section({ title, children, className, ...props }: SectionProps): JSX.Element;
+
 declare type SectionBase = {
     /** Stable and unique within the rail. Keys the layout and a11y ids. */
     id: string;
@@ -6090,6 +6372,10 @@ declare type SectionBase = {
     defaultCollapsed?: boolean;
 };
 
+declare type SectionProps = Omit<React_2.ComponentProps<"li">, "title"> & {
+    title: string;
+};
+
 /** Every section, in the user's layout. Scrolls; the header stays put. */
 declare function Sections({ className }: SectionsProps): JSX.Element;
 
@@ -6380,10 +6666,13 @@ declare namespace SelectValue {
     var displayName: string;
 }
 
+/** A decorative divider that remains a valid child of a list. */
+declare function Separator({ className, ...props }: Omit<React_2.ComponentProps<"li">, "children">): JSX.Element;
+
 /** A vertical separator for groups within a horizontal toolbar row. */
-declare function Separator({ className, ...props }: ToolbarSeparatorProps): JSX.Element;
+declare function Separator_2({ className, ...props }: ToolbarSeparatorProps): JSX.Element;
 
-declare namespace Separator {
+declare namespace Separator_2 {
     var displayName: string;
 }
 
@@ -7193,6 +7482,28 @@ declare type TabsSize = "xs" | "sm" | "default" | "lg";
 
 declare type TabsVariant = "default" | "line" | "capsule";
 
+/**
+ * Text with a typography role. The role sets the size, line height, weight,
+ * and letter spacing. It does not set the color or choose the heading level.
+ *
+ * `Text.h1` to `Text.h6`, `Text.p`, `Text.span`, and `Text.div` always render
+ * their named element, with a default role for that element. They take
+ * `variant`, the element's own attributes, and a ref, but not `render`.
+ *
+ * @example
+ * ```tsx
+ * import { Text } from "@tailor-platform/app-shell";
+ *
+ * <Text.h1>Purchase orders</Text.h1>
+ * <Text.h3 variant="heading-md">Line items</Text.h3>
+ * <Text.p className="text-muted-foreground">Orders sent this month.</Text.p>
+ * <Text.span className="tabular-nums">1,240</Text.span>
+ * <Text variant="label-md" render={<CustomLabel />}>Quantity</Text>
+ * ```
+ */
+declare const Text_2: TextComponent;
+export { Text_2 as Text }
+
 /**
  * A styled multi-line text input.
  *
@@ -7254,6 +7565,50 @@ export declare type TextareaProps = Omit<React_2.ComponentProps<typeof Field_2.C
     className?: string;
 };
 
+/**
+ * `edit` config for `type: "text"` and `type: "link"` columns. Without
+ * `options` the cell is typed into: the value is the text as typed, and an
+ * emptied cell commits `null`. A `link` column shows its label as plain text
+ * while the cell can be edited.
+ */
+export declare interface TextCellEditOptions<TRow extends Record<string, unknown>> extends CellEditBase<TRow, string, string | null> {
+    /**
+     * Turns the cell into a dropdown of these choices (a supplier, a warehouse,
+     * a unit of measure). The column's value is an option's `value`, and every
+     * cell in the column — editable or not — shows the matching `label`.
+     * Picking a choice notifies its value; a "None" choice notifies `null`.
+     */
+    options?: readonly SelectOption[];
+}
+
+/**
+ * Keep the exported static API type explicit instead of relying on
+ * `Object.assign(...)` inference, as `Layout` and `Autocomplete` do.
+ */
+declare type TextComponent = typeof TextRoot & {
+    [T in TextTagName]: TextElementComponent<T>;
+};
+
+declare type TextElementComponent<T extends TextTagName> = {
+    (props: TextElementProps<T>): React_2.JSX.Element;
+    displayName?: string;
+};
+
+declare type TextElementProps<T extends TextTagName> = React_2.ComponentProps<T> & VariantProps<typeof textVariants>;
+
+export declare type TextProps = React_2.HTMLAttributes<HTMLElement> & VariantProps<typeof textVariants> & {
+    /** Ref to the rendered element. */
+    ref?: React_2.Ref<HTMLElement>;
+    /** Custom element to render as (Base UI render prop). Use it to compose with another component. For a plain HTML element, use `Text.h1` to `Text.h6`, `Text.p`, `Text.span`, or `Text.div`. */
+    render?: React_2.ReactElement;
+};
+
+declare function TextRoot({ className, variant, render, children, ref, ...props }: TextProps): React_2.ReactElement<unknown, string | React_2.JSXElementConstructor<any>>;
+
+declare namespace TextRoot {
+    var displayName: string;
+}
+
 /** Free text with one fixed operator. */
 declare type TextSection<TField extends string = string> = FieldSectionBase<TField> & {
     control: "text";
@@ -7265,6 +7620,12 @@ declare type TextSection<TField extends string = string> = FieldSectionBase<TFie
     minLength?: number;
 };
 
+declare type TextTagName = keyof typeof elementDefaultVariants;
+
+declare const textVariants: (props?: ({
+    variant?: "heading-lg" | "heading-md" | "heading-sm" | "body-md" | "body-sm" | "label-md" | "label-sm" | "code-sm" | "body-md-relaxed" | "body-sm-relaxed" | null | undefined;
+} & ClassProp) | undefined) => string;
+
 export { Time }
 
 /**
@@ -7671,8 +8032,8 @@ declare function Tool({ className, children, ...props }: ToolProps): JSX.Element
 export declare const Toolbar: {
     Root: typeof Root_13;
     Row: typeof Row_2;
-    Group: typeof Group_2;
-    Separator: typeof Separator;
+    Group: typeof Group_3;
+    Separator: typeof Separator_2;
 };
 
 declare type ToolbarGroupProps = React_2.ComponentProps<"div">;
@@ -8959,7 +9320,7 @@ export declare function useURLCollectionVariables(options: UseCollectionOptions
  *   <Field.Validity>
  *     {(state) =>
  *       state.validity.valid === false && (
- *         <p className="text-destructive text-sm">
+ *         <p className="text-danger-text text-sm">
  *           {state.validity.typeMismatch
  *             ? "Please enter a valid URL (e.g. https://example.com)"
  *             : "This field is required."}
@@ -9087,37 +9448,37 @@ declare namespace Root {
 }
 
 
-declare namespace Viewport {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace Body {
     var displayName: string;
 }
 
 
-declare namespace Interval {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace TimelineLink {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Head {
     var displayName: string;
 }
 
 
-declare namespace Image {
+declare namespace Cell {
     var displayName: string;
 }
 
 
-declare namespace Fallback {
+declare namespace Caption {
     var displayName: string;
 }
 
@@ -9127,37 +9488,17 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
-    var displayName: string;
-}
-
-
-declare namespace Body {
-    var displayName: string;
-}
-
-
-declare namespace Footer {
-    var displayName: string;
-}
-
-
-declare namespace Row {
-    var displayName: string;
-}
-
-
-declare namespace Head {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace Cell {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace Caption {
+declare namespace TextRoot {
     var displayName: string;
 }
 
@@ -9167,52 +9508,52 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
+declare namespace Image {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Fallback {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace SelectRoot {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace SelectTrigger {
     var displayName: string;
 }
 
 
-declare namespace Close {
+declare namespace SelectValue {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace SelectContent {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace SelectItem {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace SelectGroup {
     var displayName: string;
 }
 
 
-declare namespace Title {
+declare namespace SelectGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace SelectSeparator {
     var displayName: string;
 }
 
@@ -9222,92 +9563,92 @@ declare namespace Root {
 }
 
 
-declare namespace Legend {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace ComboboxRoot {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInput {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace ComboboxTrigger {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInputGroup {
+declare namespace Close {
     var displayName: string;
 }
 
 
-declare namespace ComboboxContent {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace ComboboxList {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace ComboboxItem {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace ComboboxEmpty {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroup {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroupLabel {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace ComboboxClear {
+declare namespace Label {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChips {
+declare namespace Control {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChip {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChipRemove {
+declare namespace Error {
     var displayName: string;
 }
 
 
-declare namespace ComboboxValue {
+declare namespace Validity {
     var displayName: string;
 }
 
 
-declare namespace ComboboxStatus {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace ComboboxCollection {
+declare namespace Legend {
     var displayName: string;
 }
 
@@ -9317,182 +9658,182 @@ declare namespace Root {
 }
 
 
-declare namespace Label {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace Control {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace Item {
     var displayName: string;
 }
 
 
-declare namespace Error {
+declare namespace LinkItem {
     var displayName: string;
 }
 
 
-declare namespace Validity {
+declare namespace CheckboxItem {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace CheckboxItemIndicator {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace RadioItem {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace RadioItemIndicator {
     var displayName: string;
 }
 
 
-declare namespace Item {
+declare namespace RadioGroup {
     var displayName: string;
 }
 
 
-declare namespace LinkItem {
+declare namespace Group {
     var displayName: string;
 }
 
 
-declare namespace CheckboxItem {
+declare namespace GroupLabel {
     var displayName: string;
 }
 
 
-declare namespace CheckboxItemIndicator {
+declare namespace MenuSeparator {
     var displayName: string;
 }
 
 
-declare namespace RadioItem {
+declare namespace SubmenuRoot {
     var displayName: string;
 }
 
 
-declare namespace RadioItemIndicator {
+declare namespace SubmenuTrigger {
     var displayName: string;
 }
 
 
-declare namespace RadioGroup {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Group {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace GroupLabel {
+declare namespace Close {
     var displayName: string;
 }
 
 
-declare namespace MenuSeparator {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace SubmenuRoot {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace SubmenuTrigger {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace Group {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Separator {
+declare namespace List {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Tab {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace Panel {
     var displayName: string;
 }
 
 
-declare namespace Close {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace Group {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace Separator {
     var displayName: string;
 }
 
 
-declare namespace Title {
+declare namespace Provider {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace List {
+declare namespace ClearAll {
     var displayName: string;
 }
 
 
-declare namespace Tab {
+declare namespace Sections {
     var displayName: string;
 }
 
 
-declare namespace Panel {
+declare namespace Provider {
     var displayName: string;
 }
 
@@ -9502,12 +9843,12 @@ declare namespace Root {
 }
 
 
-declare namespace Title {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace Content {
     var displayName: string;
 }
 
@@ -9522,87 +9863,87 @@ declare namespace Settings {
 }
 
 
-declare namespace Provider {
+declare namespace ComboboxRoot {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxInput {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace ComboboxTrigger {
     var displayName: string;
 }
 
 
-declare namespace ClearAll {
+declare namespace ComboboxInputGroup {
     var displayName: string;
 }
 
 
-declare namespace Sections {
+declare namespace ComboboxContent {
     var displayName: string;
 }
 
 
-declare namespace Provider {
+declare namespace ComboboxList {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxItem {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace ComboboxEmpty {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace ComboboxGroup {
     var displayName: string;
 }
 
 
-declare namespace SelectRoot {
+declare namespace ComboboxGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace SelectTrigger {
+declare namespace ComboboxClear {
     var displayName: string;
 }
 
 
-declare namespace SelectValue {
+declare namespace ComboboxChips {
     var displayName: string;
 }
 
 
-declare namespace SelectContent {
+declare namespace ComboboxChip {
     var displayName: string;
 }
 
 
-declare namespace SelectItem {
+declare namespace ComboboxChipRemove {
     var displayName: string;
 }
 
 
-declare namespace SelectGroup {
+declare namespace ComboboxValue {
     var displayName: string;
 }
 
 
-declare namespace SelectGroupLabel {
+declare namespace ComboboxStatus {
     var displayName: string;
 }
 
 
-declare namespace SelectSeparator {
+declare namespace ComboboxCollection {
     var displayName: string;
 }
 
@@ -9707,6 +10048,31 @@ declare namespace Root {
 }
 
 
+declare namespace Viewport {
+    var displayName: string;
+}
+
+
+declare namespace Row {
+    var displayName: string;
+}
+
+
+declare namespace Interval {
+    var displayName: string;
+}
+
+
+declare namespace TimelineLink {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
 declare namespace Items {
     var displayName: string;
 }