@tailor-platform/app-shell 1.19.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';
@@ -154,6 +155,11 @@ 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;
@@ -285,9 +291,15 @@ export declare const aggregations: {
 
 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;
@@ -314,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;
@@ -369,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";
@@ -392,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;
 }
 
@@ -413,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;
@@ -581,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
@@ -592,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;
 };
@@ -1489,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;
 
@@ -2423,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;
@@ -2481,9 +2600,9 @@ export declare type ContextData = AppShellRegister extends {
  *
  * 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
+ * `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.
  */
@@ -2944,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;
+    };
 }
 
 /**
@@ -2959,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";
 }> & {
@@ -3093,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;
@@ -3427,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.
  *
@@ -3732,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;
 };
@@ -3957,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.
  *
@@ -4578,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.
      *
@@ -4593,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. */
@@ -4901,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> = {
@@ -5094,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 & {
@@ -5193,8 +5441,11 @@ 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;
@@ -6298,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
@@ -6907,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.
  *
@@ -7110,7 +7397,7 @@ declare type SidebarLayoutBodyProps = SidebarLayoutCommonProps & {
     children?: never;
 };
 
-declare type SidebarLayoutCommonProps = {
+declare type SidebarLayoutCommonProps = SidebarBehaviourProps & {
     /**
      * Custom sidebar content. Replaces the whole sidebar region.
      *
@@ -7127,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
@@ -7274,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";
 
 /**
@@ -7384,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.
@@ -8048,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>;
@@ -8095,10 +8428,311 @@ 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;
 };
 
+/**
+ * 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;
+
+export declare namespace Tree {
+    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>[];
+};
+
+/** Props for {@link Tree} with `selectionMode: "checkbox"`: the value, how ticking works, and forms. */
+declare type TreeCheckboxSelectionProps<T> = CheckboxSelectionOwnProps<T> & Excluding<SingleSelectionOwnProps<T>>;
+
+/** 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;
+}
+
+/** 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[];
+};
+
+/** 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[];
+};
+
+/**
+ * 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;
 
@@ -8196,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;
     /**
@@ -8927,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.
      *
@@ -8953,7 +9580,7 @@ export declare type UseDataTableOptions<TRow extends Record<string, unknown>, TF
     sort?: false | {
         multiple?: boolean;
     };
-};
+} & DataTableExpansionOptions<TRow>;
 
 /**
  * Return type of `useDataTable` hook.
@@ -9053,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;
+    };
 }
 
 /**
@@ -9448,17 +10095,17 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace Body {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace Root {
     var displayName: string;
 }
 
@@ -9468,32 +10115,12 @@ declare namespace Row {
 }
 
 
-declare namespace Head {
-    var displayName: string;
-}
-
-
-declare namespace Cell {
-    var displayName: string;
-}
-
-
-declare namespace Caption {
-    var displayName: string;
-}
-
-
-declare namespace Root {
-    var displayName: string;
-}
-
-
-declare namespace Title {
+declare namespace Group {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace Separator {
     var displayName: string;
 }
 
@@ -9518,42 +10145,42 @@ declare namespace Fallback {
 }
 
 
-declare namespace SelectRoot {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace SelectTrigger {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace SelectValue {
+declare namespace Body {
     var displayName: string;
 }
 
 
-declare namespace SelectContent {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace SelectItem {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace SelectGroup {
+declare namespace Head {
     var displayName: string;
 }
 
 
-declare namespace SelectGroupLabel {
+declare namespace Cell {
     var displayName: string;
 }
 
 
-declare namespace SelectSeparator {
+declare namespace Caption {
     var displayName: string;
 }
 
@@ -9563,52 +10190,52 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Close {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Close {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Title {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace Content {
     var displayName: string;
 }
 
@@ -9788,162 +10415,207 @@ 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 Provider {
+declare namespace Settings {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxRoot {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace ComboboxInput {
     var displayName: string;
 }
 
 
-declare namespace ClearAll {
+declare namespace ComboboxTrigger {
     var displayName: string;
 }
 
 
-declare namespace Sections {
+declare namespace ComboboxInputGroup {
     var displayName: string;
 }
 
 
-declare namespace Provider {
+declare namespace ComboboxContent {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxList {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace ComboboxItem {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace ComboboxEmpty {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace ComboboxGroup {
     var displayName: string;
 }
 
 
-declare namespace Settings {
+declare namespace ComboboxGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace ComboboxRoot {
+declare namespace ComboboxClear {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInput {
+declare namespace ComboboxChips {
     var displayName: string;
 }
 
 
-declare namespace ComboboxTrigger {
+declare namespace ComboboxChip {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInputGroup {
+declare namespace ComboboxChipRemove {
     var displayName: string;
 }
 
 
-declare namespace ComboboxContent {
+declare namespace ComboboxValue {
     var displayName: string;
 }
 
 
-declare namespace ComboboxList {
+declare namespace ComboboxStatus {
     var displayName: string;
 }
 
 
-declare namespace ComboboxItem {
+declare namespace ComboboxCollection {
     var displayName: string;
 }
 
 
-declare namespace ComboboxEmpty {
+declare namespace Provider {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroup {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroupLabel {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace ComboboxClear {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChips {
+declare namespace SelectRoot {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChip {
+declare namespace SelectTrigger {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChipRemove {
+declare namespace SelectValue {
     var displayName: string;
 }
 
 
-declare namespace ComboboxValue {
+declare namespace SelectContent {
     var displayName: string;
 }
 
 
-declare namespace ComboboxStatus {
+declare namespace SelectItem {
     var displayName: string;
 }
 
 
-declare namespace ComboboxCollection {
+declare namespace SelectGroup {
+    var displayName: string;
+}
+
+
+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;
 }
 
@@ -10028,76 +10700,81 @@ declare namespace AutocompleteStatus {
 }
 
 
-declare namespace DataTableRoot {
+declare namespace TreeRow {
     var displayName: string;
 }
 
 
-declare namespace DataTableTable {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace DataTableFooter {
+declare namespace Items {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Item {
     var displayName: string;
 }
 
 
-declare namespace Viewport {
+declare namespace DataTableRoot {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace DataTableTable {
     var displayName: string;
 }
 
 
-declare namespace Interval {
+declare namespace DataTableToolbar {
     var displayName: string;
 }
 
 
-declare namespace TimelineLink {
+declare namespace DataTableColumnSettings {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace DataTableFooter {
     var displayName: string;
 }
 
 
-declare namespace Items {
+declare namespace DataTableFilters {
     var displayName: string;
 }
 
 
-declare namespace Item {
+declare namespace DataTableBody {
     var displayName: string;
 }
 
 
-declare namespace DataTableColumnSettings {
+declare namespace DataTableHeaders {
     var displayName: string;
 }
 
 
-declare namespace DataTableToolbar {
+declare namespace AddFilterPanel {
     var displayName: string;
 }
 
 
-declare namespace DataTableFilters {
+declare namespace AsyncErrorState {
     var displayName: string;
 }
 
 
-declare namespace AsyncErrorState {
+declare namespace DataTableHeaderContextMenu {
+    var displayName: string;
+}
+
+
+declare namespace DataTableCellContextMenu {
     var displayName: string;
 }