@tailor-platform/app-shell 1.18.0 → 1.20.0

package/dist/app-shell.d.ts

@@ -49,6 +49,7 @@ import { ReactNode } from 'react';
 import { Ref } from 'react';
 import { RefObject } from 'react';
 import { Select as Select_2 } from '@base-ui/react/select';
+import { StandardJSONSchemaV1 } from '@standard-schema/spec';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Tabs as Tabs_2 } from '@base-ui/react/tabs';
 import { Time } from '@internationalized/date';
@@ -124,7 +125,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 +135,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;
 }
@@ -148,10 +155,15 @@ declare function Actions({ className, ...props }: ActionsProps): JSX.Element;
 
 declare type ActionsProps = React_2.ComponentProps<"div">;
 
+declare type ActiveToolCall = {
+    id: string;
+    name: string;
+};
+
 export declare const ActivityCard: typeof ActivityCardStandalone & {
     Root: typeof Root_3;
     Items: typeof Items;
-    Item: typeof Item;
+    Item: typeof Item_2;
 };
 
 /**
@@ -239,11 +251,55 @@ 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;
 
+/** Low-level event stream consumed by `useAIChat()`. */
 export declare type AIChatCompletionEvent = {
     type: "text-delta";
     text: string;
+} | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    argumentsText: string;
 } | {
     type: "done";
     finishReason?: string;
@@ -270,6 +326,7 @@ declare type AIChatComponent = typeof AIChatRoot & {
     ChainOfThoughtSearchResults: typeof ChainOfThoughtSearchResults;
     ChainOfThoughtSearchResult: typeof ChainOfThoughtSearchResult;
     Tool: typeof Tool;
+    ToolCall: typeof ToolCall;
     ToolHeader: typeof ToolHeader;
     ToolContent: typeof ToolContent;
     ToolInput: typeof ToolInput;
@@ -325,6 +382,7 @@ export declare type AIChatHeaderProps = {
     className?: string;
 };
 
+/** Public chat message shape exposed by `useAIChat()`. */
 export declare interface AIChatMessage {
     id: string;
     role: "user" | "assistant";
@@ -348,17 +406,56 @@ declare function AIChatRoot({ className, children, status, ...props }: AIChatPro
 
 export declare type AIChatStatus = "ready" | "submitted" | "streaming" | "error";
 
+export declare type AIChatToolCallProps = {
+    /** A requested tool from useAIChat().toolCalls, not an execution success receipt. */
+    call: ReturnType<typeof useAIChat>["toolCalls"][number];
+    className?: string;
+};
+
+/** Context passed to local tool executors. */
+export declare interface AIChatToolContext {
+    /** Abort signal for the in-flight chat request. */
+    signal: AbortSignal;
+    /** Public user/assistant transcript visible to the current chat turn. */
+    messages: AIChatMessage[];
+}
+
+/**
+ * Schema contract for local AI chat tools.
+ *
+ * A schema must validate runtime inputs and generate JSON Schema for the AI
+ * Gateway request. Zod 4 implements both Standard Schema contracts directly.
+ *
+ * @example
+ * ```ts
+ * import { z } from "zod/v4";
+ *
+ * const schema = z.object({
+ *   customerId: z.string(),
+ *   includeInactive: z.boolean().optional(),
+ * });
+ * ```
+ */
+export declare type AIChatToolSchema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
+
+/** Internal transcript message shape sent to the AI Gateway transport layer. */
 export declare type AIGatewayChatMessage = {
     role: "system" | "user";
     content: string;
 } | {
     role: "assistant";
     content?: string;
+    toolCalls?: AIGatewayToolCall[];
+} | {
+    role: "tool";
+    toolCallId: string;
+    content: string;
 };
 
 export declare interface AIGatewayChatRequest {
     model: string;
     messages: AIGatewayChatMessage[];
+    tools?: AIGatewayFunctionTool[];
     signal?: AbortSignal;
 }
 
@@ -369,6 +466,39 @@ export declare interface AIGatewayClient {
     streamChatCompletion(request: AIGatewayChatRequest): AsyncIterable<AIChatCompletionEvent>;
 }
 
+/** Normalized local function tool definition understood by the AI Gateway. */
+export declare interface AIGatewayFunctionTool {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+}
+
+/** Normalized local function tool call emitted by the AI Gateway transport. */
+export declare interface AIGatewayToolCall {
+    id: string;
+    name: string;
+    argumentsText: string;
+}
+
+/**
+ * A tool executed locally inside AppShell.
+ *
+ * Local tools are validated with Standard Schema, executed in-process, and then
+ * written back into the internal AI Gateway transcript as `role: "tool"`
+ * messages for the next model round.
+ * Schema and executor are split so heterogeneous schemas compare structurally.
+ */
+export declare type AILocalTool<TSchema extends AIChatToolSchema<any, any> = AIChatToolSchema<any, any>> = {
+    kind: "local";
+    description?: string;
+    schema: TSchema;
+} & {
+    execute: (args: StandardSchemaV1.InferOutput<TSchema>, context: AIChatToolContext) => unknown | Promise<unknown>;
+};
+
 export declare const Alert: {
     Root: typeof Root_2;
     Title: typeof Title;
@@ -537,9 +667,12 @@ export declare interface AppShellRegister {
 }
 
 export declare type AppShellSidebarState = {
+    /** Effective desktop operations after normalizing sidebarBehaviour or deprecated collapsible. */
+    sidebarBehaviour: SidebarBehaviour;
     /**
      * Whether the sidebar is expanded on desktop — the same signal the DOM
-     * exposes as `[data-slot="sidebar"][data-state]`.
+     * exposes as `[data-slot="sidebar"][data-state]` when collapsing is enabled.
+     * Always `true` in "fixed" or "resize" mode, regardless of `defaultOpen`.
      *
      * On mobile the sidebar is an overlay sheet rather than an in-flow column,
      * so this does not describe how much room the content has; branch on
@@ -548,11 +681,13 @@ export declare type AppShellSidebarState = {
     open: boolean;
     /** Whether the viewport is below the mobile breakpoint (768px). */
     isMobile: boolean;
-    /** Expand or collapse the sidebar. */
+    /** Expand or collapse the desktop sidebar. Inert in "fixed" or "resize" mode. */
     setOpen: (open: boolean) => void;
     /**
      * Toggle the sidebar — the same action as `<SidebarLayout.Trigger />` and the
      * ⌘B / Ctrl+B shortcut, including the mobile and tablet overlay behaviour.
+     * Desktop toggling is inert in "fixed" or "resize" mode. Mobile/tablet menu
+     * toggling remains available in every mode.
      */
     toggle: () => void;
 };
@@ -1060,7 +1195,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 }
@@ -1215,16 +1350,45 @@ declare interface CellEditBase<TRow extends Record<string, unknown>, TValue, TDr
      * 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. The return value is ignored.
+     * 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;
     /**
-     * Notifies a changed, confirmed editor output, compared with current `data`.
-     * Empty cells confirm `null`. Confirmation does not imply business validation,
-     * adoption, or persistence; update `data` here to adopt it. Return values are
-     * ignored. Output types follow the editor, not the row field's runtime type.
+     * 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. */
@@ -1416,6 +1580,34 @@ declare type CheckboxSection<TField extends string = string> = FieldSectionBase<
     searchThreshold?: number | false;
 };
 
+/** `"checkbox"` mode's own props. */
+declare type CheckboxSelectionOwnProps<T> = {
+    /** What clicking and Space do to a row. Default `"none"`. */
+    selectionMode: "checkbox";
+    /**
+     * Names the hidden inputs that carry the value on native form submission,
+     * one per key (read with `formData.getAll(name)`). Inside a `Field.Root`, the
+     * field's `name` wins.
+     */
+    name?: string;
+    /** `id` of the form that owns the hidden inputs, when the tree is rendered outside it. */
+    form?: string;
+    /** The string written into each hidden input. Defaults to the item's key. */
+    itemToStringValue?: (item: T, context: TreeMapItemContext<T>) => string;
+    /** At least one item must be ticked before the owning form can submit. */
+    required?: boolean;
+    /**
+     * Id for the tree's form control (Field generates one otherwise). A native
+     * `<label htmlFor>` focuses the tree but doesn't name it — name it with a
+     * `Field.Label`, `aria-label` or `aria-labelledby`.
+     */
+    id?: string;
+    /** Ref to the hidden proxy input that carries `required` and Field validation. */
+    inputRef?: React_2.Ref<HTMLInputElement>;
+    /** Fires when focus leaves the tree (not each row). */
+    onBlur?: () => void;
+} & TreeValueProps<T> & TreeSelectionBehaviorProps;
+
 /** Clears only the rail's own fields. Renders nothing while none are active. */
 declare function ClearAll({ children, className }: ClearAllProps): JSX.Element | null;
 
@@ -1673,6 +1865,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.
      *
@@ -1685,6 +1888,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
@@ -2305,7 +2542,7 @@ declare namespace Content_2 {
 }
 
 /** The main dialog panel that contains the dialog content. Automatically includes a close button and overlay. */
-declare function Content_3({ className, children, ...props }: React_2.ComponentProps<typeof Dialog_2.Popup>): JSX.Element;
+declare function Content_3({ className, children, ref, initialFocus, ...props }: DialogContentProps): JSX.Element;
 
 declare namespace Content_3 {
     var displayName: string;
@@ -2359,11 +2596,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`, `DateRangePicker` and
+ * `Tree` 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;
 
@@ -2684,7 +2925,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;
@@ -2821,6 +3063,26 @@ export declare interface DataTableContextValue<TRow extends Record<string, unkno
     collapseAllRows?: () => void;
     /** Expansion config. Its presence enables the expand column and detail rows. */
     rowExpansion?: RowExpansionOptions<TRow>;
+    /** Sub-rows config. Its presence turns the table into a tree. */
+    subRows?: SubRowsOptions<TRow>;
+    /** The rows to render with sub-rows: each page row followed by its open sub-rows. */
+    visibleRows?: DataTableTreeRow<TRow>[];
+    /** Key of the hierarchy column. */
+    treeColumnKey?: string;
+    /**
+     * The hierarchy column. It's owned by `subRows`, so it's not in `columns`,
+     * but it leads `visibleColumns`.
+     */
+    hierarchyColumn?: Column<TRow>;
+    /** Ids of the rows whose sub-rows are open. */
+    expandedSubRowIds?: string[];
+    /** Opens or closes `row`'s sub-rows. */
+    toggleSubRows?: (row: TRow) => void;
+    /** A row's checkbox, derived as `rowSelection.selectionStrategy` says. */
+    getRowCheckState?: (row: TRow) => {
+        checked: boolean;
+        indeterminate: boolean;
+    };
 }
 
 /**
@@ -2836,6 +3098,38 @@ declare type DataTableDateFilterOperator = Extract<OperatorForFilterType["date"]
 
 declare type DataTableEnumFilterOperator = Extract<OperatorForFilterType["enum"], "in">;
 
+/**
+ * `rowExpansion` and `subRows` are mutually exclusive. The `never` members reject
+ * both even when options come from a typed variable or a spread.
+ */
+declare type DataTableExpansionOptions<TRow extends Record<string, unknown>> = {
+    /**
+     * Expandable detail rows. Providing this enables the whole feature: a chevron
+     * column is added at the left edge (auto-pinned left, after the selection
+     * column) and `render`'s output appears in a full-width row beneath its parent.
+     *
+     * Grouped rather than flat so the parts can't be configured in a broken
+     * combination — a label or predicate without a renderer, or `expandedIds`
+     * without `onChange`, are all compile errors.
+     *
+     * **Requirement:** Each row must have a string or number `id` field.
+     * Expansion is keyed by `id`, so rows without one render no chevron.
+     *
+     * **Note:** Expansion is **not** cleared on page change — ids of rows no
+     * longer on the page simply do not render. Call `collapseAllRows()` to reset.
+     */
+    rowExpansion?: RowExpansionOptions<TRow>;
+    subRows?: never;
+} | {
+    rowExpansion?: never;
+    /**
+     * Nested rows under each row, opened from a caret in the hierarchy column.
+     * See {@link SubRowsOptions}. Can't be combined with `rowExpansion`: a row
+     * shows either its sub-rows or a detail panel, so passing both is a type error.
+     */
+    subRows: SubRowsOptions<TRow>;
+};
+
 export declare type DataTableFilterConfig = (Extract<FilterConfig, {
     type: "string";
 }> & {
@@ -2970,6 +3264,19 @@ declare namespace DataTableToolbar {
     var displayName: string;
 }
 
+/** One rendered row of a table with `subRows`. */
+export declare interface DataTableTreeRow<TRow extends Record<string, unknown>> {
+    row: TRow;
+    /** 0 for the page's own rows. */
+    depth: number;
+    /** The row has sub-rows (and an id, so it can open). */
+    hasSubRows: boolean;
+    /** Its sub-rows are shown. */
+    expanded: boolean;
+    /** Unique render key, from the row's position in the tree. */
+    key: string;
+}
+
 declare type DataTableUiFilterOperatorByType = {
     string: DataTableStringFilterOperator;
     number: DataTableNumericTemporalFilterOperator;
@@ -3304,6 +3611,39 @@ export declare type DefaultSidebarProps = {
     iconRail?: boolean;
 };
 
+/**
+ * Small typed helper for defining local AI chat tools.
+ *
+ * This is mostly an identity function, but it keeps `execute(args)` inferred
+ * from the provided schema when tools are declared inline.
+ *
+ * @example
+ * ```ts
+ * import { defineAIChatTool } from "@tailor-platform/app-shell";
+ * import { z } from "zod/v4";
+ *
+ * const lookupCustomer = defineAIChatTool({
+ *   description: "Look up a customer in the current workspace",
+ *   schema: z.object({
+ *     customerId: z.string(),
+ *   }),
+ *   async execute({ customerId }, { signal }) {
+ *     const customer = await fetchCustomer(customerId, { signal });
+ *     return {
+ *       id: customer.id,
+ *       name: customer.name,
+ *       status: customer.status,
+ *     };
+ *   },
+ * });
+ * ```
+ */
+export declare function defineAIChatTool<const TSchema extends AIChatToolSchema<any, any>>(tool: {
+    description?: string;
+    schema: TSchema;
+    execute: (args: StandardSchemaV1.InferOutput<TSchema>, context: AIChatToolContext) => unknown | Promise<unknown>;
+}): AILocalTool<TSchema>;
+
 /**
  * Defines internationalization labels for multiple locales.
  *
@@ -3609,6 +3949,8 @@ export declare const Dialog: {
     Trigger: typeof Trigger_2;
 };
 
+declare type DialogContentProps = React_2.ComponentProps<typeof Dialog_2.Popup>;
+
 declare type DialogRootProps = Pick<React_2.ComponentProps<typeof Dialog_2.Root>, "open" | "defaultOpen" | "onOpenChange" | "modal"> & {
     children: React_2.ReactNode;
 };
@@ -3706,6 +4048,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
  */
@@ -3817,6 +4176,14 @@ declare type ErrorBoundaryProps = {
     errorBoundary?: ErrorBoundaryComponent;
 };
 
+/**
+ * Rules out another mode's props, so that (say) `name` without
+ * `selectionMode: "checkbox"` is a type error rather than silently ignored.
+ */
+declare type Excluding<P> = {
+    [K in Exclude<keyof P, "selectionMode">]?: never;
+};
+
 /**
  * Type-safe path builder for file-based routing.
  *
@@ -4229,6 +4596,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.
  *
@@ -4432,7 +4805,7 @@ declare type GlobalHeaderLayoutBodyProps = GlobalHeaderLayoutCommonProps & {
     children?: never;
 };
 
-declare type GlobalHeaderLayoutCommonProps = {
+declare type GlobalHeaderLayoutCommonProps = SidebarBehaviourProps & {
     /**
      * The app-wide top bar, spanning above the sidebar and content.
      *
@@ -4447,8 +4820,6 @@ declare type GlobalHeaderLayoutCommonProps = {
     sidebar?: React.ReactNode;
     /** Whether the sidebar is expanded by default on desktop. @default true */
     defaultOpen?: boolean;
-    /** Whether the sidebar can be collapsed. @default true */
-    collapsible?: boolean;
 };
 
 /** Default content layout — you render the page via the `Outlet` render prop. */
@@ -4553,17 +4924,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;
 }
 
@@ -4574,6 +4948,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.
@@ -4712,7 +5103,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;
 
@@ -4735,6 +5126,29 @@ declare type HeadProps = React_2.ComponentProps<"th"> & {
  */
 export declare const hidden: () => GuardResult;
 
+/**
+ * The column that carries the sub-rows hierarchy: the indent, the open / close
+ * caret, the selection checkbox (except under `"independent"`), and the row's
+ * label. It takes the display options of a regular {@link Column}, typed the
+ * same way per `type`, but its layout belongs to `subRows`: it's always first
+ * and pinned left, and it stays out of column settings and saved layout.
+ *
+ * `id`, `pin`, `align`, `edit`, `sort` and `filter` aren't available. `label`
+ * and `accessor` are required: `accessor` also names each row's caret for
+ * assistive tech ("Expand row Assets").
+ */
+export declare type HierarchyColumn<TRow extends Record<string, unknown>> = Pick<ColumnBase<TRow>, "render" | "cellProps" | "header" | "headerProps" | "footer" | "footerProps" | "width" | "truncate"> & {
+    /** Header text, and the caret's name prefix. */
+    label: string;
+} & HierarchyColumnTypeBranch<TRow>;
+
+/** Each `ColumnTypeBranch`, without `edit` and with `accessor` required. */
+declare type HierarchyColumnTypeBranch<TRow extends Record<string, unknown>> = ColumnTypeBranch<TRow> extends infer Branch ? Branch extends {
+    accessor?: infer Accessor;
+} ? Omit<Branch, "edit" | "accessor"> & {
+    accessor: NonNullable<Accessor>;
+} : never : never;
+
 declare type HourCycle = 12 | 24;
 
 export declare type I18nLabels<Def extends Record<string, LabelValue> = Record<string, LabelValue>, L extends string = never> = {
@@ -4806,16 +5220,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 function Item_2({ indicator, children, className }: ActivityCardItemProps): JSX.Element;
 
-declare namespace Item {
+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;
 }
 
@@ -4831,6 +5248,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 {
@@ -4907,7 +5342,7 @@ export declare const Layout: LayoutComponent;
 
 /**
  * Typed explicitly rather than assigning onto a `function Layout`: that form emits
- * `var Header: typeof import("./Layout").Header`, which the declaration rollup
+ * `var Header: typeof import("./layout").Header`, which the declaration rollup
  * rewrites to a bare `Header` — a namespace, not a type (TS2709). See `check-dts`.
  */
 declare type LayoutComponent = typeof LayoutRoot & {
@@ -5006,13 +5441,18 @@ declare namespace LinkItem {
 
 export { LinkProps }
 
-/** Groups the individual tab buttons. */
-declare function List({ className, children, ...props }: React_2.ComponentProps<typeof Tabs_2.List>): JSX.Element;
+/**
+ * Groups the individual tab buttons. Tabs stay on one row and scroll sideways
+ * when they do not fit. `className` applies to the inner track.
+ */
+declare function List({ className, children, ...props }: Omit<React_2.ComponentProps<typeof Tabs_2.List>, "render">): JSX.Element;
 
 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);
@@ -5038,14 +5478,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;
@@ -5264,6 +5704,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;
@@ -5597,6 +6039,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";
 
@@ -6101,8 +6549,16 @@ declare type RowExpansionOptions<TRow extends Record<string, unknown>> = {
     onChange?: (ids: string[]) => void;
 });
 
-/** Controlled or uncontrolled row-selection configuration. Keep the mode stable while mounted. */
-export declare type RowSelectionOptions = {
+/**
+ * Controlled or uncontrolled row-selection configuration. Keep the mode stable while mounted.
+ *
+ * With `subRows`, `selectionStrategy` says how ticking spreads through the
+ * hierarchy and what the selected ids list, exactly as on `Tree`. It defaults to
+ * `"leaves"`: a parent row is a container, its checkbox is derived from the rows
+ * beneath it, and the selection lists the leaf rows. Without `subRows` every row
+ * is independent and it has no effect.
+ */
+export declare type RowSelectionOptions = TreeSelectionBehaviorProps & {
     /**
      * Bulk actions for the selected IDs, shown in `DataTable.Footer` while at
      * least one row is selected. The bar includes the selection count, these
@@ -6157,6 +6613,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;
@@ -6172,6 +6631,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;
 
@@ -6462,10 +6925,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;
 }
 
@@ -6700,6 +7166,34 @@ declare type SheetRootProps = Pick<React_2.ComponentProps<typeof Drawer.Root>, "
 
 declare type Side = "top" | "right" | "bottom" | "left";
 
+/** Allowed desktop operations; every mode keeps normal mobile/tablet menu presentation. */
+declare type SidebarBehaviour = 
+/** Always expanded at a fixed desktop width, with no collapse/resize controls; ignores defaultOpen. */
+"fixed"
+/** Desktop collapse/expand controls only, with a fixed width and no resize handle; respects defaultOpen. */
+| "collapse"
+/**
+* Desktop resizing only, while always expanded; ignores defaultOpen.
+* Width clamps to 192–480px, and double-click resets to 256px without collapsing.
+*/
+| "resize"
+/**
+* Default: both desktop collapsing and resizing are enabled; respects defaultOpen.
+* Dragging can expand, resize, and collapse. Double-click resets to 256px or collapses from 256px.
+*/
+| "collapse-and-resize";
+
+/** New and deprecated configuration cannot be specified together. */
+declare type SidebarBehaviourProps = {
+    /** Desktop operations to allow. @default "collapse-and-resize" */
+    sidebarBehaviour?: SidebarBehaviour;
+    collapsible?: never;
+} | {
+    sidebarBehaviour?: never;
+    /** @deprecated Use sidebarBehaviour. true maps to "collapse", false to "fixed". */
+    collapsible?: boolean;
+};
+
 /**
  * A collapsible group for sidebar navigation.
  *
@@ -6903,7 +7397,7 @@ declare type SidebarLayoutBodyProps = SidebarLayoutCommonProps & {
     children?: never;
 };
 
-declare type SidebarLayoutCommonProps = {
+declare type SidebarLayoutCommonProps = SidebarBehaviourProps & {
     /**
      * Custom sidebar content. Replaces the whole sidebar region.
      *
@@ -6920,14 +7414,6 @@ declare type SidebarLayoutCommonProps = {
      * @default true
      */
     defaultOpen?: boolean;
-    /**
-     * Whether the sidebar can be collapsed.
-     * When set to `false`, the sidebar is always visible and cannot be toggled.
-     * `defaultOpen` is ignored when this is `false`.
-     *
-     * @default true
-     */
-    collapsible?: boolean;
     /**
      * A global top bar rendered above **everything** — spanning the full width
      * across the top of the primary sidebar and the content region alike. The
@@ -7067,6 +7553,24 @@ export declare type SidebarSectionProps = {
  */
 export declare const SidebarSeparator: () => JSX.Element;
 
+/** `"single"` mode's own props. */
+declare type SingleSelectionOwnProps<T> = {
+    /** What clicking and Space do to a row. Default `"none"`. */
+    selectionMode: "single";
+    /** Controlled selection: the selected row's key, or `null` for none. */
+    selectedKey?: string | null;
+    /** Initial selection when uncontrolled. */
+    defaultSelectedKey?: string | null;
+    /** Fires when the user selects a row, with its key and your item. */
+    onSelectedKeyChange?: (key: string, item: T) => void;
+    /**
+     * Opens the selected row's ancestors when it starts out hidden or
+     * `selectedKey` changes from outside, so the selection is always on screen.
+     * A group the user closes afterwards stays closed. Default `true`.
+     */
+    revealSelected?: boolean;
+};
+
 declare type Size = "sm" | "md" | "lg" | "xl" | "full";
 
 /**
@@ -7177,6 +7681,39 @@ declare namespace SubmenuTrigger {
     var displayName: string;
 }
 
+/**
+ * Nested rows, shown under their parent when it's opened. The page's rows are
+ * the top level, so pagination counts them, and each parent's sub-rows stay on
+ * its page.
+ *
+ * `hierarchyColumn` defines the column that carries the hierarchy. Like the
+ * row-actions column, it's added by the feature rather than taken from
+ * `columns`: it's always first and pinned left, can't be hidden or moved, and
+ * leaves your other columns as you defined them.
+ *
+ * **Requirement:** Each row must have a string or number `id`, unique across
+ * the whole tree. Expansion and selection are keyed by it; a row without one
+ * shows its sub-rows nowhere and can't be selected.
+ */
+export declare type SubRowsOptions<TRow extends Record<string, unknown>> = {
+    /** A row's sub-rows. Omitted, `null` or empty means a leaf. */
+    getSubRows: (row: TRow) => readonly TRow[] | null | undefined;
+    /** The column that shows the hierarchy. See {@link HierarchyColumn}. */
+    hierarchyColumn: HierarchyColumn<TRow>;
+} & ({
+    /** Controlled: ids of the rows whose sub-rows are open. Update it from `onExpandedChange`. */
+    expandedIds: string[];
+    /** Called with every open id after the user opens or closes a row. */
+    onExpandedChange: (ids: string[]) => void;
+    defaultExpandedIds?: never;
+} | {
+    expandedIds?: never;
+    /** Ids open at first, when uncontrolled. */
+    defaultExpandedIds?: string[];
+    /** Notification in uncontrolled mode, with every open id. */
+    onExpandedChange?: (ids: string[]) => void;
+});
+
 /**
  * A starter-prompt chip. Submits `suggestion` as if the user had typed and
  * sent it — the fastest way to teach people what the assistant is good at.
@@ -7279,16 +7816,22 @@ 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 variant="heading-md" render={<h3 />}>Line items</Text>
- * <Text variant="body-md" className="text-muted-foreground">Orders sent this month.</Text>
- * <Text variant="label-md" className="tabular-nums">1,240</Text>
+ * <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 function Text_2({ className, variant, render, children, ref, ...props }: TextProps): React_2.ReactElement<unknown, string | React_2.JSXElementConstructor<any>>;
+declare const Text_2: TextComponent;
 export { Text_2 as Text }
 
 /**
@@ -7368,13 +7911,34 @@ export declare interface TextCellEditOptions<TRow extends Record<string, unknown
     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 set the heading level, for example `render={<h3 />}`. */
+    /** 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";
@@ -7386,6 +7950,8 @@ 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;
@@ -7796,8 +8362,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">;
@@ -7812,6 +8378,9 @@ declare type ToolbarRowProps = Omit<React_2.ComponentProps<"div">, "role" | "onK
 
 declare type ToolbarSeparatorProps = Omit<React_2.ComponentProps<"div">, "role" | "aria-orientation">;
 
+/** Compact tool-call label for the active flow, rendered as its own row. */
+declare function ToolCall({ call, className }: AIChatToolCallProps): JSX.Element;
+
 declare function ToolContent({ className, ...props }: ToolContentProps): JSX.Element;
 
 declare type ToolContentProps = ComponentProps<typeof DisclosurePanel>;
@@ -7859,43 +8428,344 @@ export declare const Tooltip: {
     Provider: typeof Provider;
 };
 
-declare type TooltipRootProps = Pick<React_2.ComponentProps<typeof Tooltip_2.Root>, "open" | "defaultOpen" | "onOpenChange"> & {
+declare type TooltipRootProps = Pick<React_2.ComponentProps<typeof Tooltip_2.Root>, "open" | "defaultOpen" | "onOpenChange" | "disabled"> & {
     children: React_2.ReactNode;
 };
 
-/** The element that triggers the tooltip on hover or focus. */
-declare function Trigger({ ...props }: React_2.ComponentProps<typeof Tooltip_2.Trigger>): JSX.Element;
+/**
+ * A tree of your own items, for browsing hierarchies (accounts, locations,
+ * categories), picking one node, or ticking many. It follows the ARIA tree
+ * pattern: one tab stop, arrows to move and open, Space to select or tick, and
+ * Enter for `onAction`.
+ *
+ * Pass your own items with `mapItem` (as with `Select` / `Combobox`). A key is
+ * the item's identity across the whole tree: the same key in two places is one
+ * item. When codes repeat with different meanings, compose a unique key from
+ * the `parents` that `mapItem` receives.
+ *
+ * `selectionMode` sets what a row does:
+ *
+ * - `"none"` (default): browsing. Clicking a leaf runs `onAction`.
+ * - `"single"`: one selected row (`selectedKey`), for master–detail views.
+ * - `"checkbox"`: a multi-select form control (`value`). By default parents are
+ *   containers: ticking one ticks every enabled leaf beneath it, and the value
+ *   lists leaves. `selectionStrategy` changes that. `name`
+ *   submits one hidden input per value key, and inside a `Field.Root` it picks
+ *   up the label, description, error, `required` and invalid state.
+ *
+ * `filter` narrows the tree to matches and their ancestors. The tree has no
+ * search box of its own; for the "search, pick, then add" flow in a dialog, use
+ * {@link TreePicker}.
+ *
+ * The list scrolls inside the component, so give it a height (or a sized
+ * container) for long trees.
+ *
+ * @example
+ * ```tsx
+ * // warehouses: (Warehouse | Bin)[], so `mapItem` can return either level.
+ * const isWarehouse = (node: Warehouse | Bin): node is Warehouse => "bins" in node;
+ * const [bins, setBins] = useState<string[]>([]);
+ *
+ * <Field.Root name="bins">
+ *   <Field.Label>Bins to count</Field.Label>
+ *   <Tree
+ *     className="astw:h-96"
+ *     items={warehouses}
+ *     mapItem={(item, { parents }) =>
+ *       isWarehouse(item)
+ *         ? { key: item.id, label: item.name, children: item.bins }
+ *         : // `parents` is the union too. A guard, unlike a cast, has TypeScript
+ *           // check there's a warehouse above (hence `?.`).
+ *           { key: `${parents.find(isWarehouse)?.id}/${item.code}`, label: item.code }
+ *     }
+ *     selectionMode="checkbox"
+ *     value={bins}
+ *     onValueChange={setBins}
+ *   />
+ * </Field.Root>
+ * ```
+ */
+export declare function Tree<T>(props: TreeProps<T>): JSX.Element;
 
-declare namespace Trigger {
+export declare namespace Tree {
     var displayName: string;
 }
 
-/** The element that opens the dialog when clicked. */
-declare function Trigger_2({ ...props }: React_2.ComponentProps<typeof Dialog_2.Trigger>): JSX.Element;
-
-declare namespace Trigger_2 {
-    var displayName: string;
-}
+export declare type TreeChangeDetails<T> = {
+    /** The value's items in tree order, one per key. Keys that aren't in the tree are left out. */
+    selected: TreeSelectedItem<T>[];
+};
 
-/** The element that opens the menu when clicked. */
-declare function Trigger_3({ ...props }: React_2.ComponentProps<typeof Menu_2.Trigger>): JSX.Element;
+/** Props for {@link Tree} with `selectionMode: "checkbox"`: the value, how ticking works, and forms. */
+declare type TreeCheckboxSelectionProps<T> = CheckboxSelectionOwnProps<T> & Excluding<SingleSelectionOwnProps<T>>;
 
-declare namespace Trigger_3 {
-    var displayName: string;
+/** What the tree shows — shared by `Tree` and `TreePicker`. */
+declare interface TreeContentProps<T> {
+    /** Your top-level items. Children come from `mapItem`. */
+    items: ReadonlyArray<T>;
+    /** Reads an item's key, label, children and disabled state. */
+    mapItem: (item: T, context: TreeMapItemContext<T>) => TreeMappedItem<T>;
+    /** The row's content. Defaults to the item's `label`. */
+    renderItem?: (row: TreeRowState<T>) => React_2.ReactNode;
+    /** Shown when there's nothing to show. Defaults to "No items.", or "No matching items." while filtering. */
+    emptyText?: React_2.ReactNode;
 }
 
-/** The element that opens the sheet when clicked. */
-declare function Trigger_4({ ...props }: React_2.ComponentProps<typeof Drawer.Trigger>): JSX.Element;
+/** What `filter` receives alongside each item. */
+declare type TreeFilterContext<T> = {
+    /** The item's `label` from `mapItem`. */
+    label: string;
+    /** The item's ancestors, top level first. */
+    parents: T[];
+};
 
-declare namespace Trigger_4 {
-    var displayName: string;
-}
+/** Props for {@link Tree}'s filtering. */
+declare type TreeFilterProps<T> = {
+    /**
+     * Shows only the items that match, plus their ancestors. Groups with a match
+     * open on their own, and the user can still close them. A parent that matches
+     * with no matching children keeps all its children, so it can still be opened.
+     */
+    filter?: (item: T, context: TreeFilterContext<T>) => boolean;
+};
+
+/** What `mapItem` receives alongside each item. */
+declare type TreeMapItemContext<T> = {
+    /** The item's ancestors, top level first. Empty for top-level items. */
+    parents: T[];
+};
 
 /**
- * Opens the rail on narrow screens, carrying the active filter count. Place it
- * anywhere inside `FilterRail.Provider` — a table toolbar, a page header. It
- * renders nothing on wide screens, where the rail is already visible, and while
- * it is mounted `FilterRail.Root` skips its own fallback button.
+ * How {@link Tree} reads one of your items. Mirrors `MappedItem` from
+ * `Select` / `Combobox`, plus the tree's `children` and `disabled`.
+ */
+export declare type TreeMappedItem<T> = {
+    /**
+     * Identifies the item across the whole tree. The same key in two places is
+     * one item: ticking one ticks both. When codes repeat with different meanings
+     * (bin `A1` in two warehouses), compose a unique key from `parents`.
+     */
+    key: string;
+    /** Plain text: the default row content, the default search text, and the accessible name. */
+    label: string;
+    /** The item's children. Omitted or empty means a leaf, and only leaves are selectable values. */
+    children?: ReadonlyArray<T>;
+    /** Locks the item. A disabled parent locks everything beneath it. */
+    disabled?: boolean;
+};
+
+/** Props for {@link Tree} with `selectionMode: "none"` (the default). */
+declare type TreeNoSelectionProps<T> = {
+    /** What clicking and Space do to a row. Default `"none"`. */
+    selectionMode?: "none";
+} & Excluding<SingleSelectionOwnProps<T>> & Excluding<CheckboxSelectionOwnProps<T>>;
+
+/**
+ * A {@link Tree} in a dialog, for picking many items out of a
+ * hierarchical catalog and committing them in one go — products with variants,
+ * accounts with sub-accounts, warehouses with bins. It wraps `Tree` the
+ * way `DatePicker` wraps `DateField`.
+ *
+ * The picker owns the dialog chrome, the search box, expand/collapse, and the
+ * selection while it is open; each open starts empty. The consumer owns how
+ * items are read (`mapItem`), how rows look (`renderItem`), how search matches
+ * (`matchesSearch`) and what happens on commit (`onCommit`).
+ *
+ * By default parents are containers: ticking one ticks every enabled leaf
+ * beneath it, and `onCommit` receives the ticked leaves in tree order with their
+ * parents. `selectionStrategy` changes that, as on `Tree`.
+ * Enter on a row or the "Add N items" button commits, then the picker closes
+ * itself.
+ *
+ * The dialog has a fixed height and the list scrolls inside it, so opening or
+ * closing a group never shifts what is on screen.
+ *
+ * @example
+ * ### Bulk-adding catalog items
+ * ```tsx
+ * // catalog: (Category | Product)[], so `mapItem` can return either level.
+ * const isProduct = (item: Category | Product): item is Product => "sku" in item;
+ *
+ * <TreePicker
+ *   open={open}
+ *   onOpenChange={setOpen}
+ *   title="Add items"
+ *   items={catalog}
+ *   mapItem={(item) =>
+ *     "products" in item
+ *       ? { key: item.id, label: item.name, children: item.products }
+ *       : { key: item.sku, label: item.name }
+ *   }
+ *   renderItem={({ item }) => (
+ *     <span className="flex w-full justify-between gap-3">
+ *       <span>{item.name}</span>
+ *       {"price" in item ? <span>{money(item.price)}</span> : null}
+ *     </span>
+ *   )}
+ *   // Items have the union type; a guard (not a cast) keeps categories out if
+ *   // the selection strategy ever returns parents.
+ *   onCommit={(picked) => addToOrder(picked.flatMap(({ item }) => (isProduct(item) ? [item] : [])))}
+ * />
+ * ```
+ */
+export declare function TreePicker<T>({ open, onOpenChange, title, onCommit, ctaLabel, matchesSearch, filterSlot, searchPlaceholder, className, ...treeProps }: TreePickerProps<T>): JSX.Element;
+
+export declare namespace TreePicker {
+    var displayName: string;
+}
+
+/** Props for {@link TreePicker}. */
+export declare type TreePickerProps<T> = TreeContentProps<T> & TreeSelectionBehaviorProps & {
+    /** Controls dialog visibility. */
+    open: boolean;
+    /**
+     * Fires on every user-driven open/close (Esc, backdrop, close button, Cancel,
+     * and after a successful commit). The picker closes itself after `onCommit`,
+     * so consumers should not also call this from their commit handler.
+     */
+    onOpenChange(open: boolean): void;
+    /**
+     * Search predicate. Defaults to a case-insensitive match on the item's
+     * `label`. An item is kept when it or any descendant matches. Receives the
+     * same `{ label, parents }` as `Tree`'s `filter`.
+     */
+    matchesSearch?: (item: T, query: string, context: TreeFilterContext<T>) => boolean;
+    /** Rendered to the right of the search input (e.g. a category filter button). */
+    filterSlot?: React_2.ReactNode;
+    /** Search input placeholder. Default: `"Search"`. */
+    searchPlaceholder?: string;
+    /** Dialog title. Also labels the tree for assistive tech. Default: `"Select items"`. */
+    title?: React_2.ReactNode;
+    /**
+     * Receives the value's items in tree order (see `selectionStrategy`). Items
+     * ticked before `items` changed are included, even if they're no longer in it.
+     */
+    onCommit(selected: TreeSelectedItem<T>[]): void;
+    /** Primary CTA label. Default: `"Add N items"`, or `"Add items"` when nothing is selected. */
+    ctaLabel?(count: number): React_2.ReactNode;
+    /** Merged onto the dialog panel. */
+    className?: string;
+};
+
+/** Props for {@link Tree}. */
+export declare type TreeProps<T> = TreeContentProps<T> & TreeFilterProps<T> & {
+    /**
+     * Enter on a row — the row's default action. In `"none"` mode a click on a
+     * leaf runs it too. In `"checkbox"` mode without `onAction`, Enter inside a
+     * `<form>` submits it (like Enter in a text input).
+     */
+    onAction?: (item: T, key: string) => void;
+    /** Locks the whole tree, and in `"checkbox"` mode leaves it out of form submission. */
+    disabled?: boolean;
+    /** Accessible name for the tree. Use this, `aria-labelledby`, or a `Field.Label`. */
+    "aria-label"?: string;
+    /** Id of the element naming the tree (e.g. a card or dialog title). */
+    "aria-labelledby"?: string;
+    /**
+     * Merged onto the root. The list scrolls inside it, so give it a height (or
+     * place it in a sized container) for long trees.
+     */
+    className?: string;
+} & (TreeNoSelectionProps<T> | TreeSingleSelectionProps<T> | TreeCheckboxSelectionProps<T>);
+
+/** What `renderItem` receives for each row. */
+export declare type TreeRowState<T> = {
+    item: T;
+    key: string;
+    parents: T[];
+    /** 0 for top-level rows. */
+    depth: number;
+    isLeaf: boolean;
+    /** The row's checkbox is ticked. Under `"leaves"`, `"topmost"` and `"all"`, a parent is ticked when every enabled leaf beneath it is. */
+    checked: boolean;
+    /** Under `"leaves"`, `"topmost"` and `"all"`, a parent with some, but not all, enabled leaves ticked. */
+    indeterminate: boolean;
+    /** The row is the selected one, in `"single"` mode. */
+    selected: boolean;
+    expanded: boolean;
+    disabled: boolean;
+};
+
+/** One entry of the value, as reported by `onValueChange` and `TreePicker`'s `onCommit`. */
+export declare type TreeSelectedItem<T> = {
+    key: string;
+    /** Your original item. */
+    item: T;
+    /** The item's ancestors, top level first. */
+    parents: T[];
+};
+
+/** How ticking works and what the value lists. */
+declare type TreeSelectionBehaviorProps = {
+    /** How ticking works and what the value lists. Default `"leaves"`. */
+    selectionStrategy?: TreeSelectionStrategy;
+};
+
+/**
+ * How ticking works and what the value lists. Take a parent P with leaves A and B:
+ *
+ * | Strategy               | Tick P       | Tick A and B | P ticked on its own? |
+ * | ---------------------- | ------------ | ------------ | -------------------- |
+ * | `"leaves"` (default)   | `[A, B]`     | `[A, B]`     | No                   |
+ * | `"topmost"`            | `[P]`        | `[P]`        | No                   |
+ * | `"all"`                | `[P, A, B]`  | `[P, A, B]`  | No                   |
+ * | `"cascade"`            | `[P, A, B]`  | `[A, B]`     | Yes                  |
+ * | `"independent"`        | `[P]`        | `[A, B]`     | Yes                  |
+ *
+ * - `"leaves"`, `"topmost"` and `"all"` treat parents as containers: a parent's
+ *   checkbox comes from its leaves, so unticking A after ticking P leaves P
+ *   indeterminate. With `"topmost"`, `P` stands for everything beneath it.
+ * - `"cascade"` makes parents items in their own right. Ticking one also ticks
+ *   everything beneath it, but unticking A leaves `[P, B]`, with P still ticked.
+ * - `"independent"` ticks every item on its own.
+ */
+export declare type TreeSelectionStrategy = "leaves" | "topmost" | "all" | "cascade" | "independent";
+
+/** Props for {@link Tree} with `selectionMode: "single"`. */
+declare type TreeSingleSelectionProps<T> = SingleSelectionOwnProps<T> & Excluding<CheckboxSelectionOwnProps<T>>;
+
+/** The selection: a list of keys. Which keys depends on `selectionStrategy`. */
+declare type TreeValueProps<T> = {
+    /** Controlled selection: the checked keys. */
+    value?: readonly string[];
+    /** Initial selection when uncontrolled. */
+    defaultValue?: readonly string[];
+    onValueChange?: (value: string[], details: TreeChangeDetails<T>) => void;
+};
+
+/** The element that triggers the tooltip on hover or focus. */
+declare function Trigger({ ...props }: React_2.ComponentProps<typeof Tooltip_2.Trigger>): JSX.Element;
+
+declare namespace Trigger {
+    var displayName: string;
+}
+
+/** The element that opens the dialog when clicked. */
+declare function Trigger_2({ ...props }: React_2.ComponentProps<typeof Dialog_2.Trigger>): JSX.Element;
+
+declare namespace Trigger_2 {
+    var displayName: string;
+}
+
+/** The element that opens the menu when clicked. */
+declare function Trigger_3({ ...props }: React_2.ComponentProps<typeof Menu_2.Trigger>): JSX.Element;
+
+declare namespace Trigger_3 {
+    var displayName: string;
+}
+
+/** The element that opens the sheet when clicked. */
+declare function Trigger_4({ ...props }: React_2.ComponentProps<typeof Drawer.Trigger>): JSX.Element;
+
+declare namespace Trigger_4 {
+    var displayName: string;
+}
+
+/**
+ * Opens the rail on narrow screens, carrying the active filter count. Place it
+ * anywhere inside `FilterRail.Provider` — a table toolbar, a page header. It
+ * renders nothing on wide screens, where the rail is already visible, and while
+ * it is mounted `FilterRail.Root` skips its own fallback button.
  */
 declare function Trigger_5({ children, className }: TriggerProps_2): JSX.Element | null;
 
@@ -7960,11 +8830,20 @@ declare type TypedPaths<TRoutes extends Record<string, Record<string, string>>>
     for<T extends (keyof TRoutes & string) | `${keyof TRoutes & string}?${string}`>(path: T, ...params: ExtractBasePath<T> extends keyof TRoutes ? IsEmptyObject<TRoutes[ExtractBasePath<T>]> extends true ? [] : [TRoutes[ExtractBasePath<T>]] : never): string;
 };
 
+/**
+ * React hook for AI Gateway chat with optional local tools.
+ *
+ * Messages stay text-first. Requested tool names are exposed only for the
+ * active request; tool-call and tool-result protocol messages remain internal.
+ */
 export declare function useAIChat(config: {
     client: AIGatewayClient;
     model: string;
+    tools?: Record<string, AILocalTool>;
 }): {
     messages: AIChatMessage[];
+    /** Requested tools in the active flow; cleared on completion, stop, or error. */
+    toolCalls: ActiveToolCall[];
     status: AIChatStatus;
     error?: Error;
     /**
@@ -8691,22 +9570,6 @@ export declare type UseDataTableOptions<TRow extends Record<string, unknown>, TF
      * @deprecated Use `rowSelection.onChange` instead.
      */
     onSelectionChange?: (ids: string[]) => void;
-    /**
-     * Expandable detail rows. Providing this enables the whole feature: a chevron
-     * column is added at the left edge (auto-pinned left, after the selection
-     * column) and `render`'s output appears in a full-width row beneath its parent.
-     *
-     * Grouped rather than flat so the parts can't be configured in a broken
-     * combination — a label or predicate without a renderer, or `expandedIds`
-     * without `onChange`, are all compile errors.
-     *
-     * **Requirement:** Each row must have a string or number `id` field.
-     * Expansion is keyed by `id`, so rows without one render no chevron.
-     *
-     * **Note:** Expansion is **not** cleared on page change — ids of rows no
-     * longer on the page simply do not render. Call `collapseAllRows()` to reset.
-     */
-    rowExpansion?: RowExpansionOptions<TRow>;
     /**
      * Sort behaviour configuration.
      *
@@ -8717,7 +9580,7 @@ export declare type UseDataTableOptions<TRow extends Record<string, unknown>, TF
     sort?: false | {
         multiple?: boolean;
     };
-};
+} & DataTableExpansionOptions<TRow>;
 
 /**
  * Return type of `useDataTable` hook.
@@ -8817,6 +9680,26 @@ export declare interface UseDataTableReturn<TRow extends Record<string, unknown>
     collapseAllRows?: () => void;
     /** Expansion config (passthrough for `DataTable.Root`). */
     rowExpansion?: RowExpansionOptions<TRow>;
+    /** Sub-rows config (passthrough for `DataTable.Root`). */
+    subRows?: SubRowsOptions<TRow>;
+    /** The rows to render: each page row followed by its open sub-rows, with depth. */
+    visibleRows?: DataTableTreeRow<TRow>[];
+    /** Key of the hierarchy column. */
+    treeColumnKey?: string;
+    /** The hierarchy column, built from `subRows.hierarchyColumn`. Rendered first, pinned left. */
+    hierarchyColumn?: Column<TRow>;
+    /** Ids of the rows whose sub-rows are open. */
+    expandedSubRowIds?: string[];
+    /** Opens or closes `row`'s sub-rows. */
+    toggleSubRows?: (row: TRow) => void;
+    /**
+     * A row's checkbox. With propagation a parent's state is derived from the rows
+     * beneath it, so it can be indeterminate.
+     */
+    getRowCheckState?: (row: TRow) => {
+        checked: boolean;
+        indeterminate: boolean;
+    };
 }
 
 /**
@@ -9212,46 +10095,6 @@ 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 Image {
-    var displayName: string;
-}
-
-
-declare namespace Fallback {
-    var displayName: string;
-}
-
-
-declare namespace Root {
-    var displayName: string;
-}
-
-
 declare namespace Title {
     var displayName: string;
 }
@@ -9262,37 +10105,27 @@ declare namespace Description {
 }
 
 
-declare namespace Provider {
-    var displayName: string;
-}
-
-
 declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Header {
-    var displayName: string;
-}
-
-
-declare namespace ClearAll {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace Sections {
+declare namespace Group {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace Separator {
     var displayName: string;
 }
 
 
-declare namespace Settings {
+declare namespace TextRoot {
     var displayName: string;
 }
 
@@ -9302,12 +10135,12 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
+declare namespace Image {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Fallback {
     var displayName: string;
 }
 
@@ -9397,6 +10230,21 @@ declare namespace Root {
 }
 
 
+declare namespace Header {
+    var displayName: string;
+}
+
+
+declare namespace Content {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
 declare namespace Label {
     var displayName: string;
 }
@@ -9567,167 +10415,217 @@ declare namespace Panel {
 }
 
 
+declare namespace Trigger {
+    var displayName: string;
+}
+
+
+declare namespace Provider {
+    var displayName: string;
+}
+
+
 declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Group {
+declare namespace ClearAll {
     var displayName: string;
 }
 
 
-declare namespace Separator {
+declare namespace Sections {
     var displayName: string;
 }
 
 
-declare namespace SelectRoot {
+declare namespace Settings {
     var displayName: string;
 }
 
 
-declare namespace SelectTrigger {
+declare namespace ComboboxRoot {
     var displayName: string;
 }
 
 
-declare namespace SelectValue {
+declare namespace ComboboxInput {
     var displayName: string;
 }
 
 
-declare namespace SelectContent {
+declare namespace ComboboxTrigger {
     var displayName: string;
 }
 
 
-declare namespace SelectItem {
+declare namespace ComboboxInputGroup {
     var displayName: string;
 }
 
 
-declare namespace SelectGroup {
+declare namespace ComboboxContent {
     var displayName: string;
 }
 
 
-declare namespace SelectGroupLabel {
+declare namespace ComboboxList {
     var displayName: string;
 }
 
 
-declare namespace SelectSeparator {
+declare namespace ComboboxItem {
     var displayName: string;
 }
 
 
-declare namespace Provider {
+declare namespace ComboboxEmpty {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxGroup {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace ComboboxGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace ComboboxClear {
     var displayName: string;
 }
 
 
-declare namespace ComboboxRoot {
+declare namespace ComboboxChips {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInput {
+declare namespace ComboboxChip {
     var displayName: string;
 }
 
 
-declare namespace ComboboxTrigger {
+declare namespace ComboboxChipRemove {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInputGroup {
+declare namespace ComboboxValue {
     var displayName: string;
 }
 
 
-declare namespace ComboboxContent {
+declare namespace ComboboxStatus {
     var displayName: string;
 }
 
 
-declare namespace ComboboxList {
+declare namespace ComboboxCollection {
     var displayName: string;
 }
 
 
-declare namespace ComboboxItem {
+declare namespace Provider {
     var displayName: string;
 }
 
 
-declare namespace ComboboxEmpty {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroup {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroupLabel {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace ComboboxClear {
+declare namespace SelectRoot {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChips {
+declare namespace SelectTrigger {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChip {
+declare namespace SelectValue {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChipRemove {
+declare namespace SelectContent {
     var displayName: string;
 }
 
 
-declare namespace ComboboxValue {
+declare namespace SelectItem {
     var displayName: string;
 }
 
 
-declare namespace ComboboxStatus {
+declare namespace SelectGroup {
     var displayName: string;
 }
 
 
-declare namespace ComboboxCollection {
+declare namespace SelectGroupLabel {
+    var displayName: string;
+}
+
+
+declare namespace SelectSeparator {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+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 AutocompleteStandalone {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteAsyncStandalone {
     var displayName: string;
 }
 
@@ -9802,12 +10700,22 @@ declare namespace AutocompleteStatus {
 }
 
 
-declare namespace AutocompleteStandalone {
+declare namespace TreeRow {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteAsyncStandalone {
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Items {
+    var displayName: string;
+}
+
+
+declare namespace Item {
     var displayName: string;
 }
 
@@ -9822,37 +10730,37 @@ declare namespace DataTableTable {
 }
 
 
-declare namespace DataTableFooter {
+declare namespace DataTableToolbar {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace DataTableColumnSettings {
     var displayName: string;
 }
 
 
-declare namespace Items {
+declare namespace DataTableFooter {
     var displayName: string;
 }
 
 
-declare namespace Item {
+declare namespace DataTableFilters {
     var displayName: string;
 }
 
 
-declare namespace DataTableColumnSettings {
+declare namespace DataTableBody {
     var displayName: string;
 }
 
 
-declare namespace DataTableToolbar {
+declare namespace DataTableHeaders {
     var displayName: string;
 }
 
 
-declare namespace DataTableFilters {
+declare namespace AddFilterPanel {
     var displayName: string;
 }
 
@@ -9860,3 +10768,13 @@ declare namespace DataTableFilters {
 declare namespace AsyncErrorState {
     var displayName: string;
 }
+
+
+declare namespace DataTableHeaderContextMenu {
+    var displayName: string;
+}
+
+
+declare namespace DataTableCellContextMenu {
+    var displayName: string;
+}