@tailor-platform/app-shell 1.18.0 → 1.19.0

package/dist/app-shell.d.ts

@@ -124,7 +124,7 @@ declare interface ActionItem {
  * />
  * ```
  */
-export declare function ActionPanel({ title, actions, className }: ActionPanelProps): JSX.Element;
+export declare function ActionPanel({ title, actions, emptyContent, className }: ActionPanelProps): JSX.Element;
 
 /**
  * Props for the ActionPanel component.
@@ -134,6 +134,12 @@ export declare interface ActionPanelProps {
     title: string;
     /** List of actions to render */
     actions: ActionItem[];
+    /**
+     * Content shown with consistent padding when actions is empty. Defaults to a localized "No actions available" message.
+     * Strings use the default body text styling; other React nodes render unchanged.
+     * Pass null to hide the empty content and its additional vertical spacing while keeping the card and title.
+     */
+    emptyContent?: ReactNode;
     /** Additional CSS classes for the card container */
     className?: string;
 }
@@ -151,7 +157,7 @@ declare type ActionsProps = React_2.ComponentProps<"div">;
 export declare const ActivityCard: typeof ActivityCardStandalone & {
     Root: typeof Root_3;
     Items: typeof Items;
-    Item: typeof Item;
+    Item: typeof Item_2;
 };
 
 /**
@@ -239,6 +245,44 @@ export declare interface ActivityCardRootProps<T extends ActivityCardBaseItem> {
  */
 declare function ActivityCardStandalone({ items, title, maxVisible, overflowLabel, groupBy, className, }: ActivityCardProps): JSX.Element;
 
+/** A reusable aggregation over selected row values, optionally followed by a result transformation. */
+export declare type Aggregation<TRow, TResult = number | null> = (context: {
+    rows: readonly TRow[];
+}) => TResult;
+
+/**
+ * Create reusable callbacks over `{ rows }`, independent of UI and column definitions.
+ * Selectors choose each row's value; an optional transformer receives the final
+ * result once, including empty or invalid results. Neither callback should mutate rows.
+ */
+export declare const aggregations: {
+    /** Sum finite selected numbers. Empty input returns zero; invalid input returns null. */
+    sum: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Average non-nullish finite selected numbers; empty or invalid input returns null. */
+    avg: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Minimum finite selected number; empty or invalid input returns null. */
+    min: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Maximum finite selected number; empty or invalid input returns null. */
+    max: {
+        <TRow>(selector: (row: TRow) => NumericValue, transformer?: undefined): Aggregation<TRow, number | null>;
+        <TRow, TResult>(selector: (row: TRow) => NumericValue, transformer: (value: number | null) => TResult): Aggregation<TRow, TResult>;
+    };
+    /** Count non-nullish selected values, including zero, false, and empty strings. */
+    count: {
+        <TRow>(selector: (row: TRow) => unknown, transformer?: undefined): Aggregation<TRow, number>;
+        <TRow, TResult>(selector: (row: TRow) => unknown, transformer: (value: number) => TResult): Aggregation<TRow, TResult>;
+    };
+};
+
 export declare const AIChat: AIChatComponent;
 
 export declare type AIChatCompletionEvent = {
@@ -1060,7 +1104,7 @@ export declare interface BadgeProps extends React_2.HTMLAttributes<HTMLDivElemen
 export declare type BadgeVariant = NonNullable<BadgeProps["variant"]>;
 
 export declare const badgeVariants: (props?: ({
-    variant?: "default" | "error" | "success" | "warning" | "neutral" | "info" | "subtle-success" | "subtle-warning" | "subtle-error" | "subtle-info" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
+    variant?: "default" | "error" | "success" | "warning" | "neutral" | "info" | "subtle-success" | "subtle-warning" | "subtle-error" | "subtle-info" | "subtle-neutral" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
 } & ClassProp) | undefined) => string;
 
 export { Blocker }
@@ -1215,16 +1259,45 @@ declare interface CellEditBase<TRow extends Record<string, unknown>, TValue, TDr
      * Observes editor drafts, including incomplete input and restored drafts on
      * cancellation. Direct inputs emit raw strings; choices emit selected values,
      * not search text or highlights. Updating `data` here is outside the supported
-     * coordination contract. The return value is ignored.
+     * coordination contract. A failed change check retains its draft and blocks
+     * confirmation; pending change checks finish before `onValueCommitted` runs.
+     * Cancellation notifications cannot create a new cell error after discarding
+     * the draft. Pass `error: false` for unobserved callback behavior.
      */
     onValueChange?: (row: TRow, draft: TDraft) => void;
     /**
-     * Notifies a changed, confirmed editor output, compared with current `data`.
-     * Empty cells confirm `null`. Confirmation does not imply business validation,
-     * adoption, or persistence; update `data` here to adopt it. Return values are
-     * ignored. Output types follow the editor, not the row field's runtime type.
+     * Attempts to confirm a changed editor output, compared with current `data`.
+     * Empty cells confirm `null`. A normal return or fulfilled Promise completes
+     * the edit; throw/rejection retains the draft and error for correction or retry.
+     * Focus may leave while pending. Update `data` here to adopt a successful value;
+     * DataTable does not persist or roll back consumer state. Output types follow
+     * the editor, not the row field's runtime type.
      */
     onValueCommitted: (row: TRow, value: TValue | null) => void;
+    /**
+     * Callback failures automatically open an error popover without moving focus.
+     * Only non-empty `CellEditError` messages are displayed by the standard UI;
+     * other failures use localized generic feedback. Translate messages before throwing.
+     * Pass `false` to disable interception and retain eager edit completion, or
+     * `render` to replace the popover's body. Closing the details retains the draft
+     * and error; reopen with the error icon or Alt+ArrowDown. Esc closes open details
+     * first, then restores current data and clears the error. The standard popover
+     * adds no reset action; custom content may include consumer-owned actions.
+     */
+    error?: false | {
+        render: (ctx: {
+            row: TRow;
+            error: unknown;
+        }) => ReactNode;
+    };
+}
+
+/**
+ * A cell-editing failure whose message is safe to display to the user.
+ * Translate the message before throwing; other errors use generic feedback.
+ */
+export declare class CellEditError extends globalThis.Error {
+    name: string;
 }
 
 /** Row state passed to `edit.canEdit` alongside the row. */
@@ -1673,6 +1746,17 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
      * across spread-then-override patterns like `column({ ...inferred, render })`.
      */
     render?: (row: TRow) => ReactNode;
+    /**
+     * Sets `className`, `style`, and `title` on the data cell's `<td>`, including
+     * its padding, based on the row. Return `undefined` to keep the defaults.
+     * Classes are merged with the built-in classes; CSS specificity still applies.
+     * An inline `style.backgroundColor` remains visible during row hover and
+     * selection, including on pinned cells. Use an opaque background for pinned
+     * cells to prevent content bleeding through. Column `width` and sticky
+     * positioning take precedence over `style`. Content stays owned by `render`;
+     * events, refs, and cell spanning are not configurable through this hook.
+     */
+    cellProps?: (row: TRow) => Pick<ComponentProps<"td">, "className" | "style" | "title"> | undefined;
     /**
      * Custom header renderer.
      *
@@ -1685,6 +1769,40 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
      * still driven by `label`, `sort`, and other column metadata.
      */
     header?: (ctx: HeaderRenderContext) => ReactNode;
+    /**
+     * Sets `className`, `style`, and `title` on this column's header `<th>`.
+     * Receives the same context as `header`; return `undefined` to keep the defaults.
+     * Classes are merged with the built-in classes; column `width` and sticky
+     * positioning take precedence over `style`. Use an opaque background for
+     * pinned headers. Content stays owned by `header` or the default renderer;
+     * sorting and context-menu behavior are unchanged. Built-in selection,
+     * expansion, and action headers are not affected.
+     */
+    headerProps?: (ctx: HeaderRenderContext) => Pick<ComponentProps<"th">, "className" | "style" | "title"> | undefined;
+    /**
+     * Content for this column's cell in a sticky table footer: a static string
+     * or a renderer receiving the current `data.rows` (the current page, not all
+     * records or only selected rows). `type` and `typeOptions` do not apply.
+     *
+     * A footer row appears when any visible column defines a footer, including
+     * an empty string. Columns without one leave a blank cell; hidden columns'
+     * callbacks are not called.
+     * Loading keeps the footer row with skeletons without calling renderers.
+     * Hidden during errors; loaded empty data receives `rows: []`.
+     * Separate from `DataTable.Footer`, the pagination / bulk-action container.
+     */
+    footer?: string | ((ctx: FooterRenderContext<TRow>) => ReactNode);
+    /**
+     * Sets `className`, `style`, and `title` on this column's footer `<td>`.
+     * Receives the same context as `footer`; return `undefined` to keep the defaults.
+     * Classes are merged with the built-in classes; column `width` and sticky
+     * positioning take precedence over `style`. Use an opaque background for
+     * pinned footer cells. Content stays owned by `footer`; events, refs, and
+     * cell spanning are not configurable through this hook.
+     * Does not create a footer row by itself. Not called while loading, on errors,
+     * or for hidden columns. Built-in utility footer cells are not affected.
+     */
+    footerProps?: (ctx: FooterRenderContext<TRow>) => Pick<ComponentProps<"td">, "className" | "style" | "title"> | undefined;
     /**
      * Stable identifier used for column visibility toggling, persisted layout
      * state, raw-value fallback (`row[col.id]`), and as the React key. Falls
@@ -2359,11 +2477,15 @@ export declare type ContextData = AppShellRegister extends {
 } ? T : Record<string, unknown>;
 
 /**
- * A styled input control for the field.
+ * A styled text input for the field.
  *
- * Can be omitted when using another Base UI-backed AppShell input component
- * (e.g. Select, Combobox, Autocomplete) as a sibling — those components
- * register themselves with the Field context automatically.
+ * Use it for plain text-like inputs, or pass a native element to `render`
+ * (e.g. `render={<textarea />}`). `Select`, `Combobox`, `Autocomplete`,
+ * `Checkbox`, `Textarea`, `DateField`, `DatePicker` and `DateRangePicker` go
+ * directly under `Field.Root` instead: each draws its own frame and registers
+ * with the Field context itself. Passing one to `render` draws a second frame
+ * and logs a warning. `Input` does not connect to `Field.Root` — use
+ * `Field.Control` in its place inside a field.
  */
 declare function Control({ className, ...props }: React_2.ComponentProps<typeof Field_2.Control>): JSX.Element;
 
@@ -2684,7 +2806,8 @@ export declare const DataTable: {
     /** Built-in column visibility, ordering, and pinning controls. */
     readonly ColumnSettings: typeof DataTableColumnSettings;
     /**
-     * Renders `<table>` with built-in `Headers` and `Body`.
+     * Renders `<table>` with built-in headers, body, and a sticky footer row
+     * when a visible column defines `footer`.
      * Place inside `DataTable.Root`.
      */
     readonly Table: typeof DataTableTable;
@@ -3706,6 +3829,23 @@ declare type DynamicLocales<Def extends Record<string, LabelValue>> = {
     [locale: string]: Partial<LabelDefinition<Def>> | undefined;
 };
 
+/**
+ * The role each element component applies when no `variant` is given. They
+ * follow `defaultTagNames`: body roles render `p`, label roles render `span`.
+ * `div` is a block element like `p`, so it gets the default role of `Text`.
+ */
+declare const elementDefaultVariants: {
+    readonly h1: "heading-lg";
+    readonly h2: "heading-md";
+    readonly h3: "heading-sm";
+    readonly h4: "heading-sm";
+    readonly h5: "heading-sm";
+    readonly h6: "heading-sm";
+    readonly p: "body-md";
+    readonly span: "label-md";
+    readonly div: "body-md";
+};
+
 /**
  * Behavior when a field value is empty/null/undefined
  */
@@ -4229,6 +4369,12 @@ declare namespace Footer_3 {
     var displayName: string;
 }
 
+/** Context passed to custom column `footer` renderers and `footerProps` callbacks. */
+export declare interface FooterRenderContext<TRow extends Record<string, unknown>> {
+    /** Current `data.rows` (the current page, not all records or only selected rows). */
+    rows: readonly TRow[];
+}
+
 /**
  * A form element with consolidated error handling and validation.
  *
@@ -4553,17 +4699,20 @@ export declare interface GridProps extends React_2.ComponentProps<"div"> {
     justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
 }
 
+/** An expandable group with optional separation of its heading action and expand control. */
+declare function Group({ title, icon, render, isActive, onClick, expandOnClick, defaultOpen, children, ...props }: GroupProps): JSX.Element;
+
 /** Groups related menu items with the corresponding label. */
-declare function Group({ ...props }: React_2.ComponentProps<typeof Menu_2.Group>): JSX.Element;
+declare function Group_2({ ...props }: React_2.ComponentProps<typeof Menu_2.Group>): JSX.Element;
 
-declare namespace Group {
+declare namespace Group_2 {
     var displayName: string;
 }
 
 /** A related group of controls within a toolbar row. */
-declare function Group_2({ className, ...props }: ToolbarGroupProps): JSX.Element;
+declare function Group_3({ className, ...props }: ToolbarGroupProps): JSX.Element;
 
-declare namespace Group_2 {
+declare namespace Group_3 {
     var displayName: string;
 }
 
@@ -4574,6 +4723,23 @@ declare namespace GroupLabel {
     var displayName: string;
 }
 
+declare type GroupProps = Omit<React_2.ComponentProps<"li">, "title" | "onClick"> & {
+    /** Group label with meaningful accessible text; do not nest interactive elements. */
+    title: React_2.ReactNode;
+    icon?: React_2.ReactNode;
+    /** Replaces the main heading operation without changing expansion behavior. */
+    render?: React_2.ReactElement;
+    isActive?: boolean;
+    /** Runs only for the heading operation, not children or a separate expand button. */
+    onClick?: React_2.MouseEventHandler<HTMLButtonElement>;
+    /** Whether clicking the heading toggles the child list; false requires an operation. @default true */
+    expandOnClick?: boolean;
+    /** Whether the child list starts expanded. @default true */
+    defaultOpen?: boolean;
+} & ({
+    expandOnClick?: true;
+} | RequiredOperation);
+
 /**
  * Guard function type.
  * Guards are executed in order and stop on the first non-pass result.
@@ -4712,7 +4878,7 @@ declare type HeaderProps_2 = {
 };
 
 /**
- * Context passed to custom `header` renderers.
+ * Context passed to custom `header` renderers and `headerProps` callbacks.
  */
 export declare type HeaderRenderContext = NonSortableHeaderRenderContext | SortableHeaderRenderContext;
 
@@ -4806,16 +4972,19 @@ declare namespace Interval {
  */
 declare type IsEmptyObject<T> = keyof T extends never ? true : false;
 
-declare function Item({ indicator, children, className }: ActivityCardItemProps): JSX.Element;
+/** A compact link or action row. No AppShell, router, or Sidebar provider is required. */
+declare function Item({ icon, children, disabled, render, tabIndex, className, ...props }: ItemProps): JSX.Element;
+
+declare function Item_2({ indicator, children, className }: ActivityCardItemProps): JSX.Element;
 
-declare namespace Item {
+declare namespace Item_2 {
     var displayName: string;
 }
 
 /** An individual interactive item in the menu. */
-declare function Item_2({ className, ...props }: React_2.ComponentProps<typeof Menu_2.Item>): JSX.Element;
+declare function Item_3({ className, ...props }: React_2.ComponentProps<typeof Menu_2.Item>): JSX.Element;
 
-declare namespace Item_2 {
+declare namespace Item_3 {
     var displayName: string;
 }
 
@@ -4831,6 +5000,24 @@ export declare interface ItemGroup<T> {
     items: T[];
 }
 
+/** Compact icon-and-label lists with links, actions, groups, sections, and separators. */
+export declare const ItemList: {
+    Root: typeof ListRoot;
+    Item: typeof Item;
+    Group: typeof Group;
+    Section: typeof Section;
+    Separator: typeof Separator;
+};
+
+declare type ItemProps = React_2.ComponentProps<"button"> & {
+    /** Optional decorative leading icon. */
+    icon?: React_2.ReactNode;
+    /** Visual emphasis only; aria-current="page" also supplies active styling. */
+    isActive?: boolean;
+    /** Replaces the inner button, not the containing list item. */
+    render?: React_2.ReactElement;
+} & RequiredOperation;
+
 declare function Items<T extends ActivityCardBaseItem>({ children }: ActivityCardItemsProps<T>): JSX.Element;
 
 declare namespace Items {
@@ -5013,6 +5200,8 @@ declare namespace List {
     var displayName: string;
 }
 
+declare function ListRoot({ className, ...props }: React_2.ComponentProps<"ul">): JSX.Element;
+
 declare type LoaderHandler = (args: LoaderFunctionArgs) => Promise<unknown> | unknown;
 
 declare type LocalizedString = string | ((locale: string) => string);
@@ -5038,14 +5227,14 @@ export declare const Menu: {
     Root: typeof Root_10;
     Trigger: typeof Trigger_3;
     Content: typeof Content_4;
-    Item: typeof Item_2;
+    Item: typeof Item_3;
     LinkItem: typeof LinkItem;
     CheckboxItem: typeof CheckboxItem;
     CheckboxItemIndicator: typeof CheckboxItemIndicator;
     RadioItem: typeof RadioItem;
     RadioItemIndicator: typeof RadioItemIndicator;
     RadioGroup: typeof RadioGroup;
-    Group: typeof Group;
+    Group: typeof Group_2;
     GroupLabel: typeof GroupLabel;
     Separator: typeof MenuSeparator;
     SubmenuRoot: typeof SubmenuRoot;
@@ -5264,6 +5453,8 @@ declare type NumberRangeSection<TField extends string = string> = FieldSectionBa
     unit?: ReactNode;
 };
 
+declare type NumericValue = number | null | undefined;
+
 export declare type OpenCommandPaletteOptions = {
     /** Optional initial text to prefill into the palette input. */
     search?: string;
@@ -5597,6 +5788,12 @@ declare type ReasoningTriggerProps = Omit<ComponentProps<typeof DisclosureTrigge
  */
 export declare const redirectTo: (to: string) => GuardResult;
 
+declare type RequiredOperation = {
+    onClick: React_2.MouseEventHandler<HTMLButtonElement>;
+} | {
+    render: React_2.ReactElement;
+};
+
 /** Color theme after resolving `system` to a concrete value. */
 export declare type ResolvedColorTheme = "light" | "dark";
 
@@ -6157,6 +6354,9 @@ export declare type SearchSource = {
     }) => Promise<CommandPaletteSearchResult[]>;
 };
 
+/** A static heading and a flat list, without group indentation or an expand control. */
+declare function Section({ title, children, className, ...props }: SectionProps): JSX.Element;
+
 declare type SectionBase = {
     /** Stable and unique within the rail. Keys the layout and a11y ids. */
     id: string;
@@ -6172,6 +6372,10 @@ declare type SectionBase = {
     defaultCollapsed?: boolean;
 };
 
+declare type SectionProps = Omit<React_2.ComponentProps<"li">, "title"> & {
+    title: string;
+};
+
 /** Every section, in the user's layout. Scrolls; the header stays put. */
 declare function Sections({ className }: SectionsProps): JSX.Element;
 
@@ -6462,10 +6666,13 @@ declare namespace SelectValue {
     var displayName: string;
 }
 
+/** A decorative divider that remains a valid child of a list. */
+declare function Separator({ className, ...props }: Omit<React_2.ComponentProps<"li">, "children">): JSX.Element;
+
 /** A vertical separator for groups within a horizontal toolbar row. */
-declare function Separator({ className, ...props }: ToolbarSeparatorProps): JSX.Element;
+declare function Separator_2({ className, ...props }: ToolbarSeparatorProps): JSX.Element;
 
-declare namespace Separator {
+declare namespace Separator_2 {
     var displayName: string;
 }
 
@@ -7279,16 +7486,22 @@ declare type TabsVariant = "default" | "line" | "capsule";
  * Text with a typography role. The role sets the size, line height, weight,
  * and letter spacing. It does not set the color or choose the heading level.
  *
+ * `Text.h1` to `Text.h6`, `Text.p`, `Text.span`, and `Text.div` always render
+ * their named element, with a default role for that element. They take
+ * `variant`, the element's own attributes, and a ref, but not `render`.
+ *
  * @example
  * ```tsx
  * import { Text } from "@tailor-platform/app-shell";
  *
- * <Text variant="heading-md" render={<h3 />}>Line items</Text>
- * <Text variant="body-md" className="text-muted-foreground">Orders sent this month.</Text>
- * <Text variant="label-md" className="tabular-nums">1,240</Text>
+ * <Text.h1>Purchase orders</Text.h1>
+ * <Text.h3 variant="heading-md">Line items</Text.h3>
+ * <Text.p className="text-muted-foreground">Orders sent this month.</Text.p>
+ * <Text.span className="tabular-nums">1,240</Text.span>
+ * <Text variant="label-md" render={<CustomLabel />}>Quantity</Text>
  * ```
  */
-declare function Text_2({ className, variant, render, children, ref, ...props }: TextProps): React_2.ReactElement<unknown, string | React_2.JSXElementConstructor<any>>;
+declare const Text_2: TextComponent;
 export { Text_2 as Text }
 
 /**
@@ -7368,13 +7581,34 @@ export declare interface TextCellEditOptions<TRow extends Record<string, unknown
     options?: readonly SelectOption[];
 }
 
+/**
+ * Keep the exported static API type explicit instead of relying on
+ * `Object.assign(...)` inference, as `Layout` and `Autocomplete` do.
+ */
+declare type TextComponent = typeof TextRoot & {
+    [T in TextTagName]: TextElementComponent<T>;
+};
+
+declare type TextElementComponent<T extends TextTagName> = {
+    (props: TextElementProps<T>): React_2.JSX.Element;
+    displayName?: string;
+};
+
+declare type TextElementProps<T extends TextTagName> = React_2.ComponentProps<T> & VariantProps<typeof textVariants>;
+
 export declare type TextProps = React_2.HTMLAttributes<HTMLElement> & VariantProps<typeof textVariants> & {
     /** Ref to the rendered element. */
     ref?: React_2.Ref<HTMLElement>;
-    /** Custom element to render as (Base UI render prop). Use it to set the heading level, for example `render={<h3 />}`. */
+    /** Custom element to render as (Base UI render prop). Use it to compose with another component. For a plain HTML element, use `Text.h1` to `Text.h6`, `Text.p`, `Text.span`, or `Text.div`. */
     render?: React_2.ReactElement;
 };
 
+declare function TextRoot({ className, variant, render, children, ref, ...props }: TextProps): React_2.ReactElement<unknown, string | React_2.JSXElementConstructor<any>>;
+
+declare namespace TextRoot {
+    var displayName: string;
+}
+
 /** Free text with one fixed operator. */
 declare type TextSection<TField extends string = string> = FieldSectionBase<TField> & {
     control: "text";
@@ -7386,6 +7620,8 @@ declare type TextSection<TField extends string = string> = FieldSectionBase<TFie
     minLength?: number;
 };
 
+declare type TextTagName = keyof typeof elementDefaultVariants;
+
 declare const textVariants: (props?: ({
     variant?: "heading-lg" | "heading-md" | "heading-sm" | "body-md" | "body-sm" | "label-md" | "label-sm" | "code-sm" | "body-md-relaxed" | "body-sm-relaxed" | null | undefined;
 } & ClassProp) | undefined) => string;
@@ -7796,8 +8032,8 @@ declare function Tool({ className, children, ...props }: ToolProps): JSX.Element
 export declare const Toolbar: {
     Root: typeof Root_13;
     Row: typeof Row_2;
-    Group: typeof Group_2;
-    Separator: typeof Separator;
+    Group: typeof Group_3;
+    Separator: typeof Separator_2;
 };
 
 declare type ToolbarGroupProps = React_2.ComponentProps<"div">;
@@ -9212,37 +9448,37 @@ declare namespace Root {
 }
 
 
-declare namespace Viewport {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace Body {
     var displayName: string;
 }
 
 
-declare namespace Interval {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace TimelineLink {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Head {
     var displayName: string;
 }
 
 
-declare namespace Image {
+declare namespace Cell {
     var displayName: string;
 }
 
 
-declare namespace Fallback {
+declare namespace Caption {
     var displayName: string;
 }
 
@@ -9262,7 +9498,7 @@ declare namespace Description {
 }
 
 
-declare namespace Provider {
+declare namespace TextRoot {
     var displayName: string;
 }
 
@@ -9272,82 +9508,67 @@ declare namespace Root {
 }
 
 
-declare namespace Header {
-    var displayName: string;
-}
-
-
-declare namespace ClearAll {
-    var displayName: string;
-}
-
-
-declare namespace Sections {
-    var displayName: string;
-}
-
-
-declare namespace Trigger {
+declare namespace Image {
     var displayName: string;
 }
 
 
-declare namespace Settings {
+declare namespace Fallback {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace SelectRoot {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace SelectTrigger {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace SelectValue {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace SelectContent {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace SelectItem {
     var displayName: string;
 }
 
 
-declare namespace Body {
+declare namespace SelectGroup {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace SelectGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace SelectSeparator {
     var displayName: string;
 }
 
 
-declare namespace Head {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Cell {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Caption {
+declare namespace Content {
     var displayName: string;
 }
 
@@ -9587,52 +9808,47 @@ declare namespace Separator {
 }
 
 
-declare namespace SelectRoot {
-    var displayName: string;
-}
-
-
-declare namespace SelectTrigger {
+declare namespace Provider {
     var displayName: string;
 }
 
 
-declare namespace SelectValue {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace SelectContent {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace SelectItem {
+declare namespace ClearAll {
     var displayName: string;
 }
 
 
-declare namespace SelectGroup {
+declare namespace Sections {
     var displayName: string;
 }
 
 
-declare namespace SelectGroupLabel {
+declare namespace Provider {
     var displayName: string;
 }
 
 
-declare namespace SelectSeparator {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Provider {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Content {
     var displayName: string;
 }
 
@@ -9642,7 +9858,7 @@ declare namespace Trigger {
 }
 
 
-declare namespace Content {
+declare namespace Settings {
     var displayName: string;
 }
 
@@ -9732,6 +9948,16 @@ declare namespace ComboboxCollection {
 }
 
 
+declare namespace AutocompleteStandalone {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteAsyncStandalone {
+    var displayName: string;
+}
+
+
 declare namespace AutocompleteRoot {
     var displayName: string;
 }
@@ -9802,27 +10028,42 @@ declare namespace AutocompleteStatus {
 }
 
 
-declare namespace AutocompleteStandalone {
+declare namespace DataTableRoot {
     var displayName: string;
 }
 
 
-declare namespace AutocompleteAsyncStandalone {
+declare namespace DataTableTable {
     var displayName: string;
 }
 
 
-declare namespace DataTableRoot {
+declare namespace DataTableFooter {
     var displayName: string;
 }
 
 
-declare namespace DataTableTable {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace DataTableFooter {
+declare namespace Viewport {
+    var displayName: string;
+}
+
+
+declare namespace Row {
+    var displayName: string;
+}
+
+
+declare namespace Interval {
+    var displayName: string;
+}
+
+
+declare namespace TimelineLink {
     var displayName: string;
 }