@tailor-platform/app-shell 1.16.0 → 1.17.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.
@@ -1058,6 +1060,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.
@@ -1338,6 +1352,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;
 
@@ -2135,7 +2183,7 @@ declare type CommonPageResource = {
     meta: {
         title: LocalizedString;
         icon?: ReactNode;
-        breadcrumbTitle?: string | ((segment: string) => string);
+        breadcrumbTitle?: string | ((segment: string) => LocalizedString);
     };
 };
 
@@ -2194,7 +2242,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 +2285,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 +2586,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 +2635,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 +2655,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 +2732,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 +2792,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 +2848,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 +2917,7 @@ declare namespace DataTableToolbar {
 declare type DataTableUiFilterOperatorByType = {
     string: DataTableStringFilterOperator;
     number: DataTableNumericTemporalFilterOperator;
+    decimal: DataTableNumericTemporalFilterOperator;
     datetime: DataTableNumericTemporalFilterOperator;
     date: DataTableDateFilterOperator;
     time: DataTableNumericTemporalFilterOperator;
@@ -2852,6 +2961,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 +2976,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 +3063,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,6 +3089,31 @@ 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;
 };
 
 export { DateValue }
@@ -3166,7 +3304,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 +3777,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 +3919,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 +3955,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 +3974,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 +3995,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 +4027,9 @@ export declare type FilterConfig = {
 } | {
     field: string;
     type: "number";
+} | {
+    field: string;
+    type: "decimal";
 } | {
     field: string;
     type: "datetime";
@@ -3892,6 +4060,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 +4620,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 +5138,10 @@ export { NavLink }
 
 export { NavLinkProps }
 
+declare type NoConfig = {
+    [K in keyof FilterRailConfig]?: never;
+};
+
 /**
  * Extract the node type from a cursor connection result.
  */
@@ -4916,6 +5171,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 +5213,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 +5227,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 +5352,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 +5388,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 +5551,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 +5681,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 +5706,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 +5877,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 +5957,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 +6019,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 +6075,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 +6201,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 +6387,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 +6935,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>
@@ -6775,6 +7254,17 @@ export declare type TextareaProps = Omit<React_2.ComponentProps<typeof Field_2.C
     className?: string;
 };
 
+/** 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;
+};
+
 export { Time }
 
 /**
@@ -6793,7 +7283,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 +7766,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 +7793,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 +8255,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 +8543,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 +8659,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 +8736,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 +8848,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 }
@@ -8561,12 +9112,12 @@ declare namespace Root {
 }
 
 
-declare namespace Title {
+declare namespace Image {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace Fallback {
     var displayName: string;
 }
 
@@ -8576,32 +9127,37 @@ declare namespace Root {
 }
 
 
-declare namespace List {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Tab {
+declare namespace Body {
     var displayName: string;
 }
 
 
-declare namespace Panel {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Row {
     var displayName: string;
 }
 
 
-declare namespace Image {
+declare namespace Head {
     var displayName: string;
 }
 
 
-declare namespace Fallback {
+declare namespace Cell {
+    var displayName: string;
+}
+
+
+declare namespace Caption {
     var displayName: string;
 }
 
@@ -8616,47 +9172,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 Trigger {
     var displayName: string;
 }
 
 
-declare namespace Head {
+declare namespace Close {
     var displayName: string;
 }
 
 
-declare namespace Cell {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace Caption {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace Footer {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace Title {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Description {
     var displayName: string;
 }
 
@@ -8666,192 +9222,197 @@ declare namespace Root {
 }
 
 
-declare namespace Trigger {
+declare namespace Legend {
     var displayName: string;
 }
 
 
-declare namespace Close {
+declare namespace ComboboxRoot {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace ComboboxInput {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace ComboboxTrigger {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace ComboboxInputGroup {
     var displayName: string;
 }
 
 
-declare namespace Title {
+declare namespace ComboboxContent {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace ComboboxList {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxItem {
     var displayName: string;
 }
 
 
-declare namespace Label {
+declare namespace ComboboxEmpty {
     var displayName: string;
 }
 
 
-declare namespace Control {
+declare namespace ComboboxGroup {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace ComboboxGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Error {
+declare namespace ComboboxClear {
     var displayName: string;
 }
 
 
-declare namespace Validity {
+declare namespace ComboboxChips {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxChip {
     var displayName: string;
 }
 
 
-declare namespace Legend {
+declare namespace ComboboxChipRemove {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace ComboboxValue {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace ComboboxStatus {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace ComboboxCollection {
     var displayName: string;
 }
 
 
-declare namespace Item {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace LinkItem {
+declare namespace Label {
     var displayName: string;
 }
 
 
-declare namespace CheckboxItem {
+declare namespace Control {
     var displayName: string;
 }
 
 
-declare namespace CheckboxItemIndicator {
+declare namespace Description {
     var displayName: string;
 }
 
 
-declare namespace RadioItem {
+declare namespace Error {
     var displayName: string;
 }
 
 
-declare namespace RadioItemIndicator {
+declare namespace Validity {
     var displayName: string;
 }
 
 
-declare namespace RadioGroup {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace Group {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace GroupLabel {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace MenuSeparator {
+declare namespace Item {
     var displayName: string;
 }
 
 
-declare namespace SubmenuRoot {
+declare namespace LinkItem {
     var displayName: string;
 }
 
 
-declare namespace SubmenuTrigger {
+declare namespace CheckboxItem {
     var displayName: string;
 }
 
 
-declare namespace Root {
+declare namespace CheckboxItemIndicator {
     var displayName: string;
 }
 
 
-declare namespace Trigger {
+declare namespace RadioItem {
     var displayName: string;
 }
 
 
-declare namespace Close {
+declare namespace RadioItemIndicator {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace RadioGroup {
     var displayName: string;
 }
 
 
-declare namespace Header {
+declare namespace Group {
     var displayName: string;
 }
 
 
-declare namespace Footer {
+declare namespace GroupLabel {
     var displayName: string;
 }
 
 
-declare namespace Title {
+declare namespace MenuSeparator {
     var displayName: string;
 }
 
 
-declare namespace Description {
+declare namespace SubmenuRoot {
+    var displayName: string;
+}
+
+
+declare namespace SubmenuTrigger {
     var displayName: string;
 }
 
@@ -8876,47 +9437,62 @@ declare namespace Separator {
 }
 
 
-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;
 }
 
 
-declare namespace Provider {
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace List {
+    var displayName: string;
+}
+
+
+declare namespace Tab {
+    var displayName: string;
+}
+
+
+declare namespace Panel {
     var displayName: string;
 }
 
@@ -8926,97 +9502,107 @@ declare namespace Root {
 }
 
 
+declare namespace Title {
+    var displayName: string;
+}
+
+
+declare namespace Description {
+    var displayName: string;
+}
+
+
 declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace Content {
+declare namespace Settings {
     var displayName: string;
 }
 
 
-declare namespace ComboboxRoot {
+declare namespace Provider {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInput {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace ComboboxTrigger {
+declare namespace Header {
     var displayName: string;
 }
 
 
-declare namespace ComboboxInputGroup {
+declare namespace ClearAll {
     var displayName: string;
 }
 
 
-declare namespace ComboboxContent {
+declare namespace Sections {
     var displayName: string;
 }
 
 
-declare namespace ComboboxList {
+declare namespace Provider {
     var displayName: string;
 }
 
 
-declare namespace ComboboxItem {
+declare namespace Root {
     var displayName: string;
 }
 
 
-declare namespace ComboboxEmpty {
+declare namespace Trigger {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroup {
+declare namespace Content {
     var displayName: string;
 }
 
 
-declare namespace ComboboxGroupLabel {
+declare namespace SelectRoot {
     var displayName: string;
 }
 
 
-declare namespace ComboboxClear {
+declare namespace SelectTrigger {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChips {
+declare namespace SelectValue {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChip {
+declare namespace SelectContent {
     var displayName: string;
 }
 
 
-declare namespace ComboboxChipRemove {
+declare namespace SelectItem {
     var displayName: string;
 }
 
 
-declare namespace ComboboxValue {
+declare namespace SelectGroup {
     var displayName: string;
 }
 
 
-declare namespace ComboboxStatus {
+declare namespace SelectGroupLabel {
     var displayName: string;
 }
 
 
-declare namespace ComboboxCollection {
+declare namespace SelectSeparator {
     var displayName: string;
 }