@tailor-platform/app-shell 1.14.0 → 1.16.0

package/dist/app-shell.d.ts

@@ -10,9 +10,11 @@ import { CalendarDate } from '@internationalized/date';
 import { CalendarDateTime } from '@internationalized/date';
 import { Checkbox as Checkbox_2 } from '@base-ui/react/checkbox';
 import { ClassProp } from 'class-variance-authority/types';
+import { Collapsible } from '@base-ui/react/collapsible';
 import { Combobox as Combobox_2 } from '@base-ui/react/combobox';
 import { ComboboxFilter } from '@base-ui/react/combobox';
 import { ComboboxFilterOptions } from '@base-ui/react/combobox';
+import { ComponentProps } from 'react';
 import { CSSProperties } from 'react';
 import { DateValue } from '@internationalized/date';
 import { Dialog as Dialog_2 } from '@base-ui/react/dialog';
@@ -27,6 +29,7 @@ import { Link } from 'react-router';
 import { LinkProps } from 'react-router';
 import { LoaderFunctionArgs } from 'react-router';
 import { Location as Location_2 } from 'react-router';
+import { LucideIcon } from 'lucide-react';
 import { Menu as Menu_2 } from '@base-ui/react/menu';
 import { Navigate } from 'react-router';
 import { NavigateFunction } from 'react-router';
@@ -65,6 +68,9 @@ import { useSearchParams } from 'react-router';
 import { VariantProps } from 'class-variance-authority';
 import { ZonedDateTime } from '@internationalized/date';
 
+/** A single icon-button action — copy, retry, feedback. */
+declare function Action({ label, className, disabled, children, onClick }: ActionProps): JSX.Element;
+
 /**
  * A single action row in the ActionPanel (icon + label, triggered by onClick).
  * For navigation, call useNavigate() inside onClick (e.g. navigate("/path")).
@@ -91,7 +97,7 @@ declare interface ActionItem {
  *
  * Each row has an icon and label and is triggered by onClick. For navigation, use
  * useNavigate() inside the callback (e.g. onClick: () => navigate("/path")).
- * Use `astw:w-full` so the panel fills the width of its parent container.
+ * The panel already fills the width of its parent container.
  *
  * When an action has `loading: true`, the row shows a spinner in the icon slot and is
  * non-interactive (useful for backend-driven actions: parent sets loading from mutation/request state).
@@ -132,8 +138,18 @@ export declare interface ActionPanelProps {
     className?: string;
 }
 
+declare type ActionProps = Pick<React_2.ComponentProps<typeof Button>, "className" | "disabled" | "children" | "onClick"> & {
+    /** Accessible name; also shown as the hover tooltip. */
+    label: string;
+};
+
+/** Row of icon-button actions under a finished assistant turn. */
+declare function Actions({ className, ...props }: ActionsProps): JSX.Element;
+
+declare type ActionsProps = React_2.ComponentProps<"div">;
+
 export declare const ActivityCard: typeof ActivityCardStandalone & {
-    Root: typeof Root_2;
+    Root: typeof Root_3;
     Items: typeof Items;
     Item: typeof Item;
 };
@@ -223,6 +239,8 @@ export declare interface ActivityCardRootProps<T extends ActivityCardBaseItem> {
  */
 declare function ActivityCardStandalone({ items, title, maxVisible, overflowLabel, groupBy, className, }: ActivityCardProps): JSX.Element;
 
+export declare const AIChat: AIChatComponent;
+
 export declare type AIChatCompletionEvent = {
     type: "text-delta";
     text: string;
@@ -231,12 +249,103 @@ export declare type AIChatCompletionEvent = {
     finishReason?: string;
 };
 
+declare type AIChatComponent = typeof AIChatRoot & {
+    Header: typeof Header;
+    Conversation: typeof Conversation;
+    Composer: typeof Composer;
+    EmptyState: typeof ConversationEmptyState;
+    Message: typeof Message;
+    Response: typeof Response_2;
+    Suggestions: typeof Suggestions;
+    Suggestion: typeof Suggestion;
+    Actions: typeof Actions;
+    Action: typeof Action;
+    Reasoning: typeof Reasoning;
+    ReasoningTrigger: typeof ReasoningTrigger;
+    ReasoningContent: typeof ReasoningContent;
+    ChainOfThought: typeof ChainOfThought;
+    ChainOfThoughtHeader: typeof ChainOfThoughtHeader;
+    ChainOfThoughtContent: typeof ChainOfThoughtContent;
+    ChainOfThoughtStep: typeof ChainOfThoughtStep;
+    ChainOfThoughtSearchResults: typeof ChainOfThoughtSearchResults;
+    ChainOfThoughtSearchResult: typeof ChainOfThoughtSearchResult;
+    Tool: typeof Tool;
+    ToolHeader: typeof ToolHeader;
+    ToolContent: typeof ToolContent;
+    ToolInput: typeof ToolInput;
+    ToolOutput: typeof ToolOutput;
+    Sources: typeof Sources;
+    SourcesTrigger: typeof SourcesTrigger;
+    SourcesContent: typeof SourcesContent;
+    Source: typeof Source;
+    History: typeof ChatHistory;
+};
+
+export declare type AIChatComposerProps = {
+    /** Called with the trimmed prompt when the composer submits. */
+    onSubmit: (message: string) => void;
+    /** Called from the Stop button while the chat's `status` is `"submitted"` or `"streaming"`. Omit to show a plain busy state with no Stop affordance. */
+    onStop?: () => void;
+    /** Controlled draft. Cleared (via `onValueChange("")`) after a successful submit. */
+    value?: string;
+    /** Uncontrolled draft's initial value. */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    /** Disables the composer. The transcript above it is unaffected. */
+    disabled?: boolean;
+    /**
+     * Enter submits; Shift+Enter inserts a newline. IME-safe: Enter during
+     * kana→kanji conversion confirms the candidate rather than submitting.
+     * @default true
+     */
+    submitOnEnter?: boolean;
+    /** Open slot on the action row — a visibility toggle, a model picker, a template select. */
+    actions?: ReactNode;
+    className?: string;
+};
+
+export declare type AIChatConversationProps = ComponentProps<"div"> & {
+    /**
+     * Follow content growth (streaming text, new turns) while the reader is
+     * pinned to the bottom. Set `false` for a plain scrollable region with no
+     * auto-follow; the scroll-to-latest button still works.
+     * @default true
+     */
+    autoScroll?: boolean;
+};
+
+export declare type AIChatHeaderProps = {
+    /** Title text. */
+    title?: ReactNode;
+    /** Leading graphic. Defaults to a sparkle; pass `null` for none, or a control (e.g. a collapse button) for a docked panel. */
+    icon?: ReactNode;
+    /** Right-aligned slot — compose it from `AIChat.Action`. */
+    actions?: ReactNode;
+    className?: string;
+};
+
 export declare interface AIChatMessage {
     id: string;
     role: "user" | "assistant";
     content: string;
 }
 
+export declare type AIChatProps = Omit<ComponentProps<"div">, "children"> & {
+    /**
+     * `AIChat.Header`, `AIChat.Conversation`, and `AIChat.Composer`, in any
+     * order — the root places them. They must be **direct** children: regions
+     * are matched by component identity, so one wrapped in your own component
+     * (`const AppComposer = () => <AIChat.Composer … />`) is not recognised and
+     * is dropped. To preset props, spread them onto the region instead.
+     */
+    children: ReactNode;
+    /** The chat's state. Plugs directly into `useAIChat()`'s `status`; `AIChat.Composer` reads it for its busy/Stop state. */
+    status?: AIChatStatus;
+};
+
+declare function AIChatRoot({ className, children, status, ...props }: AIChatProps): JSX.Element;
+
 export declare type AIChatStatus = "ready" | "submitted" | "streaming" | "error";
 
 export declare type AIGatewayChatMessage = {
@@ -261,7 +370,7 @@ export declare interface AIGatewayClient {
 }
 
 export declare const Alert: {
-    Root: typeof Root;
+    Root: typeof Root_2;
     Title: typeof Title;
     Description: typeof Description;
 };
@@ -269,7 +378,7 @@ export declare const Alert: {
 export declare type AlertProps = RootProps;
 
 export declare const alertVariants: (props?: ({
-    variant?: "error" | "neutral" | "success" | "warning" | "info" | null | undefined;
+    variant?: "error" | "success" | "warning" | "neutral" | "info" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 declare type Anchor = "start" | "center" | "end";
@@ -425,6 +534,27 @@ export declare type AppShellProps = SharedAppShellProps & {
 export declare interface AppShellRegister {
 }
 
+export declare type AppShellSidebarState = {
+    /**
+     * Whether the sidebar is expanded on desktop — the same signal the DOM
+     * exposes as `[data-slot="sidebar"][data-state]`.
+     *
+     * 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
+     * `isMobile` when that distinction matters.
+     */
+    open: boolean;
+    /** Whether the viewport is below the mobile breakpoint (768px). */
+    isMobile: boolean;
+    /** Expand or collapse the sidebar. */
+    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.
+     */
+    toggle: () => void;
+};
+
 /**
  * Fetcher specification for async item loading.
  *
@@ -867,7 +997,7 @@ declare namespace AutocompleteValue {
 }
 
 export declare const Avatar: {
-    Root: typeof Root_3;
+    Root: typeof Root_4;
     Image: typeof Image_2;
     Fallback: typeof Fallback;
 };
@@ -914,7 +1044,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" | "neutral" | "success" | "warning" | "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" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export { Blocker }
@@ -958,14 +1088,15 @@ export declare type BuildQueryVariables<TTable extends TableMetadata> = {
  * <Button variant="destructive">Delete</Button>
  * ```
  */
-export declare function Button({ className, variant, size, render, children, ...props }: ButtonProps): React_2.ReactElement<unknown, string | React_2.JSXElementConstructor<any>>;
+export declare function Button({ className, variant, size, render, children, ref: forwardedRef, ...props }: ButtonProps): React_2.ReactElement<unknown, string | React_2.JSXElementConstructor<any>>;
 
 export declare type ButtonProps = React_2.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    /** Custom element to render as (Base UI render prop) */
     render?: React_2.ReactElement;
 };
 
 export declare const buttonVariants: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
     size?: "default" | "xs" | "sm" | "lg" | "icon" | null | undefined;
 } & ClassProp) | undefined) => string;
 
@@ -1031,9 +1162,9 @@ declare namespace Caption {
 }
 
 export declare const Card: {
-    Root: typeof Root_5;
-    Header: typeof Header_3;
-    Content: typeof Content;
+    Root: typeof Root_6;
+    Header: typeof Header_4;
+    Content: typeof Content_2;
 };
 
 /** A table data cell (`<td>`). */
@@ -1049,6 +1180,86 @@ declare type CellProps = React_2.ComponentProps<"td"> & {
     align?: CellAlign;
 };
 
+/**
+ * Structured step timeline for agentic turns — the discrete plan being
+ * executed, each step with a status and optional result chips. Use
+ * `AIChat.Reasoning` for free-form thinking text and this for multi-step tool
+ * plans.
+ *
+ * @example
+ * ```tsx
+ * <AIChat.ChainOfThought defaultOpen>
+ *   <AIChat.ChainOfThoughtHeader />
+ *   <AIChat.ChainOfThoughtContent>
+ *     <AIChat.ChainOfThoughtStep label="Searching" status="complete" />
+ *     <AIChat.ChainOfThoughtStep label="Drafting the answer" status="active" />
+ *   </AIChat.ChainOfThoughtContent>
+ * </AIChat.ChainOfThought>
+ * ```
+ */
+declare function ChainOfThought({ className, children, ...props }: ChainOfThoughtProps): JSX.Element;
+
+declare function ChainOfThoughtContent({ className, ...props }: ChainOfThoughtContentProps): JSX.Element;
+
+declare type ChainOfThoughtContentProps = ComponentProps<typeof DisclosurePanel>;
+
+declare function ChainOfThoughtHeader({ label, className, ...props }: ChainOfThoughtHeaderProps): JSX.Element;
+
+declare type ChainOfThoughtHeaderProps = Omit<ComponentProps<typeof DisclosureTrigger>, "children"> & {
+    /** Overrides the default "Chain of thought" label. */
+    label?: string;
+};
+
+declare type ChainOfThoughtProps = Omit<ComponentProps<typeof DisclosureRoot>, "children"> & {
+    children: ReactNode;
+};
+
+declare function ChainOfThoughtSearchResult({ className, variant, children, }: ChainOfThoughtSearchResultProps): JSX.Element;
+
+declare type ChainOfThoughtSearchResultProps = Pick<ComponentProps<typeof Badge>, "className" | "children" | "variant">;
+
+declare function ChainOfThoughtSearchResults({ className, ...props }: ChainOfThoughtSearchResultsProps): JSX.Element;
+
+declare type ChainOfThoughtSearchResultsProps = ComponentProps<"div">;
+
+declare function ChainOfThoughtStep({ label, description, icon: Icon, status, className, children, ...props }: ChainOfThoughtStepProps): JSX.Element;
+
+declare type ChainOfThoughtStepProps = ComponentProps<"div"> & {
+    label: string;
+    description?: string;
+    /** Lucide icon for the marker; a plain dot when omitted. */
+    icon?: LucideIcon;
+    status?: ChainOfThoughtStepStatus;
+};
+
+export declare type ChainOfThoughtStepStatus = "complete" | "active" | "pending";
+
+/**
+ * Grouped list of past conversations ("Today", "Previous 7 days", …) for
+ * reopening an earlier chat. Layout-agnostic — render it in a popover, a
+ * `Sheet`, or a sidebar section of a full chat page. Group titles and date
+ * bucketing are the caller's own. Deleting is optional — pass `onDelete` to
+ * reveal a delete button on hover.
+ */
+declare function ChatHistory({ groups, activeId, onSelect, onDelete, className, ...props }: ChatHistoryProps): JSX.Element;
+
+export declare type ChatHistoryGroupData = {
+    title: string;
+    items: ChatHistoryItemData[];
+};
+
+export declare type ChatHistoryItemData = {
+    id: string;
+    title: string;
+};
+
+declare type ChatHistoryProps = Omit<ComponentProps<"nav">, "onSelect"> & {
+    groups: ChatHistoryGroupData[];
+    activeId?: string;
+    onSelect?: (id: string) => void;
+    onDelete?: (id: string) => void;
+};
+
 /**
  * A styled checkbox for boolean form fields.
  *
@@ -1360,6 +1571,13 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
      * `type` is set). Always wins over the built-in renderer when both are
      * present.
      *
+     * `render` is a **presentation** hook. Built-in behaviors that need the raw
+     * cell value — such as truncation tooltips, cell context-menu copy/filter
+     * actions, and typed renderers — still resolve that value from `accessor`
+     * first, then `row[col.id]`. When neither exists, those behaviors fall back
+     * to the return value of `render(row)` only if it is a primitive
+     * (`string`/`number`/`boolean`/`bigint`).
+     *
      * Kept on the base (not per-branch) so callback contextual typing works
      * across spread-then-override patterns like `column({ ...inferred, render })`.
      */
@@ -1367,17 +1585,21 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
     /**
      * Custom header renderer.
      *
-     * When omitted, the built-in header renders `label` and, for sortable
-     * columns, owns the sort button and indicator. When provided, the return
-     * value replaces the built-in header entirely. Sortable custom headers
-     * receive `sortDirection` and `activateSort()` and must render their own
-     * click surface and sort indicator.
+     * `header` is a **presentation** hook. When omitted, the built-in header
+     * renders `label` and, for sortable columns, owns the sort button and
+     * indicator. When provided, the return value replaces the built-in header
+     * entirely. Sortable custom headers receive `sortDirection` and
+     * `activateSort()` and must render their own click surface and sort
+     * indicator for left-click sorting; built-in header context-menu actions are
+     * still driven by `label`, `sort`, and other column metadata.
      */
     header?: (ctx: HeaderRenderContext) => ReactNode;
     /**
-     * Stable identifier used for column visibility toggling and as the React key.
-     * Falls back to `label` when omitted. Set this explicitly when `label` is
-     * absent or not unique.
+     * Stable identifier used for column visibility toggling, persisted layout
+     * state, raw-value fallback (`row[col.id]`), and as the React key. Falls
+     * back to `label` when omitted. Set this explicitly when `label` is absent,
+     * not unique, or when a custom-rendered column should still participate in
+     * built-in cell behaviors that need a raw value.
      */
     id?: string;
     /** Fixed column width in pixels. When omitted the column sizes naturally. */
@@ -1402,9 +1624,8 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
     align?: "left" | "right";
     /**
      * When `true`, the cell content is truncated with an ellipsis when it
-     * overflows. A `<Tooltip>` is wired up automatically when `accessor`
-     * returns a string or number, so hovering the cell reveals the full
-     * value.
+     * overflows. A `<Tooltip>` is wired up automatically when the resolved raw
+     * value is a string or number (`accessor` first, then `row[col.id]`).
      *
      * Truncation requires the cell to be shrinkable — the body cell sets
      * `max-w-0`, which collapses unless another column anchors the row width.
@@ -1413,19 +1634,24 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
      */
     truncate?: boolean;
     /**
-     * Sort configuration. When set, the column header becomes clickable and
-     * cycles through `Asc → Desc → undefined`.
+     * Sort configuration. When set, the column participates in built-in sort
+     * behaviors such as the default clickable header and the header context-menu
+     * sort submenu. Left-click sorting from a custom `header` still requires that
+     * renderer to call `ctx.activateSort()`.
+     *
      * Use `fieldTypeToSortConfig` or `inferColumns` to derive this automatically.
      */
     sort?: SortConfig;
     /**
      * Filter configuration. When set, this column appears as an option in
-     * `DataTable.Filters`.
+     * `DataTable.Filters` and, when collection `control` is available, can also
+     * drive the built-in cell context-menu filter actions.
      *
      * `operators` optionally narrows the conditions exposed by the built-in
      * filter UI for this column. Order controls both the menu order and the
      * default operator. This affects the DataTable UI only — collection control
      * APIs and persisted filter state still accept the full backend operator set.
+     * The cell context-menu narrows this further to single-value operators only.
      *
      * Use `fieldTypeToFilterConfig` or `inferColumns` to derive this automatically.
      */
@@ -1523,11 +1749,13 @@ declare type Columns = 3 | 4;
  * - `type: "text"` rejects `typeOptions` entirely.
  *
  * `accessor` lives on each branch (rather than `ColumnBase`) so the built-in
- * renderers can constrain what a column produces. Returning an array or a
- * non-Date object is a compile error on a typed branch, instead of silently
- * rendering `[object Object]`. Untyped columns (`type?: undefined`) still
- * accept `unknown` — they're rendered by an explicit `render`. `null` and
- * `undefined` are always allowed: every built-in renderer maps them to the
+ * renderers can constrain what a column produces. It is also the primary
+ * source of truth for built-in cell behaviors that need the raw value
+ * (truncate tooltip, cell context-menu copy/filter actions). Returning an
+ * array or a non-Date object is a compile error on a typed branch, instead of
+ * silently rendering `[object Object]`. Untyped columns (`type?: undefined`)
+ * still accept `unknown` — they're rendered by an explicit `render`. `null`
+ * and `undefined` are always allowed: every built-in renderer maps them to the
  * `—` placeholder.
  *
  * Prefer `Column<TRow>` in most cases; this is exported so consumers can
@@ -1670,7 +1898,7 @@ declare namespace ComboboxGroupLabel {
     var displayName: string;
 }
 
-declare function ComboboxInput({ className, ...props }: React_2.ComponentProps<typeof Combobox_2.Input>): JSX.Element;
+declare function ComboboxInput({ className, ref: forwardedRef, ...props }: React_2.ComponentProps<typeof Combobox_2.Input>): JSX.Element;
 
 declare namespace ComboboxInput {
     var displayName: string;
@@ -1939,51 +2167,76 @@ declare type CommonProps = {
     guards?: Guard[];
 };
 
-declare function Content({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
+/**
+ * The chat's fixed footer: a `Textarea` body over one action row, following
+ * the `form/composer` pattern — left side open for `actions`, right side fixed
+ * to a single submit control. Enter submits and is IME-safe; Shift+Enter
+ * inserts a newline. The submit button becomes Stop while the chat's `status`
+ * is busy.
+ *
+ * Reads `status` from the surrounding `AIChat`.
+ */
+declare function Composer({ onSubmit, onStop, value, defaultValue, onValueChange, placeholder, disabled, submitOnEnter, actions, className, }: AIChatComposerProps): JSX.Element;
+
+/** The tooltip popup that displays additional information. */
+declare function Content({ className, position, side: _side, align: _align, sideOffset: _sideOffset, noArrow, children, ...restProps }: React_2.ComponentProps<typeof Tooltip_2.Popup> & {
+    position?: PositionProps;
+    noArrow?: boolean;
+    /** @deprecated Use `position={{ side }}` instead. */
+    side?: PositionProps["side"];
+    /** @deprecated Use `position={{ align }}` instead. */
+    align?: PositionProps["align"];
+    /** @deprecated Use `position={{ sideOffset }}` instead. */
+    sideOffset?: PositionProps["sideOffset"];
+}): JSX.Element;
 
 declare namespace Content {
     var displayName: string;
 }
 
-/** The main dialog panel that contains the dialog content. Automatically includes a close button and overlay. */
-declare function Content_2({ className, children, ...props }: React_2.ComponentProps<typeof Dialog_2.Popup>): JSX.Element;
+declare function Content_2({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
 
 declare namespace Content_2 {
     var displayName: string;
 }
 
-/** The menu popup that displays menu items. */
-declare function Content_3({ className, position, children, ...restProps }: React_2.ComponentProps<typeof Menu_2.Popup> & {
-    position?: PositionProps;
-}): JSX.Element;
+/** 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 namespace Content_3 {
     var displayName: string;
 }
 
-/** The main sheet panel. The `side` and modal behavior are inherited from `Sheet.Root` via context. */
-declare function Content_4({ className, children, size, ...props }: SheetContentProps): JSX.Element;
+/** The menu popup that displays menu items. */
+declare function Content_4({ className, position, children, ...restProps }: React_2.ComponentProps<typeof Menu_2.Popup> & {
+    position?: PositionProps;
+}): JSX.Element;
 
 declare namespace Content_4 {
     var displayName: string;
 }
 
-/** The tooltip popup that displays additional information. */
-declare function Content_5({ className, position, side: _side, align: _align, sideOffset: _sideOffset, noArrow, children, ...restProps }: React_2.ComponentProps<typeof Tooltip_2.Popup> & {
-    position?: PositionProps;
-    noArrow?: boolean;
-    /** @deprecated Use `position={{ side }}` instead. */
-    side?: PositionProps["side"];
-    /** @deprecated Use `position={{ align }}` instead. */
-    align?: PositionProps["align"];
-    /** @deprecated Use `position={{ sideOffset }}` instead. */
-    sideOffset?: PositionProps["sideOffset"];
-}): JSX.Element;
+/** The main sheet panel. The `side` and modal behavior are inherited from `Sheet.Root` via context. */
+declare function Content_5({ className, children, size, ...props }: SheetContentProps): JSX.Element;
 
 declare namespace Content_5 {
     var displayName: string;
 }
 
+export declare type ContentContainerProps = {
+    /**
+     * Pinned chrome rendered above the scroll region — it stays put while the
+     * content below it scrolls. Pass `<SidebarLayout.DefaultHeader />` for the
+     * built-in top bar, your own node to replace it, or omit it entirely for a
+     * bare content column.
+     */
+    header?: React.ReactNode;
+    /** Extra classes for the content column itself (the `<main>` element). */
+    className?: string;
+    /** Scrolling page content. Usually `<SidebarLayout.Outlet />`. */
+    children?: React.ReactNode;
+};
+
 /**
  * Context data type inferred from AppShellRegister.
  * Falls back to Record<string, unknown> if not augmented.
@@ -2005,6 +2258,32 @@ declare namespace Control {
     var displayName: string;
 }
 
+/**
+ * The transcript region: a scroll container that follows streaming output,
+ * with a scroll-to-latest button that appears once the reader scrolls away.
+ * While the reader is pinned to the bottom, growing content keeps the view
+ * scrolled down; as soon as they scroll up to reread earlier messages,
+ * following stops — a plain scrollIntoView-on-change can't tell the
+ * difference and yanks the view back mid-read.
+ *
+ * Compose the transcript inside it from `AIChat.Message`, `AIChat.Response`,
+ * and the other parts, or `AIChat.EmptyState` while there are no turns.
+ */
+declare function Conversation({ className, autoScroll, children, ...props }: AIChatConversationProps): JSX.Element;
+
+/**
+ * Centered placeholder shown while the conversation has no turns yet. Stacks
+ * `icon`, then the `title`/`description` block, then `children` — so starter
+ * suggestions go in `children` alongside the text rather than replacing it.
+ */
+declare function ConversationEmptyState({ className, title, description, icon, children, ...props }: ConversationEmptyStateProps): JSX.Element;
+
+declare type ConversationEmptyStateProps = ComponentProps<"div"> & {
+    title?: string;
+    description?: string;
+    icon?: ReactNode;
+};
+
 /**
  * Creatable opt-in props. When `onCreateItem` is provided, the combobox allows
  * users to create new items on-the-fly.
@@ -2269,6 +2548,8 @@ export declare const DataTable: {
      * `useCollectionVariables()`, otherwise this component throws at render time.
      */
     readonly Filters: typeof DataTableFilters;
+    /** Built-in column visibility, ordering, and pinning controls. */
+    readonly ColumnSettings: typeof DataTableColumnSettings;
     /**
      * Renders `<table>` with built-in `Headers` and `Body`.
      * Place inside `DataTable.Root`.
@@ -2294,6 +2575,22 @@ export declare const DataTable: {
 
 declare type DataTableBooleanFilterOperator = OperatorForFilterType["boolean"];
 
+/**
+ * A "Columns" toolbar popover with three drop zones — **Fixed left**,
+ * **Scrollable**, and **Fixed right**. Drag a column into a zone to pin it to
+ * that edge (or unpin it), and drag within a zone to reorder. Each row has a
+ * visibility checkbox. State persists when `useDataTable` has a `tableId`.
+ *
+ * Place inside any toolbar or other action layout within `DataTable.Root`.
+ */
+declare function DataTableColumnSettings({ className }: {
+    className?: string;
+}): JSX.Element;
+
+declare namespace DataTableColumnSettings {
+    var displayName: string;
+}
+
 /**
  * Context value provided by `DataTable.Root`.
  *
@@ -2773,6 +3070,28 @@ export declare type DefaultSidebarProps = {
      * Auto-generation is completely disabled when children is specified.
      */
     children?: React.ReactNode;
+    /**
+     * Hide the sidebar's own header row (org title + collapse toggle). Use when a
+     * global top bar already owns those — e.g. `SidebarLayout topBar`.
+     *
+     * @default false
+     */
+    hideHeader?: boolean;
+    /**
+     * Hide the built-in Search entry. Use when the command palette is already
+     * reachable elsewhere — e.g. a global search box in `SidebarLayout topBar`.
+     *
+     * @default false
+     */
+    hideSearch?: boolean;
+    /**
+     * Collapse to a narrow icon rail (icons stay visible) instead of sliding
+     * fully off-canvas. The rail then stays visible at every width — including
+     * mobile, where it replaces the off-canvas drawer with the icon-width rail.
+     *
+     * @default false
+     */
+    iconRail?: boolean;
 };
 
 /**
@@ -3070,20 +3389,37 @@ export declare interface DescriptionCardProps<TData extends object = Record<stri
 }
 
 export declare const Dialog: {
-    Root: typeof Root_6;
+    Root: typeof Root_7;
     Close: typeof Close;
-    Content: typeof Content_2;
+    Content: typeof Content_3;
     Description: typeof Description_2;
     Footer: typeof Footer_2;
-    Header: typeof Header_4;
+    Header: typeof Header_5;
     Title: typeof Title_2;
-    Trigger: typeof Trigger;
+    Trigger: typeof Trigger_2;
 };
 
 declare type DialogRootProps = Pick<React_2.ComponentProps<typeof Dialog_2.Root>, "open" | "defaultOpen" | "onOpenChange" | "modal"> & {
     children: React_2.ReactNode;
 };
 
+declare function DisclosurePanel({ className, ...props }: DisclosurePanelProps): JSX.Element;
+
+declare type DisclosurePanelProps = React_2.ComponentProps<typeof Collapsible.Panel>;
+
+declare function DisclosureRoot({ className, children, ...props }: DisclosureRootProps): JSX.Element;
+
+declare type DisclosureRootProps = Pick<React_2.ComponentProps<typeof Collapsible.Root>, "open" | "defaultOpen" | "onOpenChange"> & {
+    className?: string;
+    children: React_2.ReactNode;
+};
+
+declare function DisclosureTrigger({ className, children, ...props }: DisclosureTriggerProps): JSX.Element;
+
+declare type DisclosureTriggerProps = Omit<React_2.ComponentProps<typeof Collapsible.Trigger>, "children"> & {
+    children: React_2.ReactNode;
+};
+
 /**
  * DocumentProgressCard — a generic, presentational card for a document's
  * lifecycle/fulfilment state: an optional headline percentage, a stacked
@@ -3154,6 +3490,8 @@ declare interface DocumentProgressSegment {
     color: DocumentProgressColor;
 }
 
+export declare const DynamicBreadcrumb: () => JSX.Element;
+
 declare type DynamicLocales<Def extends Record<string, LabelValue>> = {
     [locale: string]: Partial<LabelDefinition<Def>> | undefined;
 };
@@ -3309,7 +3647,7 @@ declare namespace Fallback {
 }
 
 export declare const Field: {
-    Root: typeof Root_7;
+    Root: typeof Root_8;
     Label: typeof Label;
     Control: typeof Control;
     Description: typeof Description_3;
@@ -3425,7 +3763,7 @@ declare type FieldRootProps = Pick<React_2.ComponentProps<typeof Field_2.Root>,
 };
 
 export declare const Fieldset: {
-    Root: typeof Root_8;
+    Root: typeof Root_9;
     Legend: typeof Legend;
 };
 
@@ -3700,51 +4038,183 @@ declare type FormSubmitEventDetails = NonNullable<React_2.ComponentProps<typeof
 export { getLocalTimeZone }
 
 /**
- * Hand-rolled segmented-date-field state.
+ * GlobalHeader — the app-wide top bar for {@link GlobalHeaderLayout}.
  *
- * This is the logic react-aria's `useDateFieldState` would otherwise provide.
- * We own it here: locale-driven segment ordering (via `DateFormatter`), per-
- * segment spinbutton semantics (increment/decrement with context-aware limits),
- * numeric type-to-fill with auto-advance, and value-type discrimination by
- * `granularity`. No `Date` ever escapes — `onChange` emits `@internationalized/date`
- * values (or `null`).
+ * Codifies the header layout so consumers don't hand-assemble it: the app title
+ * (from `AppShell`) and the route-driven breadcrumb sit on the left, and the
+ * `actions` cluster (defaulting to the appearance switcher) on the right.
+ *
+ * Use it via the `GlobalHeaderLayout.DefaultHeader` namespace.
+ *
+ * @example
+ * ```tsx
+ * <GlobalHeaderLayout
+ *   header={
+ *     <GlobalHeaderLayout.DefaultHeader
+ *       actions={[<AccountMenu key="account" />, <AppearanceSwitcher key="appearance" />]}
+ *     />
+ *   }
+ * />
+ * ```
  */
-declare type Granularity = "day" | "hour" | "minute" | "second";
-
-export declare const Grid: React_2.ForwardRefExoticComponent<Omit<GridProps, "ref"> & React_2.RefAttributes<HTMLDivElement>> & {
-    Item: React_2.ForwardRefExoticComponent<Omit<GridItemProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export declare const GlobalHeader: {
+    ({ actions }: GlobalHeaderProps): JSX.Element;
+    displayName: string;
 };
 
 /**
- * Props for {@link Grid.Item} — a grid cell that spans or is placed explicitly.
+ * GlobalHeaderLayout — the app-shell layout with an app-wide header above the
+ * whole shell and a sidebar that collapses to a persistent icon rail.
  *
- * Only needed when a child must span multiple tracks or be positioned; plain
- * children render in a single cell without it.
+ * It is a thin, opinionated wrapper over {@link SidebarLayout}: it wires the
+ * global top bar, drops the sidebar's own header, and turns on the icon rail so
+ * consumers get the intended experience without reconstructing it from
+ * individual props. Reach for `SidebarLayout` directly when you need the
+ * flexible primitive instead.
+ *
+ * @example
+ * ```tsx
+ * <GlobalHeaderLayout
+ *   header={<GlobalHeaderLayout.DefaultHeader actions={[<AppearanceSwitcher key="a" />]} />}
+ *   sidebar={
+ *     <GlobalHeaderLayout.DefaultSidebar>
+ *       <SidebarItem to="/" />
+ *       <SidebarGroup title="Main" icon={<LayersIcon />}>
+ *         <SidebarItem to="/dashboard" />
+ *         <SidebarItem to="/orders" />
+ *       </SidebarGroup>
+ *     </GlobalHeaderLayout.DefaultSidebar>
+ *   }
+ * >
+ *   {({ Outlet }) => <Outlet />}
+ * </GlobalHeaderLayout>
+ * ```
  */
-export declare interface GridItemProps extends React_2.ComponentProps<"div"> {
-    /** Number of columns to span, or `"full"` to span all columns. Responsive. */
-    colSpan?: Responsive<number | "full">;
-    /** Number of rows to span, or `"full"` to span all rows. Responsive. */
-    rowSpan?: Responsive<number | "full">;
-    /** 1-based column line to start at (`grid-column-start`). Responsive. */
-    colStart?: Responsive<number>;
-    /** 1-based column line to end at (`grid-column-end`). Responsive. */
-    colEnd?: Responsive<number>;
+export declare function GlobalHeaderLayout(props: GlobalHeaderLayoutProps): JSX.Element;
+
+export declare namespace GlobalHeaderLayout {
+    var DefaultHeader: {
+        ({ actions }: GlobalHeaderProps): JSX.Element;
+        displayName: string;
+    };
+    var DefaultSidebar: {
+        ({ footer, ...rest }: DefaultSidebarProps): JSX.Element;
+        displayName: string;
+    };
+    var ContentContainer: {
+        ({ header, className, children }: ContentContainerProps): JSX.Element;
+        displayName: string;
+    };
+    var Outlet: () => JSX.Element;
+    var Trigger: {
+        ({ className, onClick }: TriggerProps): JSX.Element;
+        displayName: string;
+    };
+    var Breadcrumb: () => JSX.Element;
 }
 
 /**
- * Props for the {@link Grid} component.
- *
- * `Grid` is a generic, presentational CSS-Grid container. It does not assume
- * any data shape — children flow into the tracks defined by `columns`/`rows`.
+ * The eject: you own the whole region beside the sidebar (e.g. a table-of-
+ * contents rail + content + an assistant panel), composed from the namespaced
+ * building blocks. See {@link SidebarLayout}'s `body` slot.
  */
-export declare interface GridProps extends React_2.ComponentProps<"div"> {
+declare type GlobalHeaderLayoutBodyProps = GlobalHeaderLayoutCommonProps & {
+    body: React.ReactNode;
+    children?: never;
+};
+
+declare type GlobalHeaderLayoutCommonProps = {
     /**
-     * Column tracks. A number creates that many equal columns
-     * (`repeat(n, minmax(0, 1fr))`); a string is used verbatim as a
-     * `grid-template-columns` value (e.g. `"280px 1fr"`). Responsive.
+     * The app-wide top bar, spanning above the sidebar and content.
+     *
+     * @default <GlobalHeaderLayout.DefaultHeader />
      */
-    columns?: Responsive<number | string>;
+    header?: React.ReactNode;
+    /**
+     * The primary sidebar.
+     *
+     * @default <GlobalHeaderLayout.DefaultSidebar />
+     */
+    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. */
+declare type GlobalHeaderLayoutDefaultProps = GlobalHeaderLayoutCommonProps & {
+    children?: (props: {
+        Outlet: () => React.ReactNode;
+    }) => React.ReactNode;
+    /** Not available alongside `children` — see the `body` overload. */
+    body?: never;
+};
+
+export declare type GlobalHeaderLayoutProps = GlobalHeaderLayoutDefaultProps | GlobalHeaderLayoutBodyProps;
+
+export declare type GlobalHeaderProps = {
+    /**
+     * The right-hand cluster of the header. Rendered in a horizontal,
+     * vertically-centered row with consistent spacing — you don't wrap it
+     * yourself. Accepts a single node or an array of nodes.
+     *
+     * **`actions` replaces the entire right-hand cluster, including the
+     * appearance switcher.** When omitted, it defaults to just the
+     * `<AppearanceSwitcher />`. Include `<AppearanceSwitcher />` in your array to
+     * keep it. Passing `actions={[]}` renders an empty right side.
+     *
+     * @default [<AppearanceSwitcher />]
+     */
+    actions?: React.ReactNode | React.ReactNode[];
+};
+
+/**
+ * Hand-rolled segmented-date-field state.
+ *
+ * This is the logic react-aria's `useDateFieldState` would otherwise provide.
+ * We own it here: locale-driven segment ordering (via `DateFormatter`), per-
+ * segment spinbutton semantics (increment/decrement with context-aware limits),
+ * numeric type-to-fill with auto-advance, and value-type discrimination by
+ * `granularity`. No `Date` ever escapes — `onChange` emits `@internationalized/date`
+ * values (or `null`).
+ */
+declare type Granularity = "day" | "hour" | "minute" | "second";
+
+export declare const Grid: React_2.ForwardRefExoticComponent<Omit<GridProps, "ref"> & React_2.RefAttributes<HTMLDivElement>> & {
+    Item: React_2.ForwardRefExoticComponent<Omit<GridItemProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+};
+
+/**
+ * Props for {@link Grid.Item} — a grid cell that spans or is placed explicitly.
+ *
+ * Only needed when a child must span multiple tracks or be positioned; plain
+ * children render in a single cell without it.
+ */
+export declare interface GridItemProps extends React_2.ComponentProps<"div"> {
+    /** Number of columns to span, or `"full"` to span all columns. Responsive. */
+    colSpan?: Responsive<number | "full">;
+    /** Number of rows to span, or `"full"` to span all rows. Responsive. */
+    rowSpan?: Responsive<number | "full">;
+    /** 1-based column line to start at (`grid-column-start`). Responsive. */
+    colStart?: Responsive<number>;
+    /** 1-based column line to end at (`grid-column-end`). Responsive. */
+    colEnd?: Responsive<number>;
+}
+
+/**
+ * Props for the {@link Grid} component.
+ *
+ * `Grid` is a generic, presentational CSS-Grid container. It does not assume
+ * any data shape — children flow into the tracks defined by `columns`/`rows`.
+ */
+export declare interface GridProps extends React_2.ComponentProps<"div"> {
+    /**
+     * Column tracks. A number creates that many equal columns
+     * (`repeat(n, minmax(0, 1fr))`); a string is used verbatim as a
+     * `grid-template-columns` value (e.g. `"280px 1fr"`). Responsive.
+     */
+    columns?: Responsive<number | string>;
     /**
      * Row tracks. A number creates that many equal rows
      * (`repeat(n, minmax(0, 1fr))`); a string is used verbatim as a
@@ -3781,6 +4251,13 @@ declare namespace Group {
     var displayName: string;
 }
 
+/** A related group of controls within a toolbar row. */
+declare function Group_2({ className, ...props }: ToolbarGroupProps): JSX.Element;
+
+declare namespace Group_2 {
+    var displayName: string;
+}
+
 /** An accessible label that is automatically associated with its parent group. */
 declare function GroupLabel({ className, ...props }: React_2.ComponentProps<typeof Menu_2.GroupLabel>): JSX.Element;
 
@@ -3827,6 +4304,13 @@ declare namespace Head {
     var displayName: string;
 }
 
+/**
+ * Fixed strip above the transcript: a leading graphic and title on the left,
+ * an open action slot on the right, closed by a rule that runs the full width
+ * of the surface.
+ */
+declare function Header({ title, icon, actions, className }: AIChatHeaderProps): JSX.Element;
+
 /**
  * Layout.Header — Page-level header with title, actions, and an optional
  * full-width slot.
@@ -3866,36 +4350,36 @@ declare namespace Head {
  * </Layout>
  * ```
  */
-declare function Header({ title, actions, children }: LayoutHeaderProps): JSX.Element;
+declare function Header_2({ title, actions, children }: LayoutHeaderProps): JSX.Element;
 
-declare namespace Header {
+declare namespace Header_2 {
     var displayName: string;
 }
 
 /** The table header section (`<thead>`). */
-declare function Header_2({ className, ...props }: React_2.ComponentProps<"thead">): JSX.Element;
+declare function Header_3({ className, ...props }: React_2.ComponentProps<"thead">): JSX.Element;
 
-declare namespace Header_2 {
+declare namespace Header_3 {
     var displayName: string;
 }
 
-declare function Header_3({ className, title, description, children, ...props }: HeaderProps): JSX.Element;
+declare function Header_4({ className, title, description, children, ...props }: HeaderProps): JSX.Element;
 
-declare namespace Header_3 {
+declare namespace Header_4 {
     var displayName: string;
 }
 
 /** A layout wrapper for the dialog title and description. */
-declare function Header_4({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
+declare function Header_5({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
 
-declare namespace Header_4 {
+declare namespace Header_5 {
     var displayName: string;
 }
 
 /** A layout wrapper for the sheet title, close button, and optional action buttons. */
-declare function Header_5({ className, action, children, ...props }: SheetHeaderProps): JSX.Element;
+declare function Header_6({ className, action, children, ...props }: SheetHeaderProps): JSX.Element;
 
-declare namespace Header_5 {
+declare namespace Header_6 {
     var displayName: string;
 }
 
@@ -3981,7 +4465,7 @@ declare type InferredFieldFilterType<TTable extends TableMetadata, TFieldName ex
  * <Input type="email" disabled />
  * ```
  */
-export declare function Input({ className, type, ...props }: InputProps): JSX.Element;
+export declare function Input({ className, type, ref: forwardedRef, ...props }: InputProps): JSX.Element;
 
 export declare type InputProps = React_2.ComponentProps<"input">;
 
@@ -4105,7 +4589,7 @@ export declare const Layout: LayoutComponent;
  */
 declare type LayoutComponent = typeof LayoutRoot & {
     Column: typeof Column_2;
-    Header: typeof Header;
+    Header: typeof Header_2;
 };
 
 /**
@@ -4134,12 +4618,7 @@ export declare interface LayoutProps {
     className?: string;
     /** Inline styles */
     style?: CSSProperties;
-    /**
-     * Gap between columns (default: 4 = 16px)
-     *
-     * @deprecated Remove the `gap` prop and use `className` with the `astw:` prefix
-     * (e.g. `className="astw:gap-6"`) to override the default gap.
-     */
+    /** Gap between columns (default: 4 = 16px; supported steps: 4, 6, and 8). */
     gap?: number;
     /** Header title - displayed at the top of the layout
      *
@@ -4217,6 +4696,11 @@ declare type LocalizedString = string | ((locale: string) => string);
 
 export { Location_2 as Location }
 
+declare type Login = {
+    (): ReturnType<AuthClient["login"]>;
+    (options: NonNullable<Parameters<AuthClient["login"]>[0]>): ReturnType<AuthClient["login"]>;
+};
+
 /** Shape returned by `mapItem` to describe how an item appears in the dropdown. */
 export declare interface MappedItem {
     /** Display text — used for filtering, a11y, and fallback display. */
@@ -4228,9 +4712,9 @@ export declare interface MappedItem {
 }
 
 export declare const Menu: {
-    Root: typeof Root_9;
-    Trigger: typeof Trigger_2;
-    Content: typeof Content_3;
+    Root: typeof Root_10;
+    Trigger: typeof Trigger_3;
+    Content: typeof Content_4;
     Item: typeof Item_2;
     LinkItem: typeof LinkItem;
     CheckboxItem: typeof CheckboxItem;
@@ -4256,6 +4740,21 @@ declare namespace MenuSeparator {
     var displayName: string;
 }
 
+/**
+ * One turn in the conversation. User turns render as a right-aligned primary
+ * bubble; assistant turns take the full width with no bubble, leaving room
+ * for reasoning, tool calls, and citations to stack above the response text.
+ * `data-from` is the styling hook for callers who need to target a turn from
+ * outside.
+ */
+declare function Message({ className, from, children, ...props }: MessageProps): JSX.Element;
+
+declare type MessageProps = Omit<React_2.ComponentProps<"div">, "children"> & {
+    /** Who sent the turn — styles the alignment and bubble. */
+    from: "user" | "assistant";
+    children: React_2.ReactNode;
+};
+
 declare type MetadataFieldFilterOptions<TType extends FilterConfig["type"] = FilterConfig["type"]> = {
     operators?: NonEmptyReadonlyArray<DataTableUiFilterOperatorByType[TType]>;
 };
@@ -4644,6 +5143,44 @@ export declare interface RangeCalendarProps<T extends DateValue = DateValue> {
     locale?: string;
 }
 
+/**
+ * Collapsible "thinking" block for models that stream reasoning before the
+ * final answer. Follows the stream — open while tokens arrive, closed once
+ * they stop — until the reader toggles it, after which their choice sticks.
+ *
+ * @example
+ * ```tsx
+ * <AIChat.Reasoning isStreaming={reasoning.streaming} duration={reasoning.duration}>
+ *   <AIChat.ReasoningTrigger />
+ *   <AIChat.ReasoningContent>{reasoning.text}</AIChat.ReasoningContent>
+ * </AIChat.Reasoning>
+ * ```
+ */
+declare function Reasoning({ className, isStreaming, duration, defaultOpen, children, ...props }: ReasoningProps): JSX.Element;
+
+declare function ReasoningContent({ children, className, ...props }: ReasoningContentProps): JSX.Element;
+
+declare type ReasoningContentProps = Omit<ComponentProps<typeof DisclosurePanel>, "children"> & {
+    children: string;
+};
+
+declare type ReasoningProps = ComponentProps<"div"> & {
+    /** True while reasoning tokens are still arriving. */
+    isStreaming?: boolean;
+    /** Seconds spent thinking; shown in the trigger once streaming ends. */
+    duration?: number;
+    /** Keep the block open even when no tokens are streaming. */
+    defaultOpen?: boolean;
+    children: ReactNode;
+};
+
+declare function ReasoningTrigger({ label, className, ...props }: ReasoningTriggerProps): JSX.Element;
+
+declare type ReasoningTriggerProps = Omit<ComponentProps<typeof DisclosureTrigger>, "children"> & {
+    /** Overrides the default "Thinking… / Thought for Ns" label. */
+    label?: string;
+};
+
 /**
  * Redirect to another path.
  *
@@ -4702,6 +5239,20 @@ declare type ResourceMeta = {
     breadcrumbTitle?: string | ((segment: string) => string);
 };
 
+/**
+ * Renders the markdown subset a streamed LLM response actually emits — bold,
+ * inline code, links, headings, and bullet/numbered lists — without a
+ * markdown dependency. For full CommonMark (tables, nested lists, math), swap
+ * this for `react-markdown` or the AI SDK's `streamdown`; call sites keep the
+ * same `<AIChat.Response>{text}</AIChat.Response>` shape either way.
+ */
+declare function Response_2({ children, className }: ResponseProps): JSX.Element;
+
+declare type ResponseProps = {
+    children: string;
+    className?: string;
+};
+
 /**
  * A value that can either be a single value applied at all breakpoints, or an
  * object keyed by breakpoint for responsive behavior.
@@ -4714,12 +5265,47 @@ declare type ResourceMeta = {
  */
 declare type Responsive<T> = T | Partial<Record<Breakpoint, T>>;
 
-declare function Root({ className, variant, action, dismissible, onDismiss, children, ...props }: RootProps): JSX.Element | null;
+/**
+ * The root component that manages tooltip open/close state.
+ *
+ * @example
+ * ```tsx
+ * <Tooltip.Root>
+ *   <Tooltip.Trigger render={<Button variant="outline" />}>
+ *     Hover me
+ *   </Tooltip.Trigger>
+ *   <Tooltip.Content>Helpful information</Tooltip.Content>
+ * </Tooltip.Root>
+ * ```
+ */
+declare function Root({ children, ...props }: TooltipRootProps): JSX.Element;
 
 declare namespace Root {
     var displayName: string;
 }
 
+/**
+ * The root component that manages menu open/close state.
+ *
+ * @example
+ * ```tsx
+ * <Menu.Root>
+ *   <Menu.Trigger>Open menu</Menu.Trigger>
+ *   <Menu.Content>
+ *     <Menu.Item>Edit</Menu.Item>
+ *     <Menu.Item>Duplicate</Menu.Item>
+ *     <Menu.Separator />
+ *     <Menu.Item>Delete</Menu.Item>
+ *   </Menu.Content>
+ * </Menu.Root>
+ * ```
+ */
+declare function Root_10({ children, ...props }: MenuRootProps): JSX.Element;
+
+declare namespace Root_10 {
+    var displayName: string;
+}
+
 /**
  * The root component that manages sheet open/close state.
  * The `side` prop controls which edge of the screen the sheet slides in from.
@@ -4740,9 +5326,9 @@ declare namespace Root {
  * </Sheet.Root>
  * ```
  */
-declare function Root_10({ side, modal, ...props }: SheetRootProps): JSX.Element;
+declare function Root_11({ side, modal, ...props }: SheetRootProps): JSX.Element;
 
-declare namespace Root_10 {
+declare namespace Root_11 {
     var displayName: string;
 }
 
@@ -4763,28 +5349,16 @@ declare namespace Root_10 {
  * </Tabs.Root>
  * ```
  */
-declare function Root_11({ className, children, variant, size, ...props }: RootProps_3): JSX.Element;
+declare function Root_12({ className, children, variant, size, ...props }: RootProps_3): JSX.Element;
 
-declare namespace Root_11 {
+declare namespace Root_12 {
     var displayName: string;
 }
 
-/**
- * The root component that manages tooltip open/close state.
- *
- * @example
- * ```tsx
- * <Tooltip.Root>
- *   <Tooltip.Trigger render={<Button variant="outline" />}>
- *     Hover me
- *   </Tooltip.Trigger>
- *   <Tooltip.Content>Helpful information</Tooltip.Content>
- * </Tooltip.Root>
- * ```
- */
-declare function Root_12({ children, ...props }: TooltipRootProps): JSX.Element;
+/** A full-width visual container for one or more rows of related controls. */
+declare function Root_13({ className, ...props }: ToolbarProps): JSX.Element;
 
-declare namespace Root_12 {
+declare namespace Root_13 {
     var displayName: string;
 }
 
@@ -4802,18 +5376,24 @@ declare namespace Root_12 {
  * </Timeline.Root>
  * ```
  */
-declare function Root_13({ start, end, children, className, style }: TimelineRootProps): JSX.Element;
+declare function Root_14({ start, end, children, className, style }: TimelineRootProps): JSX.Element;
 
-declare namespace Root_13 {
+declare namespace Root_14 {
     var displayName: string;
 }
 
-declare function Root_2<T extends ActivityCardBaseItem>({ items, title, maxVisible, overflowLabel, groupBy, className, children, }: ActivityCardRootProps<T>): JSX.Element;
+declare function Root_2({ className, variant, action, dismissible, onDismiss, children, ...props }: RootProps): JSX.Element | null;
 
 declare namespace Root_2 {
     var displayName: string;
 }
 
+declare function Root_3<T extends ActivityCardBaseItem>({ items, title, maxVisible, overflowLabel, groupBy, className, children, }: ActivityCardRootProps<T>): JSX.Element;
+
+declare namespace Root_3 {
+    var displayName: string;
+}
+
 /**
  * Root container for an avatar (image with optional fallback).
  *
@@ -4827,9 +5407,9 @@ declare namespace Root_2 {
  * </Avatar.Root>
  * ```
  */
-declare function Root_3({ className, size, ...props }: AvatarProps): JSX.Element;
+declare function Root_4({ className, size, ...props }: AvatarProps): JSX.Element;
 
-declare namespace Root_3 {
+declare namespace Root_4 {
     var displayName: string;
 }
 
@@ -4856,15 +5436,15 @@ declare namespace Root_3 {
  * </Table.Root>
  * ```
  */
-declare function Root_4({ className, containerClassName, containerRef, ...props }: RootProps_2): JSX.Element;
+declare function Root_5({ className, containerClassName, containerRef, ...props }: RootProps_2): JSX.Element;
 
-declare namespace Root_4 {
+declare namespace Root_5 {
     var displayName: string;
 }
 
-declare function Root_5({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
+declare function Root_6({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
 
-declare namespace Root_5 {
+declare namespace Root_6 {
     var displayName: string;
 }
 
@@ -4888,9 +5468,9 @@ declare namespace Root_5 {
  * </Dialog.Root>
  * ```
  */
-declare function Root_6({ ...props }: DialogRootProps): JSX.Element;
+declare function Root_7({ ...props }: DialogRootProps): JSX.Element;
 
-declare namespace Root_6 {
+declare namespace Root_7 {
     var displayName: string;
 }
 
@@ -4941,37 +5521,15 @@ declare namespace Root_6 {
  * > error routing, add `name={field.name}` to `Field.Root` so errors can be
  * > matched by field name.
  */
-declare function Root_7({ className, children, isTouched, isDirty, invalid, error, isValidating: _isValidating, ...props }: FieldRootProps & {
+declare function Root_8({ className, children, isTouched, isDirty, invalid, error, isValidating: _isValidating, ...props }: FieldRootProps & {
     isValidating?: unknown;
 }): JSX.Element;
 
-declare namespace Root_7 {
-    var displayName: string;
-}
-
-declare function Root_8({ className, ...props }: FieldsetRootProps): JSX.Element;
-
 declare namespace Root_8 {
     var displayName: string;
 }
 
-/**
- * The root component that manages menu open/close state.
- *
- * @example
- * ```tsx
- * <Menu.Root>
- *   <Menu.Trigger>Open menu</Menu.Trigger>
- *   <Menu.Content>
- *     <Menu.Item>Edit</Menu.Item>
- *     <Menu.Item>Duplicate</Menu.Item>
- *     <Menu.Separator />
- *     <Menu.Item>Delete</Menu.Item>
- *   </Menu.Content>
- * </Menu.Root>
- * ```
- */
-declare function Root_9({ children, ...props }: MenuRootProps): JSX.Element;
+declare function Root_9({ className, ...props }: FieldsetRootProps): JSX.Element;
 
 declare namespace Root_9 {
     var displayName: string;
@@ -4990,8 +5548,11 @@ declare type RootConfiguration = {
 };
 
 declare type RootProps = React_2.ComponentProps<"div"> & VariantProps<typeof alertVariants> & {
+    /** Action element rendered below the description */
     action?: React_2.ReactNode;
+    /** Shows a dismiss button; hides the alert when clicked */
     dismissible?: boolean;
+    /** Callback invoked when the dismiss button is clicked */
     onDismiss?: () => void;
 };
 
@@ -5030,6 +5591,13 @@ declare namespace Row {
     var displayName: string;
 }
 
+/** One independently navigable horizontal row of toolbar controls. */
+declare function Row_2({ className, justify, onKeyDown, ref: forwardedRef, ...props }: ToolbarRowProps): JSX.Element;
+
+declare namespace Row_2 {
+    var displayName: string;
+}
+
 /**
  * A single body row.
  *
@@ -5043,9 +5611,9 @@ declare namespace Row {
  * </Timeline.Row>
  * ```
  */
-declare function Row_2({ children, className, style, height, background }: TimelineRowProps): JSX.Element;
+declare function Row_3({ children, className, style, height, background }: TimelineRowProps): JSX.Element;
 
-declare namespace Row_2 {
+declare namespace Row_3 {
     var displayName: string;
 }
 
@@ -5374,7 +5942,7 @@ declare type SelectStandaloneProps<I> = ({
     items: I[];
 } & SelectPropsMultiple<ExtractItem<I>>);
 
-declare function SelectTrigger({ className, children, ...props }: React_2.ComponentProps<typeof Select_2.Trigger>): JSX.Element;
+declare function SelectTrigger({ className, children, ref: forwardedRef, ...props }: React_2.ComponentProps<typeof Select_2.Trigger>): JSX.Element;
 
 declare namespace SelectTrigger {
     var displayName: string;
@@ -5386,6 +5954,13 @@ declare namespace SelectValue {
     var displayName: string;
 }
 
+/** A vertical separator for groups within a horizontal toolbar row. */
+declare function Separator({ className, ...props }: ToolbarSeparatorProps): JSX.Element;
+
+declare namespace Separator {
+    var displayName: string;
+}
+
 /**
  * Shared props between `AppShellProps` and the internal `WithPages` wrapper.
  *
@@ -5572,11 +6147,11 @@ declare type SharedAppShellProps = React.PropsWithChildren<{
 }>;
 
 export declare const Sheet: {
-    Root: typeof Root_10;
-    Trigger: typeof Trigger_3;
+    Root: typeof Root_11;
+    Trigger: typeof Trigger_4;
     Close: typeof Close_2;
-    Content: typeof Content_4;
-    Header: typeof Header_5;
+    Content: typeof Content_5;
+    Header: typeof Header_6;
     Footer: typeof Footer_3;
     Title: typeof Title_3;
     Description: typeof Description_4;
@@ -5692,10 +6267,10 @@ export declare type SidebarItemProps = {
      */
     to: string;
     /**
-     * Override title.
+     * Override title (i18n supported).
      * When omitted, title is auto-resolved from resource meta.
      */
-    title?: string;
+    title?: LocalizedString;
     /**
      * Override icon.
      * When omitted, icon is auto-resolved from resource meta.
@@ -5740,28 +6315,70 @@ export declare namespace SidebarLayout {
         ({ actions }: DefaultHeaderProps): JSX.Element;
         displayName: string;
     };
+    var ContentContainer: {
+        ({ header, className, children }: ContentContainerProps): JSX.Element;
+        displayName: string;
+    };
+    var Outlet: () => JSX.Element;
+    var Trigger: {
+        ({ className, onClick }: TriggerProps): JSX.Element;
+        displayName: string;
+    };
 }
 
-export declare type SidebarLayoutProps = {
+/**
+ * The eject: you own the whole region beside the sidebar, including where the
+ * header goes. `header` and `children` are unavailable here by construction —
+ * they describe a content column you are now supplying yourself.
+ */
+declare type SidebarLayoutBodyProps = SidebarLayoutCommonProps & {
     /**
-     * Custom content renderer.
+     * Replaces everything to the right of the sidebar — the escape hatch for
+     * page layouts the default content column can't express, such as a
+     * table-of-contents rail or an assistant panel docked flush against the
+     * viewport edge.
+     *
+     * Whatever you pass becomes a flex row alongside the sidebar, so it widens
+     * and narrows with the sidebar automatically. Compose it from the namespaced
+     * building blocks rather than rebuilding them:
+     *
+     * - `<SidebarLayout.ContentContainer>` — the stock content column (inset
+     *   padding, pinned header slot, scroll region, `useAppShellScrollContainer()`)
+     * - `<SidebarLayout.Outlet />` — the current page
+     * - `<SidebarLayout.DefaultHeader />` — the built-in top bar
+     * - `<SidebarLayout.Trigger />` — the sidebar collapse toggle
+     * - `useAppShellSidebar()` — subscribe to the sidebar's collapsed state
+     *
+     * The header lives inside `body` too — pass it to `ContentContainer` so it
+     * stays pinned above that column's scroll region.
      *
      * @example
      * ```tsx
-     * <SidebarLayout>
-     *   {({ Outlet }) => (
+     * <SidebarLayout
+     *   body={
      *     <>
-     *       <CustomHeader />
-     *       <Outlet />
-     *       <CustomFooter />
+     *       <aside className="w-64 shrink-0 border-r overflow-y-auto">
+     *         <TableOfContents />
+     *       </aside>
+     *       <SidebarLayout.ContentContainer header={<SidebarLayout.DefaultHeader />}>
+     *         <SidebarLayout.Outlet />
+     *       </SidebarLayout.ContentContainer>
+     *       <aside className="w-96 shrink-0 border-l overflow-y-auto">
+     *         <AssistantPanel />
+     *       </aside>
      *     </>
-     *   )}
-     * </SidebarLayout>
+     *   }
+     * />
      * ```
      */
-    children?: (props: {
-        Outlet: () => React.ReactNode;
-    }) => React.ReactNode;
+    body: React.ReactNode;
+    /** Place your header inside `body`, via `<SidebarLayout.ContentContainer header={…}>`. */
+    header?: never;
+    /** Place your content inside `body`, via `<SidebarLayout.Outlet />`. */
+    children?: never;
+};
+
+declare type SidebarLayoutCommonProps = {
     /**
      * Custom sidebar content. Replaces the whole sidebar region.
      *
@@ -5772,6 +6389,42 @@ export declare type SidebarLayoutProps = {
      * ```
      */
     sidebar?: React.ReactNode;
+    /**
+     * Whether the sidebar is open by default on desktop.
+     *
+     * @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
+     * sidebar and content then sit in a row beneath it.
+     *
+     * This is distinct from the content `header` (which sits above the content
+     * column only): use `topBar` when you want a single app-wide bar over the
+     * whole layout. Pair it with `<SidebarLayout.DefaultSidebar hideHeader />`
+     * (and often `iconRail`) so the sidebar defers its own header to the bar.
+     *
+     * The bar should be `3.5rem` (h-14) tall: the fixed sidebar is offset to start
+     * just beneath it (via the internal `--appshell-topbar-h`, fixed at `3.5rem`
+     * while a `topBar` is present).
+     */
+    topBar?: React.ReactNode;
+};
+
+/**
+ * The default layout: AppShell owns the content column, you customise its
+ * header and content.
+ */
+declare type SidebarLayoutDefaultProps = SidebarLayoutCommonProps & {
     /**
      * Custom header content. Replaces the whole top-bar region.
      *
@@ -5797,21 +6450,48 @@ export declare type SidebarLayoutProps = {
      */
     header?: React.ReactNode;
     /**
-     * Whether the sidebar is open by default on desktop.
-     *
-     * @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`.
+     * Custom content renderer.
      *
-     * @default true
+     * @example
+     * ```tsx
+     * <SidebarLayout>
+     *   {({ Outlet }) => (
+     *     <>
+     *       <CustomHeader />
+     *       <Outlet />
+     *       <CustomFooter />
+     *     </>
+     *   )}
+     * </SidebarLayout>
+     * ```
      */
-    collapsible?: boolean;
+    children?: (props: {
+        Outlet: () => React.ReactNode;
+    }) => React.ReactNode;
+    /** Not available alongside `header`/`children` — see the `body` overload. */
+    body?: never;
 };
 
+/**
+ * Either the default layout (`header` + `children`) or the ejected one (`body`)
+ * — never both. Passing `body` alongside `header`/`children` is a type error,
+ * because `body` replaces the very region those two describe.
+ */
+export declare type SidebarLayoutProps = SidebarLayoutDefaultProps | SidebarLayoutBodyProps;
+
+export declare function SidebarMenuButton({ render, isActive, variant, size, tooltip, className, children, onClick, ...props }: React_2.ComponentProps<"button"> & {
+    render?: React_2.ReactElement;
+    isActive?: boolean;
+    tooltip?: string | React_2.ComponentProps<typeof Tooltip.Content>;
+} & VariantProps<typeof sidebarMenuButtonVariants>): JSX.Element;
+
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare function SidebarMenuItem({ className, ...props }: React_2.ComponentProps<"li">): JSX.Element;
+
 /**
  * A visual divider for sidebar navigation.
  *
@@ -5865,6 +6545,59 @@ export declare interface SortState {
     direction: "Asc" | "Desc";
 }
 
+declare function Source({ title, className, ...props }: SourceProps): JSX.Element;
+
+declare type SourceProps = Omit<ComponentProps<"button">, "title"> & {
+    /** Display name of the cited document. */
+    title: string;
+};
+
+/**
+ * Collapsible citation list for a grounded answer. Renders a compact
+ * "Used N sources" trigger under the answer; expanding lists each source the
+ * model actually consulted.
+ *
+ * @example
+ * ```tsx
+ * <AIChat.Sources>
+ *   <AIChat.SourcesTrigger count={sources.length} />
+ *   <AIChat.SourcesContent>
+ *     {sources.map((s) => (
+ *       <AIChat.Source key={s.id} title={s.title} onClick={() => open(s.id)} />
+ *     ))}
+ *   </AIChat.SourcesContent>
+ * </AIChat.Sources>
+ * ```
+ */
+declare function Sources({ className, children, ...props }: SourcesProps): JSX.Element;
+
+declare function SourcesContent({ className, ...props }: SourcesContentProps): JSX.Element;
+
+declare type SourcesContentProps = ComponentProps<typeof DisclosurePanel>;
+
+declare type SourcesProps = Omit<ComponentProps<typeof DisclosureRoot>, "children"> & {
+    children: ReactNode;
+};
+
+declare function SourcesTrigger({ count, className, ...props }: SourcesTriggerProps): JSX.Element;
+
+declare type SourcesTriggerProps = Omit<ComponentProps<typeof DisclosureTrigger>, "children"> & {
+    count: number;
+};
+
+export declare function Spinner({ className, size, width, height, ...props }: SpinnerProps): JSX.Element;
+
+declare const SPINNER_SIZES: {
+    readonly xs: 12;
+    readonly sm: 14;
+    readonly default: 16;
+    readonly lg: 20;
+};
+
+export declare type SpinnerProps = React_2.ComponentProps<"svg"> & {
+    size?: keyof typeof SPINNER_SIZES;
+};
+
 /** Groups all parts of a submenu. */
 declare function SubmenuRoot({ children, ...props }: SubmenuRootProps): JSX.Element;
 
@@ -5883,16 +6616,33 @@ declare namespace SubmenuTrigger {
     var displayName: string;
 }
 
+/**
+ * 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.
+ */
+declare function Suggestion({ suggestion, onSelect, className, disabled, children }: SuggestionProps): JSX.Element;
+
+declare type SuggestionProps = Pick<React_2.ComponentProps<typeof Button>, "className" | "disabled" | "children"> & {
+    /** Prompt text; submitted through `onSelect`, and shown unless `children` overrides it. */
+    suggestion: string;
+    onSelect?: (suggestion: string) => void;
+};
+
+/** Wraps a row of starter-prompt chips for the empty conversation state. */
+declare function Suggestions({ className, children, ...props }: SuggestionsProps): JSX.Element;
+
+declare type SuggestionsProps = React_2.ComponentProps<"div">;
+
 /** An individual interactive tab button that toggles the corresponding panel. */
-declare function Tab({ className, children, ...props }: React_2.ComponentProps<typeof Tabs_2.Tab>): JSX.Element;
+declare function Tab({ className, children, ref: forwardedRef, ...props }: React_2.ComponentProps<typeof Tabs_2.Tab>): JSX.Element;
 
 declare namespace Tab {
     var displayName: string;
 }
 
 export declare const Table: {
-    Root: typeof Root_4;
-    Header: typeof Header_2;
+    Root: typeof Root_5;
+    Header: typeof Header_3;
     Body: typeof Body_2;
     Footer: typeof Footer;
     Row: typeof Row;
@@ -5954,7 +6704,7 @@ export declare type TableOrderableFieldName<TTable extends TableMetadata> = Extr
 } ? N extends string ? N : never : never;
 
 export declare const Tabs: {
-    Root: typeof Root_11;
+    Root: typeof Root_12;
     List: typeof List;
     Tab: typeof Tab;
     Panel: typeof Panel;
@@ -6043,9 +6793,9 @@ export { Time }
  * ```
  */
 export declare const Timeline: {
-    Root: typeof Root_13;
+    Root: typeof Root_14;
     Viewport: typeof Viewport;
-    Row: typeof Row_2;
+    Row: typeof Row_3;
     Interval: typeof Interval;
     Link: typeof TimelineLink;
 };
@@ -6410,10 +7160,87 @@ declare namespace Title_3 {
 
 export { To }
 
+/**
+ * Collapsible tool-call card. Shows which tool the model invoked and its live
+ * status in the header; expanding reveals the input parameters and the result
+ * (or error) as JSON.
+ *
+ * @example
+ * ```tsx
+ * <AIChat.Tool>
+ *   <AIChat.ToolHeader toolName="search_kb" state={call.state} />
+ *   <AIChat.ToolContent>
+ *     <AIChat.ToolInput input={call.input} />
+ *     <AIChat.ToolOutput output={call.output} errorText={call.errorText} />
+ *   </AIChat.ToolContent>
+ * </AIChat.Tool>
+ * ```
+ */
+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;
+};
+
+declare type ToolbarGroupProps = React_2.ComponentProps<"div">;
+
+export declare type ToolbarProps = React_2.ComponentProps<"div">;
+
+declare type ToolbarRowProps = Omit<React_2.ComponentProps<"div">, "role" | "onKeyDown"> & {
+    /** Distribute the row's outer groups between its two edges. */
+    justify?: "start" | "between";
+    onKeyDown?: React_2.KeyboardEventHandler<HTMLDivElement>;
+};
+
+declare type ToolbarSeparatorProps = Omit<React_2.ComponentProps<"div">, "role" | "aria-orientation">;
+
+declare function ToolContent({ className, ...props }: ToolContentProps): JSX.Element;
+
+declare type ToolContentProps = ComponentProps<typeof DisclosurePanel>;
+
+declare function ToolHeader({ toolName, state, title, className, ...props }: ToolHeaderProps): JSX.Element;
+
+declare type ToolHeaderProps = Omit<ComponentProps<typeof DisclosureTrigger>, "children" | "title"> & {
+    toolName: string;
+    state: ToolState;
+    /** Human-readable label shown instead of the raw tool name. */
+    title?: string;
+};
+
+declare function ToolInput({ input, className, ...props }: ToolInputProps): JSX.Element;
+
+declare type ToolInputProps = ComponentProps<"div"> & {
+    input: unknown;
+};
+
+declare function ToolOutput({ output, errorText, className, ...props }: ToolOutputProps): JSX.Element | null;
+
+declare type ToolOutputProps = ComponentProps<"div"> & {
+    output?: unknown;
+    errorText?: string;
+};
+
+declare type ToolProps = Omit<ComponentProps<typeof DisclosureRoot>, "children"> & {
+    children: ReactNode;
+};
+
+/**
+ * Maps 1:1 to the AI SDK's tool-part lifecycle, so a streaming loop can
+ * update a call in place as parts arrive:
+ * - `input-streaming` — the model is still writing the arguments
+ * - `input-available` — arguments complete, tool executing
+ * - `output-available` — finished with a result
+ * - `output-error` — finished with an error
+ */
+export declare type ToolState = "input-streaming" | "input-available" | "output-available" | "output-error";
+
 export declare const Tooltip: {
-    Root: typeof Root_12;
-    Trigger: typeof Trigger_4;
-    Content: typeof Content_5;
+    Root: typeof Root;
+    Trigger: typeof Trigger;
+    Content: typeof Content;
     Provider: typeof Provider;
 };
 
@@ -6421,34 +7248,44 @@ declare type TooltipRootProps = Pick<React_2.ComponentProps<typeof Tooltip_2.Roo
     children: React_2.ReactNode;
 };
 
-/** The element that opens the dialog when clicked. */
-declare function Trigger({ ...props }: React_2.ComponentProps<typeof Dialog_2.Trigger>): JSX.Element;
+/** 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 menu when clicked. */
-declare function Trigger_2({ ...props }: React_2.ComponentProps<typeof Menu_2.Trigger>): JSX.Element;
+/** 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 sheet when clicked. */
-declare function Trigger_3({ ...props }: React_2.ComponentProps<typeof Drawer.Trigger>): JSX.Element;
+/** 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 triggers the tooltip on hover or focus. */
-declare function Trigger_4({ ...props }: React_2.ComponentProps<typeof Tooltip_2.Trigger>): JSX.Element;
+/** 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;
 }
 
+declare type TriggerProps = {
+    /** Extra classes for the trigger button. */
+    className?: string;
+    /**
+     * Runs before the sidebar toggles. The toggle itself is not cancellable —
+     * use `useAppShellSidebar()` if you need to drive the state directly.
+     */
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+};
+
 /**
  * Metadata-aware collection variables that remain assignable to the broad
  * `CollectionVariables` shape expected by GraphQL clients.
@@ -6565,6 +7402,23 @@ export declare const useAppShellData: () => AppShellDataContextType;
  */
 export declare function useAppShellScrollContainer(): RefObject<HTMLElement | null>;
 
+/**
+ * Read and control the AppShell sidebar's collapsed state.
+ *
+ * Use this instead of observing `[data-slot="sidebar"][data-state]` or clicking
+ * the trigger through the DOM — those reach into internals that can change
+ * between releases.
+ *
+ * ```tsx
+ * const { open, toggle } = useAppShellSidebar();
+ * return <button onClick={toggle}>{open ? "Hide nav" : "Show nav"}</button>;
+ * ```
+ *
+ * Outside a `SidebarLayout` there is no sidebar to describe, so this reports
+ * `open: true` with no-op setters rather than throwing.
+ */
+export declare function useAppShellSidebar(): AppShellSidebarState;
+
 /**
  * Hook that encapsulates the async select pattern — fetching on open,
  * request cancellation via `AbortController`, and loading/error state.
@@ -6786,7 +7640,7 @@ declare type UseAttachmentReturn = {
  *   const { isAuthenticated, isReady, login, logout } = useAuth();
  *
  *   if (!isReady) return <Loading />;
- *   if (!isAuthenticated) return <button onClick={login}>Log In</button>;
+ *   if (!isAuthenticated) return <button onClick={() => void login()}>Log In</button>;
  *
  *   return <button onClick={logout}>Log Out</button>;
  * }
@@ -6796,7 +7650,7 @@ export declare const useAuth: () => {
     error: string | null;
     isAuthenticated: boolean;
     isReady: boolean;
-    login: () => Promise<void>;
+    login: Login;
     logout: () => Promise<void>;
     checkAuthStatus: () => Promise<AuthState>;
 };
@@ -6840,7 +7694,7 @@ export declare const useAuth: () => {
  *   // isReady is guaranteed to be true here (Suspense handles loading)
  *
  *   if (!isAuthenticated) {
- *     return <button onClick={login}>Log In</button>;
+ *     return <button onClick={() => void login()}>Log In</button>;
  *   }
  *
  *   return (
@@ -6855,7 +7709,7 @@ export declare const useAuth: () => {
 export declare const useAuthSuspense: () => {
     error: string | null;
     isAuthenticated: boolean;
-    login: () => Promise<void>;
+    login: Login;
     logout: () => Promise<void>;
     checkAuthStatus: () => Promise<AuthState>;
 };
@@ -7397,6 +8251,19 @@ export declare const usePageMeta: (path: string) => PageMeta | null;
 
 export { useParams }
 
+/**
+ * Hook to retrieve the current path segments and their corresponding titles.
+ */
+export declare const usePathSegments: () => {
+    basePath: string | null;
+    segments: {
+        segment: string;
+        path: string;
+        title: string;
+        clickable: boolean;
+    }[];
+};
+
 /**
  * Declaratively register contextual actions to the CommandPalette.
  *
@@ -7664,92 +8531,97 @@ export { ZonedDateTime }
 export { }
 
 
-declare namespace AutocompleteStandalone {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteAsyncStandalone {
+declare namespace Viewport {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteRoot {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteValue {
+declare namespace Interval {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteInput {
+declare namespace TimelineLink {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteTrigger {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteInputGroup {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteContent {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteList {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteItem {
+declare namespace List {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteEmpty {
+declare namespace Tab {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteClear {
+declare namespace Panel {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteGroup {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteGroupLabel {
+declare namespace Image {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteCollection {
+declare namespace Fallback {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteStatus {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Viewport {
+declare namespace Body {
+    var displayName: string;
+}
+
+
+declare namespace Footer {
     var displayName: string;
 }
 
@@ -7759,17 +8631,17 @@ declare namespace Row {
 }
 
 
-declare namespace Interval {
+declare namespace Head {
     var displayName: string;
 }
 
 
-declare namespace TimelineLink {
+declare namespace Cell {
     var displayName: string;
 }
 
 
-declare namespace Provider {
+declare namespace Caption {
     var displayName: string;
 }
 
@@ -7779,7 +8651,7 @@ declare namespace Root {
 }
 
 
-declare namespace Trigger {
+declare namespace Header {
     var displayName: string;
 }
 
@@ -7789,42 +8661,42 @@ declare namespace Content {
 }
 
 
-declare namespace SelectRoot {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace SelectTrigger {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace SelectValue {
+declare namespace Close {
     var displayName: string;
 }
 
 
-declare namespace SelectContent {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace SelectItem {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace SelectGroup {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace SelectGroupLabel {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace SelectSeparator {
+declare namespace Description {
     var displayName: string;
 }
 
@@ -7834,102 +8706,112 @@ declare namespace Root {
 }
 
 
-declare namespace Trigger {
+declare namespace Label {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Control {
     var displayName: string;
 }
 
 
-declare namespace Item {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace LinkItem {
+declare namespace Error {
     var displayName: string;
 }
 
 
-declare namespace CheckboxItem {
+declare namespace Validity {
     var displayName: string;
 }
 
 
-declare namespace CheckboxItemIndicator {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace RadioItem {
+declare namespace Legend {
     var displayName: string;
 }
 
 
-declare namespace RadioItemIndicator {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace RadioGroup {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace Group {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace GroupLabel {
+declare namespace Item {
     var displayName: string;
 }
 
 
-declare namespace MenuSeparator {
+declare namespace LinkItem {
     var displayName: string;
 }
 
 
-declare namespace SubmenuRoot {
+declare namespace CheckboxItem {
     var displayName: string;
 }
 
 
-declare namespace SubmenuTrigger {
+declare namespace CheckboxItemIndicator {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace RadioItem {
     var displayName: string;
 }
 
 
-declare namespace Image {
+declare namespace RadioItemIndicator {
     var displayName: string;
 }
 
 
-declare namespace Fallback {
+declare namespace RadioGroup {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Group {
     var displayName: string;
 }
 
 
-declare namespace Title {
+declare namespace GroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace MenuSeparator {
+    var displayName: string;
+}
+
+
+declare namespace SubmenuRoot {
+    var displayName: string;
+}
+
+
+declare namespace SubmenuTrigger {
     var displayName: string;
 }
 
@@ -7979,57 +8861,77 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace Body {
+declare namespace Group {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace Separator {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace SelectRoot {
     var displayName: string;
 }
 
 
-declare namespace Head {
+declare namespace SelectTrigger {
     var displayName: string;
 }
 
 
-declare namespace Cell {
+declare namespace SelectValue {
     var displayName: string;
 }
 
 
-declare namespace Caption {
+declare namespace SelectContent {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace SelectItem {
     var displayName: string;
 }
 
 
-declare namespace List {
+declare namespace SelectGroup {
     var displayName: string;
 }
 
 
-declare namespace Tab {
+declare namespace SelectGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Panel {
+declare namespace SelectSeparator {
+    var displayName: string;
+}
+
+
+declare namespace Provider {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Trigger {
+    var displayName: string;
+}
+
+
+declare namespace Content {
     var displayName: string;
 }
 
@@ -8119,97 +9021,97 @@ declare namespace ComboboxCollection {
 }
 
 
-declare namespace DataTableRoot {
+declare namespace AutocompleteStandalone {
     var displayName: string;
 }
 
 
-declare namespace DataTableTable {
+declare namespace AutocompleteAsyncStandalone {
     var displayName: string;
 }
 
 
-declare namespace DataTableFooter {
+declare namespace AutocompleteRoot {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace AutocompleteValue {
     var displayName: string;
 }
 
 
-declare namespace Label {
+declare namespace AutocompleteInput {
     var displayName: string;
 }
 
 
-declare namespace Control {
+declare namespace AutocompleteTrigger {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace AutocompleteInputGroup {
     var displayName: string;
 }
 
 
-declare namespace Error {
+declare namespace AutocompleteContent {
     var displayName: string;
 }
 
 
-declare namespace Validity {
+declare namespace AutocompleteList {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace AutocompleteItem {
     var displayName: string;
 }
 
 
-declare namespace Legend {
+declare namespace AutocompleteEmpty {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace AutocompleteClear {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace AutocompleteGroup {
     var displayName: string;
 }
 
 
-declare namespace Close {
+declare namespace AutocompleteGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace AutocompleteCollection {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace AutocompleteStatus {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace DataTableRoot {
     var displayName: string;
 }
 
 
-declare namespace Title {
+declare namespace DataTableTable {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace DataTableFooter {
     var displayName: string;
 }
 
@@ -8219,27 +9121,17 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
-    var displayName: string;
-}
-
-
-declare namespace Content {
-    var displayName: string;
-}
-
-
-declare namespace Root {
+declare namespace Items {
     var displayName: string;
 }
 
 
-declare namespace Items {
+declare namespace Item {
     var displayName: string;
 }
 
 
-declare namespace Item {
+declare namespace DataTableColumnSettings {
     var displayName: string;
 }
 
@@ -8257,8 +9149,3 @@ declare namespace DataTableFilters {
 declare namespace AsyncErrorState {
     var displayName: string;
 }
-
-
-declare namespace DataTableColumnSettings {
-    var displayName: string;
-}