@tailor-platform/app-shell 1.16.0 → 1.18.0

package/dist/app-shell.d.ts

@@ -456,9 +456,11 @@ export declare type AppShellPageProps = {
         icon?: ReactNode;
         /**
          * Custom breadcrumb segment title for this page.
-         * Can be a static string or a function that receives the URL segment.
+         * Can be a static string or a `labels.t("key")` translation function.
+         * Other callbacks receive the URL segment and may return a LocalizedString
+         * (e.g. `(segment) => labels.t("order", { id: segment })`), resolved using the current locale.
          */
-        breadcrumbTitle?: string | ((segment: string) => string);
+        breadcrumbTitle?: string | ((segment: string) => LocalizedString);
     };
     /**
      * Guards to control access to this page.
@@ -1010,6 +1012,20 @@ export declare const avatarVariants: (props?: ({
 
 export declare function Badge({ className, variant, children, ...props }: BadgeProps): JSX.Element;
 
+/**
+ * `edit` config for `type: "badge"` columns: a dropdown whose choices render as
+ * the same badges the cell shows. Picking one notifies its `value`; a "None"
+ * choice notifies `null`. Single-value columns only.
+ */
+export declare interface BadgeCellEditOptions<TRow extends Record<string, unknown>> extends CellEditBase<TRow, string> {
+    /**
+     * The choices. Default: the entries of `typeOptions.badgeLabelMap`, else the
+     * column's enum `filter` options. A badge column with neither can't be
+     * edited.
+     */
+    options?: readonly SelectOption[];
+}
+
 /** Options for `type: "badge"` cells. */
 declare interface BadgeCellOptions extends BadgeOptions {
     /** Maximum number of badges to display before showing a "+N" overflow indicator */
@@ -1058,6 +1074,18 @@ declare namespace Body_2 {
     var displayName: string;
 }
 
+/** True / false with a third "no constraint" state. */
+declare type BooleanSection<TField extends string = string> = FieldSectionBase<TField> & {
+    control: "boolean";
+    operator?: "eq" | "ne";
+    /** Default "Yes". */
+    trueLabel?: ReactNode;
+    /** Default "No". */
+    falseLabel?: ReactNode;
+    /** Default "Any"; `null` removes it. */
+    anyLabel?: ReactNode | null;
+};
+
 /**
  * Responsive breakpoints, aligned with Tailwind's default breakpoints.
  * `initial` is the base (mobile-first) value applied below the `sm` breakpoint.
@@ -1176,6 +1204,35 @@ declare namespace Cell {
 
 declare type CellAlign = "left" | "center" | "right";
 
+declare interface CellEditBase<TRow extends Record<string, unknown>, TValue, TDraft = TValue | null> {
+    /**
+     * Decides, per row, whether the cell can be edited. Receives the row and
+     * whether it is selected, so "editable once selected" is
+     * `(_, { selected }) => selected`. Default: every row with an `id`.
+     */
+    canEdit?: (row: TRow, state: CellEditState) => boolean;
+    /**
+     * Observes editor drafts, including incomplete input and restored drafts on
+     * cancellation. Direct inputs emit raw strings; choices emit selected values,
+     * not search text or highlights. Updating `data` here is outside the supported
+     * coordination contract. The return value is ignored.
+     */
+    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.
+     */
+    onValueCommitted: (row: TRow, value: TValue | null) => void;
+}
+
+/** Row state passed to `edit.canEdit` alongside the row. */
+export declare interface CellEditState {
+    /** Whether the row is selected. Always `false` when row selection is off. */
+    selected: boolean;
+}
+
 declare type CellProps = React_2.ComponentProps<"td"> & {
     align?: CellAlign;
 };
@@ -1338,6 +1395,40 @@ export declare type CheckboxProps = Omit<React_2.ComponentProps<typeof Checkbox_
     label?: React_2.ReactNode;
 };
 
+/** Multi-select — the `in` (any of) or `nin` (none of) operator. */
+declare type CheckboxSection<TField extends string = string> = FieldSectionBase<TField> & {
+    control: "checkbox";
+    operator?: "in" | "nin";
+    options: readonly FacetOption[];
+    sort?: OptionSort;
+    /**
+     * Options shown before "Show N more". Default 8, `false` shows everything.
+     * A selected option is never truncated away.
+     */
+    truncate?: number | false;
+    /** Option values held at the top, in this order. */
+    pinned?: readonly string[];
+    /**
+     * Above this many options, show a search box. Defaults to `truncate` (so any
+     * list long enough to need "Show more" is searchable), or 12 when nothing is
+     * truncated. `false` never shows it.
+     */
+    searchThreshold?: number | false;
+};
+
+/** Clears only the rail's own fields. Renders nothing while none are active. */
+declare function ClearAll({ children, className }: ClearAllProps): JSX.Element | null;
+
+declare namespace ClearAll {
+    var displayName: string;
+}
+
+declare type ClearAllProps = {
+    /** Default "Clear all". */
+    children?: ReactNode;
+    className?: string;
+};
+
 /** A button that closes the dialog. */
 declare function Close({ ...props }: React_2.ComponentProps<typeof Dialog_2.Close>): JSX.Element;
 
@@ -1758,6 +1849,12 @@ declare type Columns = 3 | 4;
  * and `undefined` are always allowed: every built-in renderer maps them to the
  * `—` placeholder.
  *
+ * `edit` makes the cells editable in place and also narrows per branch, so
+ * `onValueCommitted` receives the editor's output type, not necessarily the
+ * original row field's runtime type. Text / link / badge output strings or null.
+ * Every typed column
+ * supports it; untyped (`render`-only) columns don't.
+ *
  * Prefer `Column<TRow>` in most cases; this is exported so consumers can
  * compose more specific column types.
  */
@@ -1765,30 +1862,37 @@ declare type ColumnTypeBranch<TRow extends Record<string, unknown>> = {
     type?: undefined;
     typeOptions?: never;
     accessor?: (row: TRow) => unknown;
+    edit?: never;
 } | {
     type: "text";
     typeOptions?: never;
     accessor?: (row: TRow) => string | number | boolean | bigint | null | undefined;
+    edit?: TextCellEditOptions<TRow>;
 } | {
     type: "number";
     typeOptions?: NumberCellOptions;
     accessor?: (row: TRow) => number | null | undefined;
+    edit?: NumberCellEditOptions<TRow>;
 } | {
     type: "money";
     typeOptions?: MoneyCellOptions<TRow>;
     accessor?: (row: TRow) => number | null | undefined;
+    edit?: NumberCellEditOptions<TRow>;
 } | {
     type: "date";
     typeOptions?: DateCellOptions;
     accessor?: (row: TRow) => Date | string | number | null | undefined;
+    edit?: DateCellEditOptions<TRow>;
 } | {
     type: "badge";
     typeOptions?: BadgeCellOptions;
     accessor?: (row: TRow) => string | string[] | number | boolean | null | undefined;
+    edit?: BadgeCellEditOptions<TRow>;
 } | {
     type: "link";
     typeOptions: LinkCellOptions<TRow>;
     accessor?: (row: TRow) => string | number | boolean | null | undefined;
+    edit?: TextCellEditOptions<TRow>;
 };
 
 export declare const Combobox: ComboboxComponent;
@@ -2135,7 +2239,7 @@ declare type CommonPageResource = {
     meta: {
         title: LocalizedString;
         icon?: ReactNode;
-        breadcrumbTitle?: string | ((segment: string) => string);
+        breadcrumbTitle?: string | ((segment: string) => LocalizedString);
     };
 };
 
@@ -2194,7 +2298,7 @@ declare namespace Content {
     var displayName: string;
 }
 
-declare function Content_2({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
+declare function Content_2({ className, padding, ...props }: ContentProps): JSX.Element;
 
 declare namespace Content_2 {
     var displayName: string;
@@ -2237,6 +2341,15 @@ export declare type ContentContainerProps = {
     children?: React.ReactNode;
 };
 
+declare type ContentProps = React_2.ComponentProps<"div"> & {
+    /**
+     * `"none"` renders the content edge-to-edge, for a `Table`, `DataTable` or
+     * divided list that should meet the card's border.
+     * @default "default"
+     */
+    padding?: "default" | "none";
+};
+
 /**
  * Context data type inferred from AppShellRegister.
  * Falls back to Record<string, unknown> if not augmented.
@@ -2529,6 +2642,26 @@ export declare type CsvSchema = {
     columns: readonly CsvColumn[];
 };
 
+/**
+ * Anything the built-in controls do not cover. Declares the `fields` it writes
+ * so Clear all, Clear and the settings panel still treat it as rail-owned.
+ */
+declare type CustomSection<TField extends string = string> = SectionBase & {
+    control: "custom";
+    fields: readonly TField[];
+    clearable?: boolean;
+    render: (context: CustomSectionContext<TField>) => ReactNode;
+};
+
+/** What a custom section's `render` receives. */
+declare type CustomSectionContext<TField extends string = string> = {
+    control: CollectionControl<TField>;
+    /** The current filter on `field`, if any. */
+    getFilter: (field: TField) => Filter<TField> | undefined;
+    /** Replace (or with `null`, remove) the filter on `field`. */
+    setFilter: (field: TField, next: Omit<Filter<TField>, "field"> | null) => void;
+};
+
 export declare const DataTable: {
     /**
      * Context/provider root. Wraps all other `DataTable.*` components and
@@ -2558,6 +2691,11 @@ export declare const DataTable: {
     /**
      * Footer container for pagination and other footer content.
      * Place inside `DataTable.Root`, after `DataTable.Table`.
+     *
+     * When `useDataTable()` is given `rowSelection.actions`, the footer becomes the
+     * bulk-action bar while rows are selected — the selection count, the
+     * actions, and a Clear button — with its own children (usually
+     * `DataTable.Pagination`) kept alongside.
      */
     readonly Footer: typeof DataTableFooter;
     /**
@@ -2573,6 +2711,14 @@ export declare const DataTable: {
     readonly Pagination: typeof DataTablePagination;
 };
 
+/** Presentation shared by row actions and selection actions. */
+export declare interface DataTableAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    variant?: "default" | "destructive";
+}
+
 declare type DataTableBooleanFilterOperator = OperatorForFilterType["boolean"];
 
 /**
@@ -2642,15 +2788,29 @@ export declare interface DataTableContextValue<TRow extends Record<string, unkno
     setPin: (key: string, side: "left" | "right" | "none" | null) => void;
     onClickRow?: (row: TRow) => void;
     rowActions?: RowAction<TRow>[];
+    /** Selection config, including bulk actions shown by `DataTable.Footer`. */
+    rowSelection?: RowSelectionOptions;
     selectedIds: string[];
     isRowSelected: (row: TRow) => boolean;
     toggleRowSelection?: (row: TRow) => void;
     /**
-     * Selects all rows on the **current page** only. Cross-page selection is not supported.
-     * Undefined when `onSelectionChange` is not provided.
+     * Adds every row on the **current page** to the selection; rows selected on
+     * other pages are kept.
      */
     selectAllRows?: () => void;
+    /**
+     * Removes the **current page's** rows from the selection; rows selected on
+     * other pages stay selected.
+     */
+    deselectAllRows?: () => void;
+    /** Empties the selection across all pages. */
     clearSelection?: () => void;
+    /** Id of the selection action whose request is in flight, or `null`. */
+    pendingActionId?: string | null;
+    /** See `UseDataTableReturn.runSelectionAction`. */
+    runSelectionAction?: (action: {
+        id: string;
+    }, request: PromiseLike<unknown>) => void;
     isAllSelected: boolean;
     isIndeterminate: boolean;
     /** Ids of the currently expanded rows. */
@@ -2688,6 +2848,10 @@ export declare type DataTableFilterConfig = (Extract<FilterConfig, {
     type: "number";
 }> & {
     operators?: NonEmptyReadonlyArray<DataTableNumericTemporalFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "decimal";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableNumericTemporalFilterOperator>;
 }) | (Extract<FilterConfig, {
     type: "datetime";
 }> & {
@@ -2740,7 +2904,7 @@ declare namespace DataTableFilters {
 
 /** Use `DataTable.Footer` instead of calling this directly. */
 declare function DataTableFooter({ children, className }: {
-    children: ReactNode;
+    children?: ReactNode;
     className?: string;
 }): JSX.Element;
 
@@ -2809,6 +2973,7 @@ declare namespace DataTableToolbar {
 declare type DataTableUiFilterOperatorByType = {
     string: DataTableStringFilterOperator;
     number: DataTableNumericTemporalFilterOperator;
+    decimal: DataTableNumericTemporalFilterOperator;
     datetime: DataTableNumericTemporalFilterOperator;
     date: DataTableDateFilterOperator;
     time: DataTableNumericTemporalFilterOperator;
@@ -2819,6 +2984,16 @@ declare type DataTableUiFilterOperatorByType = {
 
 declare type DataTableUuidFilterOperator = Extract<OperatorForFilterType["uuid"], "eq">;
 
+/**
+ * `edit` config for `type: "date"` columns: a calendar that opens from the
+ * cell. Picking a day commits `"YYYY-MM-DD"`. With `dateFormat: "datetime"`
+ * the calendar emits complete `DateTimeDraft` snapshots and Done confirms an
+ * ISO 8601 timestamp in the AppShell timezone only with a valid day and time.
+ * Outside closing / Esc cancels; Clear explicitly confirms `null`.
+ * Date-only drafts are `"YYYY-MM-DD" | null`.
+ */
+export declare type DateCellEditOptions<TRow extends Record<string, unknown>> = CellEditBase<TRow, string, string | DateTimeDraft | null>;
+
 /** Options for `type: "date"` cells. */
 declare interface DateCellOptions {
     /**
@@ -2852,6 +3027,7 @@ declare interface DateControlProps<T extends DateValue> {
     isRequired?: boolean;
     isInvalid?: boolean;
     autoFocus?: boolean;
+    /** 12- or 24-hour time; defaults to the locale. */
     hourCycle?: HourCycle;
     placeholderValue?: DateValue;
     firstDayOfWeek?: FirstDayOfWeek;
@@ -2866,6 +3042,8 @@ declare interface DateControlProps<T extends DateValue> {
     "aria-describedby"?: string;
     /** BCP-47 locale override; defaults to the AppShell formatting locale. */
     locale?: string;
+    /** Show the locale's short day of the week next to the date (e.g. `(金)`, `Fri,`). */
+    showDayOfWeek?: boolean;
 }
 
 /**
@@ -2951,6 +3129,7 @@ export declare type DateRangePickerProps<T extends DateValue = DateValue> = {
     isRequired?: boolean;
     isInvalid?: boolean;
     autoFocus?: boolean;
+    /** 12- or 24-hour time; defaults to the locale. */
     hourCycle?: HourCycle;
     placeholderValue?: DateValue;
     firstDayOfWeek?: FirstDayOfWeek;
@@ -2976,8 +3155,39 @@ export declare type DateRangePickerProps<T extends DateValue = DateValue> = {
     locale?: string;
     /** IANA timezone; defaults to the AppShell `timeZone`. */
     timeZone?: string;
+    /** Show the locale's short day of the week next to each date. */
+    showDayOfWeek?: boolean;
+};
+
+/** A from/to date pair, committed as `between` `{ min, max }`. */
+declare type DateRangeSection<TField extends string = string> = FieldSectionBase<TField> & {
+    control: "dateRange";
+    min?: string;
+    max?: string;
+    /** Named spans offered above the picker ("Last 30 days"). Click again to clear. */
+    presets?: readonly {
+        label: string;
+        from: string;
+        to: string;
+    }[];
 };
 
+/** A single `YYYY-MM-DD` date with one fixed operator. */
+declare type DateSection<TField extends string = string> = FieldSectionBase<TField> & {
+    control: "date";
+    operator: "eq" | "gte" | "lte";
+    /** `YYYY-MM-DD` */
+    min?: string;
+    /** `YYYY-MM-DD` */
+    max?: string;
+};
+
+/** Incomplete date-time editor state, interpreted in the AppShell timezone. */
+export declare interface DateTimeDraft {
+    day: string | null;
+    time: string | null;
+}
+
 export { DateValue }
 
 /**
@@ -3166,7 +3376,7 @@ export declare const defineI18nLabels: <const L extends Exclude<string, "en">, c
     };
     /**
      * A function to get the translater for a specific label key.
-     * This is expected to be used in `meta.title` in module/resource definitions.
+     * Use directly in `meta.title` or `meta.breadcrumbTitle` in module/resource definitions.
      *
      * Note: When using dynamic labels with props in meta.title, the props are
      * bound at definition time (when calling labels.t), not at render time.
@@ -3639,6 +3849,25 @@ declare type ExtractBasePath<T extends string> = T extends `${infer Base}?${stri
 /** Extracts the item type from a possibly-grouped items array element. */
 declare type ExtractItem<I> = I extends ItemGroup<infer T> ? T : I;
 
+/**
+ * One choice in a checkbox or radio section.
+ *
+ * Widens `SelectOption` (`{ value, label }`) and stays assignable **from** it,
+ * so an existing `column.filter.options` array passes straight in.
+ *
+ * `value` is a string on purpose: `useURLCollectionVariables` stringifies array
+ * members when it writes the URL, so a numeric `in` filter would come back as
+ * `["1","2"]` and match nothing after a reload.
+ */
+declare type FacetOption = SelectOption & {
+    /** Leading adornment — a colour swatch, a status dot. */
+    icon?: ReactNode;
+    /** Rendered but not selectable, with this as the reason (shown as a tooltip). */
+    disabledReason?: string;
+    /** A data-quality note shown as a tooltip, e.g. "Legacy spelling". */
+    note?: string;
+};
+
 /** Shown when there is no image or the image failed to load. */
 declare function Fallback({ className, ...props }: React_2.ComponentProps<typeof Avatar_2.Fallback>): JSX.Element;
 
@@ -3762,6 +3991,12 @@ declare type FieldRootProps = Pick<React_2.ComponentProps<typeof Field_2.Root>,
     };
 };
 
+declare type FieldSectionBase<TField extends string> = SectionBase & {
+    field: TField;
+    /** Show the per-section Clear. Default `true`. */
+    clearable?: boolean;
+};
+
 export declare const Fieldset: {
     Root: typeof Root_9;
     Legend: typeof Legend;
@@ -3792,7 +4027,7 @@ declare type FieldsetRootProps = Pick<React_2.ComponentProps<typeof Fieldset_2.R
 /**
  * Field type mapping for Data View.
  */
-export declare type FieldType = "string" | "number" | "boolean" | "uuid" | "datetime" | "date" | "time" | "enum" | "array" | "nested" | "file";
+export declare type FieldType = "string" | "number" | "decimal" | "boolean" | "uuid" | "datetime" | "date" | "time" | "enum" | "array" | "nested" | "file";
 
 /**
  * Supported field types for DescriptionCard
@@ -3811,6 +4046,7 @@ export declare function fieldTypeToFilterConfig(field: string, type: FieldType,
 declare type FieldTypeToFilterConfigType = {
     string: "string";
     number: "number";
+    decimal: "decimal";
     boolean: "boolean";
     uuid: "uuid";
     datetime: "datetime";
@@ -3831,6 +4067,7 @@ export declare function fieldTypeToSortConfig(field: string, type: FieldType): S
 declare type FieldTypeToTSType = {
     string: string;
     number: number;
+    decimal: string;
     boolean: boolean;
     uuid: string;
     datetime: string;
@@ -3862,6 +4099,9 @@ export declare type FilterConfig = {
 } | {
     field: string;
     type: "number";
+} | {
+    field: string;
+    type: "decimal";
 } | {
     field: string;
     type: "datetime";
@@ -3892,6 +4132,75 @@ declare type FilterInputForFieldType<TFilterConfigType extends FilterConfig["typ
  */
 export declare type FilterOperator = OperatorForFilterType[FilterConfig["type"]];
 
+/**
+ * An always-visible faceted filter rail. Sections are config (`sections`), so
+ * any mix of checkbox, radio, boolean, text, date, range and custom sections
+ * works; every other feature is an optional part you include or leave out.
+ *
+ * It writes the same `CollectionControl` a `DataTable` reads, so it can sit in
+ * a separate `Layout.Column` beside the table. Below `lg` it turns itself into
+ * a left sheet behind a "Filters" button, like the Sidebar does.
+ *
+ * @example
+ * ```tsx
+ * <FilterRail.Root control={control} sections={sections} layout={layout}>
+ *   <FilterRail.Header>
+ *     <FilterRail.ClearAll />
+ *     <FilterRail.Settings />
+ *   </FilterRail.Header>
+ *   <FilterRail.Sections />
+ * </FilterRail.Root>
+ * ```
+ */
+export declare const FilterRail: {
+    Provider: typeof Provider_2;
+    Root: typeof Root_14;
+    Header: typeof Header_7;
+    ClearAll: typeof ClearAll;
+    Sections: typeof Sections;
+    Settings: typeof Settings;
+    Trigger: typeof Trigger_5;
+};
+
+/** Everything the rail filters with. Given to `Provider`, or to `Root` directly. */
+/**
+ * `TField` is the control's field type; `TSectionField` the sections' — it must
+ * fit inside `TField`, and defaults to it. With an untyped control
+ * (`CollectionControl<string>`), type the sections with the row's keys to catch
+ * a `field` that is not on the table:
+ *
+ * ```ts
+ * const sections: FilterRailSection<keyof Row & string>[] = [...];
+ * ```
+ */
+declare type FilterRailConfig<TField extends string = string, TSectionField extends TField = TField> = {
+    /**
+     * The same `control` passed to `useDataTable`. A prop rather than context:
+     * the rail sits in a different `Layout.Column`, outside `DataTable.Root`.
+     */
+    control: CollectionControl<TField>;
+    /** Top to bottom. Any mix of section types. */
+    sections: readonly FilterRailSection<TSectionField>[];
+    /** User layout (order / hidden / sort). Required for `FilterRail.Settings`. */
+    layout?: RailLayoutBinding;
+    /** 32px rows (default) or 40px. */
+    density?: "compact" | "comfortable";
+    /** Fires after the rail applies a change. */
+    onFilterChange?: (next: Filter<TField>[], changed: readonly TSectionField[]) => void;
+};
+
+declare type FilterRailProviderProps<TField extends string = string, TSectionField extends TField = TField> = FilterRailConfig<TField, TSectionField> & {
+    children: ReactNode;
+};
+
+/**
+ * Standalone, `Root` takes the config itself. Inside `FilterRail.Provider` —
+ * needed only when a `FilterRail.Trigger` sits outside the rail — it takes none.
+ */
+export declare type FilterRailRootProps<TField extends string = string, TSectionField extends TField = TField> = RootOwnProps & (FilterRailConfig<TField, TSectionField> | NoConfig);
+
+export declare type FilterRailSection<TField extends string = string> = TextSection<TField> | RadioSection<TField> | CheckboxSection<TField> | DateSection<TField> | DateRangeSection<TField> | NumberRangeSection<TField> | BooleanSection<TField> | CustomSection<TField>;
+
 /**
  * Week-start override for the `weekStart`/`weekEnd` shortcuts (and the calendar
  * grid). Defined here — with the resolver that consumes it — so the field and
@@ -4383,11 +4692,25 @@ declare namespace Header_6 {
     var displayName: string;
 }
 
+declare function Header_7({ title, children, className }: HeaderProps_2): JSX.Element;
+
+declare namespace Header_7 {
+    var displayName: string;
+}
+
 declare type HeaderProps = Omit<React_2.ComponentProps<"div">, "title"> & {
     title?: React_2.ReactNode;
     description?: React_2.ReactNode;
 };
 
+declare type HeaderProps_2 = {
+    /** Default "Filters". */
+    title?: ReactNode;
+    /** Actions on the right — `FilterRail.ClearAll`, `FilterRail.Settings`, or your own. */
+    children?: ReactNode;
+    className?: string;
+};
+
 /**
  * Context passed to custom `header` renderers.
  */
@@ -4887,6 +5210,10 @@ export { NavLink }
 
 export { NavLinkProps }
 
+declare type NoConfig = {
+    [K in keyof FilterRailConfig]?: never;
+};
+
 /**
  * Extract the node type from a cursor connection result.
  */
@@ -4906,6 +5233,16 @@ declare interface NonSortableHeaderRenderContext {
     sortable: false;
 }
 
+/**
+ * `edit` config for `type: "number"` and `type: "money"` columns. Drafts are raw
+ * strings (including incomplete input); confirmation emits a JavaScript number
+ * or `null`, not an arbitrary-precision Decimal. Editing uses `.` as the decimal
+ * separator, independently of display locale. Full-width digits and valid comma
+ * grouping are normalized on confirmation. Display precision does not constrain
+ * input; business rules belong to the consumer.
+ */
+export declare type NumberCellEditOptions<TRow extends Record<string, unknown>> = CellEditBase<TRow, number, string>;
+
 /** Options for `type: "number"` cells. */
 declare interface NumberCellOptions {
     /** Minimum decimal places. Default: `0`. */
@@ -4916,6 +5253,17 @@ declare interface NumberCellOptions {
     locale?: string;
 }
 
+/** A numeric from/to pair: `between` `{ min, max }`, or `gte` / `lte` when half-open. */
+declare type NumberRangeSection<TField extends string = string> = FieldSectionBase<TField> & {
+    control: "numberRange";
+    /** Input bounds and placeholders. One end typed alone commits `gte` / `lte`. */
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Rendered after the inputs — "units", "$". */
+    unit?: ReactNode;
+};
+
 export declare type OpenCommandPaletteOptions = {
     /** Optional initial text to prefill into the palette input. */
     search?: string;
@@ -4947,6 +5295,7 @@ declare type OperatorForFilterType = {
 export declare const OPERATORS_BY_FILTER_TYPE: {
     readonly string: readonly ["eq", "ne", "contains", "notContains", "hasPrefix", "hasSuffix", "notHasPrefix", "notHasSuffix", "in", "nin", "regex"];
     readonly number: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between", "in", "nin"];
+    readonly decimal: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between", "in", "nin"];
     readonly datetime: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between", "in", "nin"];
     readonly date: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between", "in", "nin"];
     readonly time: readonly ["eq", "ne", "gt", "gte", "lt", "lte", "between", "in", "nin"];
@@ -4960,7 +5309,16 @@ declare type OperatorValueType<TOp extends string, TValue> = TOp extends "in" |
     max: TValue;
 } : TValue;
 
-declare type OrderableFieldType = "string" | "number" | "boolean" | "datetime" | "date" | "time" | "enum";
+/**
+ * How a checkbox section's options are ordered.
+ *
+ * `"given"` (default) keeps the authored order — a curated vocabulary
+ * (XS · S · M · L) must never be reordered. `"label"` sorts A–Z. A comparator
+ * gives any other fixed order.
+ */
+declare type OptionSort = "given" | "label" | ((a: FacetOption, b: FacetOption) => number);
+
+declare type OrderableFieldType = "string" | "number" | "decimal" | "boolean" | "datetime" | "date" | "time" | "enum";
 
 /**
  * A React component that can be used as a page in file-based routing.
@@ -5076,6 +5434,17 @@ declare namespace Provider {
     var displayName: string;
 }
 
+/**
+ * Holds the rail's state for every part beneath it. Only needed when a
+ * `FilterRail.Trigger` sits outside `FilterRail.Root` (in a table toolbar, say);
+ * otherwise give `Root` the config directly.
+ */
+declare function Provider_2<TField extends string = string, TSectionField extends TField = TField>({ control, sections, layout, density, onFilterChange, children, }: FilterRailProviderProps<TField, TSectionField>): JSX.Element;
+
+declare namespace Provider_2 {
+    var displayName: string;
+}
+
 declare type ProviderProps = Pick<React_2.ComponentProps<typeof Tooltip_2.Provider>, "delay" | "closeDelay" | "timeout"> & {
     children: React_2.ReactNode;
 };
@@ -5101,6 +5470,36 @@ declare namespace RadioItemIndicator {
     var displayName: string;
 }
 
+/** Mutually exclusive choices — one filter, or none. */
+declare type RadioSection<TField extends string = string> = FieldSectionBase<TField> & {
+    control: "radio";
+    operator?: "eq" | "ne";
+    options: readonly FacetOption[];
+    /** The "no constraint" row. Default "Any"; `null` removes it. */
+    anyLabel?: ReactNode | null;
+};
+
+/**
+ * The user's override of the authored section order, visibility and option
+ * sort. Kept separate from `sections` so a new authored section needs no
+ * migration of anyone's saved layout.
+ */
+declare type RailLayout = {
+    /** Section ids, top to bottom. Unlisted ids follow in authored order. */
+    order: readonly string[];
+    /** Section ids the user has switched off. */
+    hidden: readonly string[];
+    /** Per-section override of the authored `sort`. Checkbox sections only. */
+    sort: Readonly<Record<string, UserOptionSort>>;
+};
+
+declare type RailLayoutBinding = {
+    value: RailLayout;
+    onChange: (next: RailLayout) => void;
+    /** Back to the authored defaults. Omit and no Reset is offered. */
+    onReset?: () => void;
+};
+
 /**
  * A standalone inline range calendar. The first click sets one end of the
  * range, the highlight follows the pointer (or arrow keys), and the second
@@ -5234,9 +5633,11 @@ declare type ResourceMeta = {
     title?: LocalizedString;
     icon?: ReactNode;
     /**
-     * Custom breadcrumb segment title for this page. Can be a string or a function.
+     * Custom breadcrumb segment title. Pass `labels.t("key")` directly for localization.
+     * Other callbacks receive the URL segment and may return a LocalizedString
+     * (e.g. `(segment) => labels.t("order", { id: segment })`), resolved using the current locale.
      */
-    breadcrumbTitle?: string | ((segment: string) => string);
+    breadcrumbTitle?: string | ((segment: string) => LocalizedString);
 };
 
 /**
@@ -5362,6 +5763,17 @@ declare namespace Root_13 {
     var displayName: string;
 }
 
+/**
+ * The rail. Give it the config directly, or render it inside
+ * `FilterRail.Provider` with no config when a `FilterRail.Trigger` lives
+ * elsewhere on the page.
+ */
+declare function Root_14<TField extends string = string, TSectionField extends TField = TField>(props: FilterRailRootProps<TField, TSectionField>): JSX.Element;
+
+declare namespace Root_14 {
+    var displayName: string;
+}
+
 /**
  * Provides the shared time range used by all timeline primitives.
  *
@@ -5376,9 +5788,9 @@ declare namespace Root_13 {
  * </Timeline.Root>
  * ```
  */
-declare function Root_14({ start, end, children, className, style }: TimelineRootProps): JSX.Element;
+declare function Root_15({ start, end, children, className, style }: TimelineRootProps): JSX.Element;
 
-declare namespace Root_14 {
+declare namespace Root_15 {
     var displayName: string;
 }
 
@@ -5547,6 +5959,13 @@ declare type RootConfiguration = {
     timeZone?: string;
 };
 
+declare type RootOwnProps = {
+    /** Accessible name of the rail landmark. Default "Filters". */
+    "aria-label"?: string;
+    className?: string;
+    children: ReactNode;
+};
+
 declare type RootProps = React_2.ComponentProps<"div"> & VariantProps<typeof alertVariants> & {
     /** Action element rendered below the description */
     action?: React_2.ReactNode;
@@ -5620,11 +6039,16 @@ declare namespace Row_3 {
 /**
  * A single row action definition for the actions column.
  */
-export declare interface RowAction<TRow extends Record<string, unknown>> {
-    id: string;
-    label: string;
-    icon?: ReactNode;
-    variant?: "default" | "destructive";
+export declare interface RowAction<TRow extends Record<string, unknown>> extends DataTableAction {
+    /** Whether the action can act on this row. Return `false` to disable it. */
+    canApply?: (row: TRow) => boolean;
+    /**
+     * Return `true` to disable the action for a given row.
+     *
+     * @deprecated Use `canApply`, which reads the other way round:
+     * `isDisabled: (row) => x` is `canApply: (row) => !x`. If both are set, the
+     * action is disabled when either one says so.
+     */
     isDisabled?: (row: TRow) => boolean;
     onClick: (row: TRow) => void;
 }
@@ -5677,6 +6101,32 @@ declare type RowExpansionOptions<TRow extends Record<string, unknown>> = {
     onChange?: (ids: string[]) => void;
 });
 
+/** Controlled or uncontrolled row-selection configuration. Keep the mode stable while mounted. */
+export declare type RowSelectionOptions = {
+    /**
+     * Bulk actions for the selected IDs, shown in `DataTable.Footer` while at
+     * least one row is selected. The bar includes the selection count, these
+     * actions, and Clear, with pagination kept alongside. The first three actions
+     * render as buttons; the rest collapse into a "More actions" menu.
+     * Omit or pass an empty array to enable selection without an action bar.
+     */
+    actions?: SelectionAction[];
+} & ({
+    /**
+     * Controlled selected ids. Update this array from `onChange`.
+     * Commands issued before the owner commits each derive from this value.
+     */
+    selectedIds: string[];
+    onChange: (ids: string[]) => void;
+    defaultSelectedIds?: never;
+} | {
+    selectedIds?: never;
+    /** Initial selected ids in uncontrolled mode; subsequent changes are ignored. */
+    defaultSelectedIds?: string[];
+    /** Notification of user-driven selection changes, including under StrictMode. */
+    onChange?: (ids: string[]) => void;
+});
+
 /**
  * Setter shape compatible with `useSearchParams()`.
  */
@@ -5707,6 +6157,32 @@ export declare type SearchSource = {
     }) => Promise<CommandPaletteSearchResult[]>;
 };
 
+declare type SectionBase = {
+    /** Stable and unique within the rail. Keys the layout and a11y ids. */
+    id: string;
+    /** The section heading — the word the business uses, not the field name. */
+    label: ReactNode;
+    /** One muted line under the heading. */
+    hint?: ReactNode;
+    /**
+     * Start collapsed. Users expand or collapse any section from the chevron by
+     * its title; while collapsed, the header still shows how many values are
+     * selected. Default `false`.
+     */
+    defaultCollapsed?: boolean;
+};
+
+/** Every section, in the user's layout. Scrolls; the header stays put. */
+declare function Sections({ className }: SectionsProps): JSX.Element;
+
+declare namespace Sections {
+    var displayName: string;
+}
+
+declare type SectionsProps = {
+    className?: string;
+};
+
 export declare const Select: SelectComponent;
 
 /**
@@ -5807,6 +6283,38 @@ declare namespace SelectGroupLabel {
     var displayName: string;
 }
 
+/**
+ * An ID-based bulk action shown in `DataTable.Footer` while a selection is open.
+ * Configure through `UseDataTableOptions.rowSelection.actions`.
+ */
+export declare interface SelectionAction extends DataTableAction {
+    /**
+     * Called with a click-time copy of all selected IDs, including unloaded rows.
+     * Consumers own eligibility checks, fetching, confirmation, and execution.
+     * Selection is never automatically cleared: update controlled selection based
+     * on the actual result, preserving ineligible IDs and any new selections.
+     *
+     * Return a promise to disable the bar and show a spinner while it is pending.
+     * For work started later by a confirmation dialog, pass the request to
+     * `helpers.run` instead. Neither success nor failure changes selection.
+     */
+    onClick: (ids: string[], helpers: SelectionActionHelpers) => void | Promise<unknown>;
+}
+
+/** The second argument to `SelectionAction.onClick`. */
+export declare interface SelectionActionHelpers {
+    /** Empty the selection across all pages. */
+    clearSelection: () => void;
+    /**
+     * Hand the bar a request it should track — for one that starts after
+     * `onClick` has returned, typically from a confirm dialog's confirm button.
+     * The bar then behaves as if `onClick` had returned it: actions (and Clear)
+     * are disabled while it is pending. It never changes selection. Returns the
+     * request, so it can be awaited too.
+     */
+    run: <T>(request: PromiseLike<T>) => PromiseLike<T>;
+}
+
 declare function SelectItem({ className, children, ...props }: React_2.ComponentProps<typeof Select_2.Item>): JSX.Element;
 
 declare namespace SelectItem {
@@ -5961,6 +6469,23 @@ declare namespace Separator {
     var displayName: string;
 }
 
+/**
+ * Show / hide, reorder and sort the sections. Renders nothing unless
+ * `FilterRail.Root` has a `layout` binding.
+ *
+ * Hiding a section that carries a filter also clears that filter — hiding must
+ * never strand an active filter somewhere the user cannot see it.
+ */
+declare function Settings({ className }: SettingsProps): JSX.Element | null;
+
+declare namespace Settings {
+    var displayName: string;
+}
+
+declare type SettingsProps = {
+    className?: string;
+};
+
 /**
  * Shared props between `AppShellProps` and the internal `WithPages` wrapper.
  *
@@ -6492,9 +7017,45 @@ declare const sidebarMenuButtonVariants: (props?: ({
 
 export declare function SidebarMenuItem({ className, ...props }: React_2.ComponentProps<"li">): JSX.Element;
 
+/**
+ * A static heading for a run of flat sidebar navigation items.
+ *
+ * Unlike `SidebarGroup`, a section is neither collapsible nor navigable, and its
+ * items keep the same styling and indentation as top-level items. In the icon
+ * rail the heading is hidden so the compact layout is unaffected. Add dividers
+ * between sections with `SidebarSeparator`.
+ *
+ * @example
+ * ```tsx
+ * <DefaultSidebar>
+ *   <SidebarItem to="/overview" />
+ *   <SidebarSeparator />
+ *   <SidebarSection title={labels.t("services")}>
+ *     <SidebarItem to="/ai-gateways" />
+ *     <SidebarItem to="/applications" />
+ *   </SidebarSection>
+ * </DefaultSidebar>
+ * ```
+ */
+export declare const SidebarSection: (props: SidebarSectionProps) => JSX.Element;
+
+export declare type SidebarSectionProps = {
+    /**
+     * Section heading (i18n supported).
+     */
+    title: LocalizedString;
+    /**
+     * Child items (SidebarItem, SidebarGroup, etc.)
+     */
+    children: ReactNode;
+};
+
 /**
  * A visual divider for sidebar navigation.
  *
+ * Adds 4px above and 8px below the line (on top of the menu's own gap) so the
+ * items that follow read as a new section.
+ *
  * @example
  * ```tsx
  * <DefaultSidebar>
@@ -6714,6 +7275,22 @@ declare type TabsSize = "xs" | "sm" | "default" | "lg";
 
 declare type TabsVariant = "default" | "line" | "capsule";
 
+/**
+ * Text with a typography role. The role sets the size, line height, weight,
+ * and letter spacing. It does not set the color or choose the heading level.
+ *
+ * @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>
+ * ```
+ */
+declare function Text_2({ className, variant, render, children, ref, ...props }: TextProps): React_2.ReactElement<unknown, string | React_2.JSXElementConstructor<any>>;
+export { Text_2 as Text }
+
 /**
  * A styled multi-line text input.
  *
@@ -6775,6 +7352,44 @@ export declare type TextareaProps = Omit<React_2.ComponentProps<typeof Field_2.C
     className?: string;
 };
 
+/**
+ * `edit` config for `type: "text"` and `type: "link"` columns. Without
+ * `options` the cell is typed into: the value is the text as typed, and an
+ * emptied cell commits `null`. A `link` column shows its label as plain text
+ * while the cell can be edited.
+ */
+export declare interface TextCellEditOptions<TRow extends Record<string, unknown>> extends CellEditBase<TRow, string, string | null> {
+    /**
+     * Turns the cell into a dropdown of these choices (a supplier, a warehouse,
+     * a unit of measure). The column's value is an option's `value`, and every
+     * cell in the column — editable or not — shows the matching `label`.
+     * Picking a choice notifies its value; a "None" choice notifies `null`.
+     */
+    options?: readonly SelectOption[];
+}
+
+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 />}`. */
+    render?: React_2.ReactElement;
+};
+
+/** Free text with one fixed operator. */
+declare type TextSection<TField extends string = string> = FieldSectionBase<TField> & {
+    control: "text";
+    operator: "contains" | "hasPrefix" | "eq";
+    placeholder?: string;
+    /** Default 250 ms. Every commit resets pagination. */
+    debounceMs?: number;
+    /** Below this length the filter is removed instead of applied. Default 1. */
+    minLength?: number;
+};
+
+declare const textVariants: (props?: ({
+    variant?: "heading-lg" | "heading-md" | "heading-sm" | "body-md" | "body-sm" | "label-md" | "label-sm" | "code-sm" | "body-md-relaxed" | "body-sm-relaxed" | null | undefined;
+} & ClassProp) | undefined) => string;
+
 export { Time }
 
 /**
@@ -6793,7 +7408,7 @@ export { Time }
  * ```
  */
 export declare const Timeline: {
-    Root: typeof Root_14;
+    Root: typeof Root_15;
     Viewport: typeof Viewport;
     Row: typeof Row_3;
     Interval: typeof Interval;
@@ -7276,6 +7891,23 @@ declare namespace Trigger_4 {
     var displayName: string;
 }
 
+/**
+ * Opens the rail on narrow screens, carrying the active filter count. Place it
+ * anywhere inside `FilterRail.Provider` — a table toolbar, a page header. It
+ * renders nothing on wide screens, where the rail is already visible, and while
+ * it is mounted `FilterRail.Root` skips its own fallback button.
+ */
+declare function Trigger_5({ children, className }: TriggerProps_2): JSX.Element | null;
+
+declare namespace Trigger_5 {
+    var displayName: string;
+}
+
+declare type TriggerButtonProps = {
+    children?: ReactNode;
+    className?: string;
+};
+
 declare type TriggerProps = {
     /** Extra classes for the trigger button. */
     className?: string;
@@ -7286,6 +7918,8 @@ declare type TriggerProps = {
     onClick?: React.MouseEventHandler<HTMLButtonElement>;
 };
 
+declare type TriggerProps_2 = TriggerButtonProps;
+
 /**
  * Metadata-aware collection variables that remain assignable to the broad
  * `CollectionVariables` shape expected by GraphQL clients.
@@ -7746,6 +8380,8 @@ export declare interface UseCollectionReturn<TFieldName extends string = string,
 /**
  * Hook for managing collection query parameters (filters, sort, pagination)
  * with metadata-based field name typing and automatic `fieldType` detection.
+ * Datetime filters are normalized to RFC 3339 using the AppShell timezone
+ * before initialization or updates. Invalid datetime values throw a TypeError.
  *
  * Returns `variables` with `query`, `order`, and `pagination` sub-properties
  * that can be mapped to GraphQL query variables.
@@ -8032,16 +8668,27 @@ export declare type UseDataTableOptions<TRow extends Record<string, unknown>, TF
      * The column is omitted when this array is empty or not provided.
      */
     rowActions?: RowAction<TRow>[];
+    /**
+     * Controlled or uncontrolled row selection. Providing this option enables
+     * checkboxes. Uses string-normalized `row.id`; rows without an id are excluded.
+     * The header checkbox adds/removes only the current page, preserving other ids.
+     */
+    rowSelection?: RowSelectionOptions;
     /**
      * Called with the current array of selected row IDs whenever the selection
-     * changes. Providing this prop enables the checkbox selection column.
-     * Selection is ID-based (`row.id`) and persists across page changes.
+     * changes. Providing this prop or `rowSelection` enables the checkbox
+     * selection column. Selection is ID-based (`row.id`) and persists
+     * across page changes. Remains supported; `rowSelection.onChange` takes
+     * precedence when both callbacks are supplied.
      *
      * **Requirement:** Each row must have a string or number `id` field.
      * Rows without `id` are excluded from selection.
      *
-     * **Note:** `selectAllRows` (triggered by the header checkbox) selects only
-     * the rows on the **current page**, not all pages.
+     * **Note:** The header checkbox acts on the **current page**: checking it adds
+     * the page's rows to the selection and unchecking it removes them. Rows
+     * selected on other pages are kept.
+     *
+     * @deprecated Use `rowSelection.onChange` instead.
      */
     onSelectionChange?: (ids: string[]) => void;
     /**
@@ -8137,11 +8784,27 @@ export declare interface UseDataTableReturn<TRow extends Record<string, unknown>
     control: CollectionControl | undefined;
     onClickRow?: (row: TRow) => void;
     rowActions?: RowAction<TRow>[];
+    /** Selection config (passthrough for `DataTable.Root`). */
+    rowSelection?: RowSelectionOptions;
     selectedIds: string[];
     isRowSelected: (row: TRow) => boolean;
     toggleRowSelection?: (row: TRow) => void;
+    /** Adds every row on the current page to the selection. */
     selectAllRows?: () => void;
+    /** Removes the current page's rows from the selection; other pages' rows stay selected. */
+    deselectAllRows?: () => void;
+    /** Empties the selection across all pages. */
     clearSelection?: () => void;
+    /** Id of the selection action whose request is in flight, or `null`. */
+    pendingActionId?: string | null;
+    /**
+     * Tracks a selection action's request: disables the bar while it is pending
+     * without changing selection. This is what `SelectionActionHelpers.run` calls.
+     * Undefined when selection is off.
+     */
+    runSelectionAction?: (action: {
+        id: string;
+    }, request: PromiseLike<unknown>) => void;
     isAllSelected: boolean;
     isIndeterminate: boolean;
     /** Ids of the currently expanded rows. */
@@ -8198,6 +8861,16 @@ declare function useFilter(options?: ComboboxFilterOptions): ComboboxFilter;
  */
 declare function useFilter_2(options?: AutocompleteFilterOptions): AutocompleteFilter;
 
+/**
+ * The user's section order, visibility and option sort, persisted to
+ * localStorage under `storageKey`. Pass the result to `FilterRail.Root`'s
+ * `layout` prop to enable `FilterRail.Settings`.
+ *
+ * For a team-shared layout, build a `{ value, onChange, onReset }` binding over
+ * your own store instead — the rail does not care where it lives.
+ */
+export declare function useFilterRailLayout(storageKey: string): RailLayoutBinding;
+
 export { useLocation }
 
 export { useMatch }
@@ -8300,6 +8973,9 @@ export declare const useResolvedLocale: () => {
 
 export { useResolvedPath }
 
+/** The option sorts a user may pick in `FilterRail.Settings`. */
+declare type UserOptionSort = "given" | "label";
+
 export { useRouteError }
 
 export { useSearchParams }
@@ -8408,7 +9084,7 @@ export declare function useURLCollectionVariables(options: UseCollectionOptions
  *   <Field.Validity>
  *     {(state) =>
  *       state.validity.valid === false && (
- *         <p className="text-destructive text-sm">
+ *         <p className="text-danger-text text-sm">
  *           {state.validity.typeMismatch
  *             ? "Please enter a valid URL (e.g. https://example.com)"
  *             : "This field is required."}
@@ -8561,12 +9237,12 @@ declare namespace Root {
 }
 
 
-declare namespace Title {
+declare namespace Image {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace Fallback {
     var displayName: string;
 }
 
@@ -8576,17 +9252,17 @@ declare namespace Root {
 }
 
 
-declare namespace List {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace Tab {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace Panel {
+declare namespace Provider {
     var displayName: string;
 }
 
@@ -8596,12 +9272,27 @@ declare namespace Root {
 }
 
 
-declare namespace Image {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Fallback {
+declare namespace ClearAll {
+    var displayName: string;
+}
+
+
+declare namespace Sections {
+    var displayName: string;
+}
+
+
+declare namespace Trigger {
+    var displayName: string;
+}
+
+
+declare namespace Settings {
     var displayName: string;
 }
 
@@ -8616,47 +9307,47 @@ declare namespace Header {
 }
 
 
-declare namespace Body {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Row {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Head {
+declare namespace Body {
     var displayName: string;
 }
 
 
-declare namespace Cell {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace Caption {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Head {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace Cell {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Caption {
     var displayName: string;
 }
 
@@ -8861,6 +9552,26 @@ declare namespace Root {
 }
 
 
+declare namespace List {
+    var displayName: string;
+}
+
+
+declare namespace Tab {
+    var displayName: string;
+}
+
+
+declare namespace Panel {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
 declare namespace Row {
     var displayName: string;
 }
@@ -9021,16 +9732,6 @@ declare namespace ComboboxCollection {
 }
 
 
-declare namespace AutocompleteStandalone {
-    var displayName: string;
-}
-
-
-declare namespace AutocompleteAsyncStandalone {
-    var displayName: string;
-}
-
-
 declare namespace AutocompleteRoot {
     var displayName: string;
 }
@@ -9101,6 +9802,16 @@ declare namespace AutocompleteStatus {
 }
 
 
+declare namespace AutocompleteStandalone {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteAsyncStandalone {
+    var displayName: string;
+}
+
+
 declare namespace DataTableRoot {
     var displayName: string;
 }