@tailor-platform/app-shell 1.11.0 → 1.13.0

package/dist/app-shell.d.ts

@@ -1,12 +1,18 @@
 import { AuthClient } from '@tailor-platform/auth-public-client';
 import { Autocomplete as Autocomplete_2 } from '@base-ui/react/autocomplete';
+import { AutocompleteFilter } from '@base-ui/react/autocomplete';
+import { AutocompleteFilterOptions } from '@base-ui/react/autocomplete';
 import { AutocompleteRootProps } from '@base-ui/react/autocomplete';
 import { Avatar as Avatar_2 } from '@base-ui/react/avatar';
+import { Blocker } from 'react-router';
+import { BlockerFunction } from 'react-router';
 import { CalendarDate } from '@internationalized/date';
 import { CalendarDateTime } from '@internationalized/date';
 import { Checkbox as Checkbox_2 } from '@base-ui/react/checkbox';
 import { ClassProp } from 'class-variance-authority/types';
 import { Combobox as Combobox_2 } from '@base-ui/react/combobox';
+import { ComboboxFilter } from '@base-ui/react/combobox';
+import { ComboboxFilterOptions } from '@base-ui/react/combobox';
 import { CSSProperties } from 'react';
 import { DateValue } from '@internationalized/date';
 import { Dialog as Dialog_2 } from '@base-ui/react/dialog';
@@ -15,28 +21,45 @@ import { FC } from 'react';
 import { Field as Field_2 } from '@base-ui/react/field';
 import { Fieldset as Fieldset_2 } from '@base-ui/react/fieldset';
 import { Form as Form_2 } from '@base-ui/react/form';
-import { getFilter } from '@base-ui/react/internals/filter';
 import { getLocalTimeZone } from '@internationalized/date';
 import { JSX } from 'react/jsx-runtime';
 import { Link } from 'react-router';
+import { LinkProps } from 'react-router';
 import { LoaderFunctionArgs } from 'react-router';
+import { Location as Location_2 } from 'react-router';
 import { Menu as Menu_2 } from '@base-ui/react/menu';
+import { Navigate } from 'react-router';
+import { NavigateFunction } from 'react-router';
+import { NavigateOptions } from 'react-router';
+import { Navigation } from 'react-router';
+import { NavLink } from 'react-router';
+import { NavLinkProps } from 'react-router';
+import { Params } from 'react-router';
 import { parseAbsolute } from '@internationalized/date';
 import { parseDate } from '@internationalized/date';
 import { parseDateTime } from '@internationalized/date';
 import { parseZonedDateTime } from '@internationalized/date';
+import { PathMatch } from 'react-router';
 import * as React_2 from 'react';
+import { ReactElement } from 'react';
 import { ReactNode } from 'react';
+import { Ref } from 'react';
 import { RefObject } from 'react';
 import { Select as Select_2 } from '@base-ui/react/select';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { Tabs as Tabs_2 } from '@base-ui/react/tabs';
 import { Time } from '@internationalized/date';
+import { To } from 'react-router';
 import { toast } from 'sonner';
 import { Tooltip as Tooltip_2 } from '@base-ui/react/tooltip';
+import { useBeforeUnload } from 'react-router';
+import { useBlocker } from 'react-router';
 import { useLocation } from 'react-router';
+import { useMatch } from 'react-router';
 import { useNavigate } from 'react-router';
+import { useNavigation } from 'react-router';
 import { useParams } from 'react-router';
+import { useResolvedPath } from 'react-router';
 import { useRouteError } from 'react-router';
 import { useSearchParams } from 'react-router';
 import { VariantProps } from 'class-variance-authority';
@@ -269,9 +292,8 @@ export declare type AppInfoEntry = {
     value: string | number | boolean | null | undefined;
 };
 
-export declare const AppShell: {
-    (props: AppShellProps): JSX.Element | null;
-    WithPages(pages: PageEntry[]): FC<AppShellProps>;
+export declare const AppShell: ((props: AppShellProps) => React.ReactNode) & {
+    WithPages: (pages: PageEntry[]) => FC<AppShellProps>;
 };
 
 /**
@@ -872,6 +894,10 @@ export declare const badgeVariants: (props?: ({
     variant?: "default" | "error" | "neutral" | "success" | "warning" | "info" | "subtle-success" | "subtle-warning" | "subtle-error" | "subtle-info" | "outline-success" | "outline-warning" | "outline-error" | "outline-info" | "outline-neutral" | null | undefined;
 } & ClassProp) | undefined) => string;
 
+export { Blocker }
+
+export { BlockerFunction }
+
 /** The table body section (`<tbody>`). */
 declare function Body_2({ className, ...props }: React_2.ComponentProps<"tbody">): JSX.Element;
 
@@ -965,8 +991,14 @@ export declare interface CalendarProps<T extends DateValue = DateValue> {
 
 /**
  * Internal type for tracking OAuth callback handling status.
+ *
+ * "denied" is distinct from "rejected": it means another automatic login round
+ * trip will not help, so auto-login stays out of it. Two things land there —
+ * the authorization server refusing outright (the user declined consent, the
+ * client is not permitted), and a callback that keeps failing after its retry
+ * budget is spent. "rejected" is a failure that is still worth one more attempt.
  */
-declare type CallbackStatus = "idle" | "pending" | "resolved" | "rejected";
+declare type CallbackStatus = "idle" | "pending" | "resolved" | "rejected" | "denied";
 
 /** A table caption element. */
 declare function Caption({ className, ...props }: React_2.ComponentProps<"caption">): JSX.Element;
@@ -1231,6 +1263,58 @@ export declare type ColorTheme = "light" | "dark" | "system";
  */
 export declare type Column<TRow extends Record<string, unknown>> = ColumnBase<TRow> & ColumnTypeBranch<TRow>;
 
+/**
+ * Layout.Column — A single column within `<Layout>`.
+ *
+ * Wrap each logical section of the page in a `<Layout.Column>`.
+ * The parent `<Layout>` sizes columns via CSS Grid `grid-template-columns`,
+ * based on the number of children and, optionally, the `area` prop.
+ * Column width is controlled entirely by the parent grid — the column
+ * itself does not set its own width.
+ *
+ * ### Position-based mode (default)
+ *
+ * When no `area` prop is provided, columns are sized by their DOM position:
+ *
+ * - **2-column:** 1st = flexible (`1fr`), 2nd = fixed 280 px
+ * - **3-column:** 1st = fixed 320 px, 2nd = flexible (`1fr`), 3rd = fixed 280 px
+ * - **4+ columns:** all columns share equal width (`repeat(N, 1fr)`)
+ *
+ * ### Area mode
+ *
+ * Set the `area` prop on any column to opt into role-based widths.
+ * Columns without an `area` prop default to `1fr`.
+ * Visual ordering always follows DOM order, so place your columns in the
+ * intended left-to-right sequence.
+ *
+ * | area      | width             |
+ * | --------- | ----------------- |
+ * | `"left"`  | fixed 320 px      |
+ * | `"main"`  | flexible (`1fr`)  |
+ * | `"right"` | fixed 280 px      |
+ *
+ * ### Data attributes
+ *
+ * The rendered `<div>` always has `data-layout-column`.
+ * When `area` is set, `data-area` is also added with the area value.
+ *
+ * @example
+ * ```tsx
+ * // Position-based (default)
+ * <Layout>
+ *   <Layout.Column>Main content</Layout.Column>
+ *   <Layout.Column>Side panel</Layout.Column>
+ * </Layout>
+ *
+ * // Area-based
+ * <Layout>
+ *   <Layout.Column area="left">Sidebar</Layout.Column>
+ *   <Layout.Column area="main">Content</Layout.Column>
+ * </Layout>
+ * ```
+ */
+declare const Column_2: React_2.ForwardRefExoticComponent<ColumnProps & React_2.RefAttributes<HTMLDivElement>>;
+
 /**
  * Supported area values for Layout.Column
  */
@@ -1314,9 +1398,15 @@ declare interface ColumnBase<TRow extends Record<string, unknown>> {
     /**
      * Filter configuration. When set, this column appears as an option in
      * `DataTable.Filters`.
+     *
+     * `operators` optionally narrows the conditions exposed by the built-in
+     * filter UI for this column. Order controls both the menu order and the
+     * default operator. This affects the DataTable UI only — collection control
+     * APIs and persisted filter state still accept the full backend operator set.
+     *
      * Use `fieldTypeToFilterConfig` or `inferColumns` to derive this automatically.
      */
-    filter?: FilterConfig;
+    filter?: DataTableFilterConfig;
 }
 
 /**
@@ -1369,13 +1459,13 @@ declare interface ColumnHelper<TRow extends Record<string, unknown>> {
  * Per-field column factory returned by `inferColumns(tableMetadata)`.
  *
  * Derives label, sort config, and filter config from the field's metadata.
- * Sort and filter can be suppressed per call via `options`.
+ * Sort can be suppressed and filter can be suppressed or narrowed per call via `options`.
  *
  * @param dataKey - A field name from the bound table metadata.
  * @param options - Optional per-column overrides (label, width, sort, filter).
  * @throws {Error} If `dataKey` is not found in the metadata passed to `inferColumns`.
  */
-declare type ColumnInferFn<TRow extends Record<string, unknown>, TTable extends TableMetadata = TableMetadata> = (dataKey: TableFieldName<TTable>, options?: MetadataFieldOptions) => InferredColumn<TRow>;
+declare type ColumnInferFn<TRow extends Record<string, unknown>, TTable extends TableMetadata = TableMetadata> = <TFieldName extends TableFieldName<TTable>>(dataKey: TFieldName, options?: MetadataFieldOptionsForField<TTable, NoInfer<TFieldName>>) => InferredColumn<TRow>;
 
 /**
  * Props for individual Layout.Column component
@@ -2148,6 +2238,8 @@ export declare const DataTable: {
     readonly Pagination: typeof DataTablePagination;
 };
 
+declare type DataTableBooleanFilterOperator = OperatorForFilterType["boolean"];
+
 /**
  * Context value provided by `DataTable.Root`.
  *
@@ -2210,6 +2302,14 @@ export declare interface DataTableContextValue<TRow extends Record<string, unkno
     clearSelection?: () => void;
     isAllSelected: boolean;
     isIndeterminate: boolean;
+    /** Ids of the currently expanded rows. */
+    expandedIds?: string[];
+    /** Whether `row` is currently expanded. Always `false` for rows without an `id`. */
+    isRowExpanded?: (row: TRow) => boolean;
+    toggleRowExpansion?: (row: TRow) => void;
+    collapseAllRows?: () => void;
+    /** Expansion config. Its presence enables the expand column and detail rows. */
+    rowExpansion?: RowExpansionOptions<TRow>;
 }
 
 /**
@@ -2221,6 +2321,48 @@ export declare interface DataTableData<TRow> {
     total?: number | null;
 }
 
+declare type DataTableDateFilterOperator = Extract<OperatorForFilterType["date"], "eq" | "gte" | "lte" | "between">;
+
+declare type DataTableEnumFilterOperator = Extract<OperatorForFilterType["enum"], "in">;
+
+export declare type DataTableFilterConfig = (Extract<FilterConfig, {
+    type: "string";
+}> & {
+    /**
+     * Allowlist of operators shown by `DataTable.Filters` for this column.
+     * Order controls both the menu order and the default operator.
+     */
+    operators?: NonEmptyReadonlyArray<DataTableStringFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "number";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableNumericTemporalFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "datetime";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableNumericTemporalFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "date";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableDateFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "time";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableNumericTemporalFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "enum";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableEnumFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "boolean";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableBooleanFilterOperator>;
+}) | (Extract<FilterConfig, {
+    type: "uuid";
+}> & {
+    operators?: NonEmptyReadonlyArray<DataTableUuidFilterOperator>;
+});
+
 /** Use `DataTable.Filters` instead of calling this directly. */
 declare function DataTableFilters({ className, slot, addIconOnly, }: {
     className?: string;
@@ -2255,6 +2397,8 @@ declare namespace DataTableFooter {
     var displayName: string;
 }
 
+declare type DataTableNumericTemporalFilterOperator = Extract<OperatorForFilterType["number"], "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "between">;
+
 /** Use `DataTable.Pagination` instead of calling this directly. */
 declare function DataTablePagination({ pageSizeOptions }?: DataTablePaginationProps): JSX.Element;
 
@@ -2283,6 +2427,8 @@ export declare interface DataTableRootProps<TRow extends Record<string, unknown>
     className?: string;
 }
 
+declare type DataTableStringFilterOperator = Extract<OperatorForFilterType["string"], "eq" | "ne" | "contains" | "notContains" | "hasPrefix" | "hasSuffix">;
+
 /** Use `DataTable.Table` instead of calling this directly. */
 declare function DataTableTable({ className }: {
     className?: string;
@@ -2309,10 +2455,43 @@ declare namespace DataTableToolbar {
     var displayName: string;
 }
 
-declare interface DateBehaviorProps<T extends DateValue> {
+declare type DataTableUiFilterOperatorByType = {
+    string: DataTableStringFilterOperator;
+    number: DataTableNumericTemporalFilterOperator;
+    datetime: DataTableNumericTemporalFilterOperator;
+    date: DataTableDateFilterOperator;
+    time: DataTableNumericTemporalFilterOperator;
+    enum: DataTableEnumFilterOperator;
+    boolean: DataTableBooleanFilterOperator;
+    uuid: DataTableUuidFilterOperator;
+};
+
+declare type DataTableUuidFilterOperator = Extract<OperatorForFilterType["uuid"], "eq">;
+
+/** Options for `type: "date"` cells. */
+declare interface DateCellOptions {
+    /**
+     * Format style. `"short"` → `Apr 9, 2026`; `"long"` → `April 9, 2026`;
+     * `"datetime"` → `Apr 9, 2026, 3:45 PM`. Default: `"short"`.
+     */
+    dateFormat?: "short" | "long" | "datetime";
+    /** BCP 47 locale tag. Defaults to the runtime locale. */
+    locale?: string;
+}
+
+/**
+ * Public date controls.
+ *
+ * These are standalone composite widgets built on plain accessible markup and a
+ * proxy input for form value / native validity. Inside `Field.Root`, they also
+ * register with Base UI's label, description, and validation plumbing. All of
+ * that coupling lives in `useDateFieldFieldBridge` (see `./use-date-field-bridge`).
+ */
+declare interface DateControlProps<T extends DateValue> {
     value?: T | null;
     defaultValue?: T | null;
     onChange?: (value: T | null) => void;
+    onBlur?: () => void;
     granularity?: Granularity;
     minValue?: DateValue;
     maxValue?: DateValue;
@@ -2323,52 +2502,32 @@ declare interface DateBehaviorProps<T extends DateValue> {
     isInvalid?: boolean;
     autoFocus?: boolean;
     hourCycle?: HourCycle;
-    hideTimeZone?: boolean;
     placeholderValue?: DateValue;
-    /**
-     * First day of the week (0 = Sunday … 6 = Saturday); defaults to the locale.
-     * Only affects the `w`/`k` (start/end of week) keyboard shortcuts here.
-     */
     firstDayOfWeek?: FirstDayOfWeek;
     name?: string;
-    /** Accessible name when no visible `label` is provided (e.g. a compact filter input). */
+    className?: string;
+    id?: string;
+    /** Accessible name when there is no visible label. */
     "aria-label"?: string;
+    /** ID of the element(s) that label the control. */
+    "aria-labelledby"?: string;
+    /** ID of the element(s) that describe the control. */
+    "aria-describedby"?: string;
     /** BCP-47 locale override; defaults to the AppShell formatting locale. */
     locale?: string;
 }
 
-/** Options for `type: "date"` cells. */
-declare interface DateCellOptions {
-    /**
-     * Format style. `"short"` → `Apr 9, 2026`; `"long"` → `April 9, 2026`;
-     * `"datetime"` → `Apr 9, 2026, 3:45 PM`. Default: `"short"`.
-     */
-    dateFormat?: "short" | "long" | "datetime";
-    /** BCP 47 locale tag. Defaults to the runtime locale. */
-    locale?: string;
-}
-
 /**
  * A segmented date/time input field with no popover.
  *
- * @example
- * ```tsx
- * import { DateField } from "@tailor-platform/app-shell";
- *
- * <DateField label="Invoice date" />
- * <DateField label="Created at" granularity="minute" />
- * ```
+ * Compose with `Field.Root` for label / description / error presentation, or
+ * provide standalone ARIA wiring yourself.
  */
-export declare function DateField<T extends DateValue = DateValue>({ label, description, errorMessage, className, locale: localeProp, value, defaultValue, onChange, granularity, hourCycle, placeholderValue, minValue, maxValue, isDateUnavailable, isDisabled, isReadOnly, isInvalid, isRequired, autoFocus, firstDayOfWeek, name, "aria-label": ariaLabel, }: DateFieldProps<T>): JSX.Element;
+export declare const DateField: <T extends DateValue = DateValue>(props: DateFieldProps<T> & {
+    ref?: Ref<HTMLInputElement>;
+}) => ReactElement;
 
-declare interface DateFieldMetaProps {
-    label?: LocalizedString;
-    description?: LocalizedString;
-    errorMessage?: LocalizedString;
-    className?: string;
-}
-
-export declare type DateFieldProps<T extends DateValue = DateValue> = DateFieldMetaProps & DateBehaviorProps<T>;
+export declare type DateFieldProps<T extends DateValue = DateValue> = DateControlProps<T>;
 
 /**
  * Date format options
@@ -2378,21 +2537,92 @@ declare type DateFormat = "short" | "medium" | "long" | "relative";
 /**
  * A date/time input with a popover calendar.
  *
- * Value type is driven by `granularity`:
- * - `"day"` (default) → `CalendarDate`
- * - `"hour" | "minute" | "second"` → `CalendarDateTime` (or `ZonedDateTime` when a `timeZone` is set)
- *
- * @example
- * ```tsx
- * import { DatePicker, today, getLocalTimeZone, type CalendarDate } from "@tailor-platform/app-shell";
+ * Compose with `Field.Root` for label / description / error presentation, or
+ * provide standalone ARIA wiring yourself.
+ */
+export declare const DatePicker: <T extends DateValue = DateValue>(props: DatePickerProps<T> & {
+    ref?: Ref<HTMLInputElement>;
+}) => ReactElement;
+
+export declare type DatePickerProps<T extends DateValue = DateValue> = DateControlProps<T> & {
+    /** IANA timezone; defaults to the AppShell `timeZone`. */
+    timeZone?: string;
+};
+
+/**
+ * Range calendar state — the logic react-aria's `useRangeCalendarState` would
+ * otherwise provide, on top of the shared `useCalendarGridState` engine.
  *
- * const [date, setDate] = useState<CalendarDate | null>(null);
- * <DatePicker label="Ship date" value={date} onChange={setDate} />
- * ```
+ * Selection is the react-aria two-click model: the first confirmed day sets an
+ * *anchor*; while the anchor is set the highlighted range live-extends to the
+ * focused day (keyboard nav and pointer hover both move it); the second
+ * confirmed day commits `{ start, end }` in one `onChange`. Picking a day
+ * before the anchor swaps the endpoints, so a committed range is always
+ * ordered — a reversed range can only be produced by typing into the field.
  */
-export declare function DatePicker<T extends DateValue = DateValue>({ label, description, errorMessage, className, locale: localeProp, timeZone: timeZoneProp, value, defaultValue, onChange, granularity, hourCycle, placeholderValue, minValue, maxValue, isDateUnavailable, isDisabled, isReadOnly, isInvalid, isRequired, autoFocus, firstDayOfWeek, name, "aria-label": ariaLabel, }: DatePickerProps<T>): JSX.Element;
+/** An inclusive date range. `start` and `end` may be the same day. */
+export declare interface DateRange<T extends DateValue = DateValue> {
+    start: T;
+    end: T;
+}
 
-export declare type DatePickerProps<T extends DateValue = DateValue> = DateFieldProps<T> & {
+export declare const DateRangePicker: <T extends DateValue = DateValue>(props: DateRangePickerProps<T> & {
+    ref?: Ref<HTMLInputElement>;
+}) => ReactElement;
+
+/**
+ * Public date-range control — the @internationalized/date + Base UI
+ * implementation, mirroring react-aria's `DateRangePicker` interaction spec.
+ *
+ * Like `DateField`/`DatePicker`, it is a standalone composite widget that also
+ * composes inside `Field.Root` (label / description / error / form validation).
+ * A single combined proxy input is registered as the one Field control (its
+ * value is empty until BOTH ends are complete, so `required` blocks a partial
+ * range); two optional plain hidden inputs (`startName` / `endName`) provide
+ * classic form-POST parity. A range typed in reverse is flagged invalid rather
+ * than swapped — only the calendar normalizes endpoint order.
+ */
+export declare type DateRangePickerProps<T extends DateValue = DateValue> = {
+    value?: DateRange<T> | null;
+    defaultValue?: DateRange<T> | null;
+    /**
+     * Fired with a complete `{ start, end }` range, or `null` when the range is
+     * cleared or becomes incomplete. Never fired for half-typed intermediates.
+     */
+    onChange?: (value: DateRange<T> | null) => void;
+    onBlur?: () => void;
+    granularity?: Granularity;
+    minValue?: DateValue;
+    maxValue?: DateValue;
+    isDateUnavailable?: (date: DateValue) => boolean;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    isInvalid?: boolean;
+    autoFocus?: boolean;
+    hourCycle?: HourCycle;
+    placeholderValue?: DateValue;
+    firstDayOfWeek?: FirstDayOfWeek;
+    /**
+     * Name for the combined hidden proxy input — a single `name=start/end` field
+     * for native form POST, mirroring `DateField` / `DatePicker`. Inside
+     * `Field.Root`, the Field's `name` takes precedence. For two separate fields,
+     * use `startName` / `endName` instead.
+     */
+    name?: string;
+    /** Names for the two plain hidden start/end inputs (classic form POST). */
+    startName?: string;
+    endName?: string;
+    className?: string;
+    id?: string;
+    /** Accessible name when there is no visible label. */
+    "aria-label"?: string;
+    /** ID of the element(s) that label the control. */
+    "aria-labelledby"?: string;
+    /** ID of the element(s) that describe the control. */
+    "aria-describedby"?: string;
+    /** BCP-47 locale override; defaults to the AppShell formatting locale. */
+    locale?: string;
     /** IANA timezone; defaults to the AppShell `timeZone`. */
     timeZone?: string;
 };
@@ -2743,6 +2973,8 @@ declare namespace Description_4 {
  * Renders structured key-value information with automatic layout.
  * Use { type: "divider" } in the fields array to add dividers between sections.
  *
+ * Pass `render` on a field to draw it yourself when no built-in `type` fits.
+ *
  * @example
  * ```tsx
  * <DescriptionCard
@@ -2753,22 +2985,26 @@ declare namespace Description_4 {
  *     { key: "orderNumber", label: "Order #", meta: { copyable: true } },
  *     { type: "divider" },
  *     { key: "total", label: "Total", type: "money" },
+ *     { key: "deliveryBreakdown", label: "Delivery", render: (d) => <PieChart data={d.deliveryBreakdown} /> },
  *   ]}
  * />
  * ```
  */
-export declare function DescriptionCard({ data, title, fields, columns, className, style, headerAction, }: DescriptionCardProps): JSX.Element;
+export declare function DescriptionCard<TData extends object = Record<string, unknown>>({ data, title, fields, columns, className, style, headerAction, }: DescriptionCardProps<TData>): JSX.Element;
 
 /**
  * Props for the DescriptionCard component
+ *
+ * `TData` is inferred from `data`; constrained to `object` rather than
+ * `Record<string, unknown>` so interfaces are accepted.
  */
-export declare interface DescriptionCardProps {
+export declare interface DescriptionCardProps<TData extends object = Record<string, unknown>> {
     /** Raw backend data object */
-    data: Record<string, unknown>;
+    data: TData;
     /** Card title */
     title: string;
     /** Ordered list of field definitions (use { type: "divider" } for dividers) */
-    fields: FieldConfig[];
+    fields: FieldConfig<TData>[];
     /** Number of columns on desktop (3 or 4) */
     columns?: Columns;
     /** Additional CSS classes */
@@ -3030,12 +3266,12 @@ export declare const Field: {
 /**
  * A field configuration - either a divider or a field definition
  */
-declare type FieldConfig = FieldDivider | FieldDefinition;
+declare type FieldConfig<TData extends object = Record<string, unknown>> = FieldDivider | FieldDefinition<TData>;
 
 /**
  * Field definition - renders a key-value pair
  */
-declare interface FieldDefinition {
+declare interface FieldDefinition<TData extends object = Record<string, unknown>> {
     /** Field type determines rendering (defaults to "text") */
     type?: FieldType_2;
     /** Path to the value in the data object (supports dot notation) */
@@ -3046,6 +3282,12 @@ declare interface FieldDefinition {
     meta?: FieldMeta;
     /** Behavior when value is empty (defaults to "dash") */
     emptyBehavior?: EmptyBehavior;
+    /**
+     * Draws the field from `data` instead of using `type`. Wins over `type` and
+     * replaces the built-in output, so `meta` is not applied. Still runs when the
+     * value at `key` is empty; `emptyBehavior: "hide"` is checked first.
+     */
+    render?: FieldRender<TData>;
 }
 
 /**
@@ -3108,6 +3350,9 @@ export declare interface FieldMetadata {
     };
 }
 
+/** Renders a field from the whole `data` object, like `render` on DataTable's `Column`. */
+declare type FieldRender<TData extends object = Record<string, unknown>> = (data: TData) => ReactNode;
+
 declare type FieldRootProps = Pick<React_2.ComponentProps<typeof Field_2.Root>, "name" | "disabled" | "validate" | "validationMode" | "validationDebounceTime" | "className" | "style"> & {
     children: React_2.ReactNode;
     /** Whether the field has been blurred. Maps to Base UI's `touched`. */
@@ -3347,10 +3592,16 @@ declare namespace Footer_3 {
  * </Form>
  * ```
  */
-export declare function Form<FormValues extends Record<string, any> = Record<string, any>>({ className, children, ...props }: FormProps<FormValues>): JSX.Element;
+export declare const Form: FormComponent;
 
-export declare namespace Form {
-    var displayName: string;
+/**
+ * Typed explicitly rather than as a `function` + `displayName` expando: that form is
+ * emitted as a namespace merge, which the declaration rollup duplicates as a second,
+ * non-exported `declare namespace Form` — TS2395 for consumers. See `check-dts`.
+ */
+declare interface FormComponent {
+    <FormValues extends Record<string, any> = Record<string, any>>(props: FormProps<FormValues>): React_2.JSX.Element;
+    displayName?: string;
 }
 
 export declare type FormProps<FormValues extends Record<string, any> = Record<string, any>> = Pick<React_2.ComponentProps<typeof Form_2>, "errors" | "actionsRef" | "validationMode" | "noValidate" | "ref" | "className" | "style"> & {
@@ -3640,6 +3891,12 @@ export declare type InferCsvRow<T extends CsvSchema> = {
  */
 declare type InferredColumn<TRow extends Record<string, unknown>> = ColumnBase<TRow>;
 
+declare type InferredFieldFilterType<TTable extends TableMetadata, TFieldName extends TableFieldName<TTable>> = Extract<TTable["fields"][number], {
+    readonly name: TFieldName;
+}> extends {
+    readonly type: infer TType;
+} ? TType extends keyof FieldTypeToFilterConfigType ? FieldTypeToFilterConfigType[TType] : never : never;
+
 /**
  * A styled input component.
  *
@@ -3766,12 +4023,17 @@ declare type LabelValue = string | ((props: any) => string);
  * </Layout>
  * ```
  */
-export declare function Layout({ columns, className, style, gap, title, actions, fill, children, }: LayoutProps): JSX.Element;
+export declare const Layout: LayoutComponent;
 
-export declare namespace Layout {
-    var Column: React_2.ForwardRefExoticComponent<ColumnProps & React_2.RefAttributes<HTMLDivElement>>;
-    var Header: Header;
-}
+/**
+ * Typed explicitly rather than assigning onto a `function Layout`: that form emits
+ * `var Header: typeof import("./Layout").Header`, which the declaration rollup
+ * rewrites to a bare `Header` — a namespace, not a type (TS2709). See `check-dts`.
+ */
+declare type LayoutComponent = typeof LayoutRoot & {
+    Column: typeof Column_2;
+    Header: typeof Header;
+};
 
 /**
  * Props for Layout.Header component
@@ -3839,6 +4101,9 @@ export declare interface LayoutProps {
     children: ReactNode;
 }
 
+/** Implementation for {@link Layout}; exported below with its sub-components attached. */
+declare function LayoutRoot({ columns, className, style, gap, title, actions, fill, children, }: LayoutProps): JSX.Element;
+
 /** An accessible legend that is automatically associated with the fieldset. */
 declare function Legend({ className, ...props }: React_2.ComponentProps<typeof Fieldset_2.Legend>): JSX.Element;
 
@@ -3848,17 +4113,6 @@ declare namespace Legend {
 
 export { Link }
 
-/**
- * Draws an orthogonal connector between two row items.
- *
- * If either referenced `Timeline.Interval` id is unresolved, nothing is rendered.
- */
-declare function Link_2({ from, to, fromAnchor, toAnchor, arrow, gap, className, style, strokeWidth, }: TimelineLinkProps): React_2.ReactPortal | null;
-
-declare namespace Link_2 {
-    var displayName: string;
-}
-
 /** Options for `type: "link"` cells. `href` is required. */
 declare interface LinkCellOptions<TRow extends Record<string, unknown>> {
     /**
@@ -3875,6 +4129,8 @@ declare namespace LinkItem {
     var displayName: string;
 }
 
+export { LinkProps }
+
 /** Groups the individual tab buttons. */
 declare function List({ className, children, ...props }: React_2.ComponentProps<typeof Tabs_2.List>): JSX.Element;
 
@@ -3886,6 +4142,8 @@ declare type LoaderHandler = (args: LoaderFunctionArgs) => Promise<unknown> | un
 
 declare type LocalizedString = string | ((locale: string) => string);
 
+export { Location_2 as Location }
+
 /** Shape returned by `mapItem` to describe how an item appears in the dropdown. */
 export declare interface MappedItem {
     /** Display text — used for filtering, a11y, and fallback display. */
@@ -3925,10 +4183,14 @@ declare namespace MenuSeparator {
     var displayName: string;
 }
 
+declare type MetadataFieldFilterOptions<TType extends FilterConfig["type"] = FilterConfig["type"]> = {
+    operators?: NonEmptyReadonlyArray<DataTableUiFilterOperatorByType[TType]>;
+};
+
 /**
  * Options for metadata-based single field inference.
  */
-export declare interface MetadataFieldOptions {
+export declare type MetadataFieldOptions<TType extends FilterConfig["type"] = FilterConfig["type"]> = {
     /** Override the column header text. Defaults to the field's `description` or `name` from metadata. */
     label?: string;
     /** Fixed column width in pixels. When omitted the column sizes naturally. */
@@ -3939,11 +4201,21 @@ export declare interface MetadataFieldOptions {
      */
     sort?: boolean;
     /**
-     * Set to `false` to suppress the auto-generated filter config for this field.
-     * Defaults to `true` (filter is enabled when the field type supports it).
+     * Set to `false` to suppress the auto-generated filter config for this field,
+     * or pass `operators` to narrow the DataTable filter conditions exposed for
+     * this field.
+     *
+     * When used through `inferColumns()` with specific table metadata, operator
+     * literals are narrowed to the inferred field type. If the metadata has
+     * already widened to `TableMetadata`, mismatched operators are still filtered
+     * out at runtime.
      */
-    filter?: boolean;
-}
+    filter?: boolean | MetadataFieldFilterOptions<TType>;
+};
+
+declare type MetadataFieldOptionsForField<TTable extends TableMetadata, TFieldName extends TableFieldName<TTable>> = MetadataFieldOptions<[
+InferredFieldFilterType<TTable, TFieldName>
+] extends [never] ? FilterConfig["type"] : InferredFieldFilterType<TTable, TFieldName>>;
 
 /**
  * MetricCard — Compact card for dashboard KPI display (title, value, optional trend and description).
@@ -4031,6 +4303,18 @@ declare interface MoneyCellOptions<TRow extends Record<string, unknown>> {
     locale?: string;
 }
 
+export { Navigate }
+
+export { NavigateFunction }
+
+export { NavigateOptions }
+
+export { Navigation }
+
+export { NavLink }
+
+export { NavLinkProps }
+
 /**
  * Extract the node type from a cursor connection result.
  */
@@ -4040,6 +4324,8 @@ export declare type NodeType<T extends {
     }[];
 } | null | undefined> = NonNullable<T>["edges"][number]["node"];
 
+declare type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+
 /**
  * Header render context for non-sortable columns.
  */
@@ -4160,6 +4446,8 @@ declare namespace Panel {
     var displayName: string;
 }
 
+export { Params }
+
 export { parseAbsolute }
 
 export { parseDate }
@@ -4191,7 +4479,23 @@ export { parseZonedDateTime }
  */
 export declare const pass: () => GuardResult;
 
-/* Excluded from this release type: PositionProps */
+export { PathMatch }
+
+/**
+ * Shared positioning props for components that wrap both a Base UI Popup and
+ * Positioner internally (e.g. Menu.Content, Tooltip.Content).
+ *
+ * Grouping Positioner-specific props under a `position` namespace prevents
+ * name collisions with the Popup's own props and keeps the type surface clean.
+ */
+export declare interface PositionProps {
+    /** Which side of the anchor element to position against. */
+    side?: "top" | "right" | "bottom" | "left";
+    /** How to align the popup relative to the anchor along the cross axis. */
+    align?: "start" | "center" | "end";
+    /** Distance (in px) between the popup and the anchor edge. */
+    sideOffset?: number;
+}
 
 /** Provides shared delay configuration for nested tooltips. */
 declare function Provider({ delay, children, ...props }: ProviderProps): JSX.Element;
@@ -4225,6 +4529,48 @@ declare namespace RadioItemIndicator {
     var displayName: string;
 }
 
+/**
+ * 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
+ * click completes it — picking a day before the first swaps the endpoints.
+ *
+ * @example
+ * ```tsx
+ * import { RangeCalendar, type DateRange } from "@tailor-platform/app-shell";
+ *
+ * const [range, setRange] = useState<DateRange | null>(null);
+ * <RangeCalendar aria-label="Stay dates" value={range} onChange={setRange} />
+ * ```
+ */
+export declare function RangeCalendar<T extends DateValue = DateValue>({ value, defaultValue, onChange, minValue, maxValue, isDateUnavailable, isDisabled, isReadOnly, focusedValue, defaultFocusedValue, onFocusChange, firstDayOfWeek, timeZone: timeZoneProp, locale: localeProp, className, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, }: RangeCalendarProps<T>): JSX.Element;
+
+/**
+ * Public, closed-API standalone range calendar — the @internationalized/date +
+ * Base UI implementation. Same surface as the react-aria variant; only the
+ * internals differ. Consumers never see Base UI or the calendar engine.
+ */
+export declare interface RangeCalendarProps<T extends DateValue = DateValue> {
+    value?: DateRange<T> | null;
+    defaultValue?: DateRange<T> | null;
+    /** Fired once per selection, when the second date completes the range. */
+    onChange?: (value: DateRange<T>) => void;
+    minValue?: DateValue;
+    maxValue?: DateValue;
+    isDateUnavailable?: (date: DateValue) => boolean;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    focusedValue?: DateValue;
+    defaultFocusedValue?: DateValue;
+    onFocusChange?: (date: CalendarDate) => void;
+    firstDayOfWeek?: FirstDayOfWeek;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    timeZone?: string;
+    className?: string;
+    /** BCP-47 locale override; defaults to the AppShell formatting locale. */
+    locale?: string;
+}
+
 /**
  * Redirect to another path.
  *
@@ -4642,6 +4988,54 @@ export declare interface RowAction<TRow extends Record<string, unknown>> {
     onClick: (row: TRow) => void;
 }
 
+/**
+ * Expandable-row configuration for `useDataTable`.
+ *
+ * The union is what makes an invalid setup unrepresentable: pass `expandedIds`
+ * and you must pass `onChange` with it (controlled), or pass neither and let
+ * the hook own the state. `onChange` alone is still allowed — in uncontrolled
+ * mode it is a notification.
+ */
+declare type RowExpansionOptions<TRow extends Record<string, unknown>> = {
+    /** Renders the detail panel for an expanded row. */
+    render: (row: TRow) => ReactNode;
+    /**
+     * Decides whether a row can be expanded. Rows returning `false` render an
+     * empty cell in place of the chevron. Defaults to `true` for rows with an
+     * `id`. Gates the panel in both directions: an id in `expandedIds` never
+     * opens a panel for a row this rejects.
+     */
+    canExpand?: (row: TRow) => boolean;
+    /**
+     * The row's record identity — a **bare identifier** such as `"INV-1001"`, not
+     * a sentence. The built-in i18n labels compose it into the accessible names of
+     * the chevron ("Expand row INV-1001") and the panel ("INV-1001 details").
+     * Without it, the generic "Expand row" / "Row details" fallbacks are used.
+     */
+    getLabel?: (row: TRow) => string;
+} & ({
+    /**
+     * Ids of the expanded rows. Passing this switches expansion to
+     * **controlled** mode: internal state is never written and you update this
+     * array from `onChange`.
+     *
+     * **Batching caveat:** each toggle derives the next array from this
+     * value, so two toggles dispatched before your state commits share a base
+     * and the first is lost. Relevant behind an async store (a debounced URL
+     * sync, `startTransition`) or when looping the toggle over many rows.
+     */
+    expandedIds: string[];
+    /** Called with the full array of expanded ids. Fires once per toggle. */
+    onChange: (ids: string[]) => void;
+} | {
+    expandedIds?: never;
+    /**
+     * Optional notification in uncontrolled mode, called with the full array
+     * of expanded ids. Fires once per toggle, including under StrictMode.
+     */
+    onChange?: (ids: string[]) => void;
+});
+
 /**
  * Setter shape compatible with `useSearchParams()`.
  */
@@ -5467,6 +5861,67 @@ declare type TabsSize = "xs" | "sm" | "default" | "lg";
 
 declare type TabsVariant = "default" | "line" | "capsule";
 
+/**
+ * A styled multi-line text input.
+ *
+ * Wraps Base UI's `Field.Control` rendered as a `<textarea>`, so it works with
+ * `Field` and React Hook Form the same way `Input`, `Checkbox`, and `Select`
+ * do — placed inside a `Field.Root` it inherits label association,
+ * `aria-describedby`, `disabled`, and the `data-invalid` error state
+ * automatically (no `error` prop of its own). Outside a `Field.Root` it
+ * renders as a plain standalone control.
+ *
+ * The box has no fixed height: `rows` sets the visible line count, and the user
+ * can drag it taller. `min-h-16` is a hard floor, so `rows={1}` and `rows={2}`
+ * both render at 64px — `rows` only starts moving the height from 3 up.
+ *
+ * @example
+ * ### Standalone
+ * ```tsx
+ * const [note, setNote] = React.useState("");
+ *
+ * <Textarea value={note} onChange={(event) => setNote(event.target.value)} placeholder="Add a note…" />
+ * ```
+ *
+ * @example
+ * ### Taller
+ * ```tsx
+ * <Textarea rows={8} placeholder="Paste the incident log…" />
+ * ```
+ *
+ * @example
+ * ### Inside a Field
+ * ```tsx
+ * <Field.Root name="description">
+ *   <Field.Label>Description</Field.Label>
+ *   <Textarea rows={5} placeholder="What changed?" />
+ *   <Field.Description>Optional — visible to the whole team.</Field.Description>
+ * </Field.Root>
+ * ```
+ *
+ * @example
+ * ### With React Hook Form
+ * ```tsx
+ * <Controller
+ *   name="description"
+ *   control={control}
+ *   rules={{ required: "Description is required." }}
+ *   render={({ field, fieldState }) => (
+ *     <Field.Root name={field.name} {...fieldState}>
+ *       <Field.Label>Description</Field.Label>
+ *       <Textarea {...field} rows={5} />
+ *       <Field.Error />
+ *     </Field.Root>
+ *   )}
+ * />
+ * ```
+ */
+export declare function Textarea({ className, ...props }: TextareaProps): JSX.Element;
+
+export declare type TextareaProps = Omit<React_2.ComponentProps<typeof Field_2.Control>, "render" | "onChange" | "className"> & Pick<React_2.ComponentProps<"textarea">, "onChange" | "rows"> & {
+    className?: string;
+};
+
 export { Time }
 
 /**
@@ -5489,7 +5944,7 @@ export declare const Timeline: {
     Viewport: typeof Viewport;
     Row: typeof Row_2;
     Interval: typeof Interval;
-    Link: typeof Link_2;
+    Link: typeof TimelineLink;
 };
 
 /**
@@ -5669,6 +6124,17 @@ export declare type TimelineIntervalProps = {
     style?: React_2.CSSProperties;
 };
 
+/**
+ * Draws an orthogonal connector between two row items.
+ *
+ * If either referenced `Timeline.Interval` id is unresolved, nothing is rendered.
+ */
+declare function TimelineLink({ from, to, fromAnchor, toAnchor, arrow, gap, className, style, strokeWidth, }: TimelineLinkProps): React_2.ReactPortal | null;
+
+declare namespace TimelineLink {
+    var displayName: string;
+}
+
 /**
  * Shared defaults for `Timeline.Link` instances inside one viewport.
  */
@@ -5839,6 +6305,8 @@ declare namespace Title_3 {
     var displayName: string;
 }
 
+export { To }
+
 export declare const Tooltip: {
     Root: typeof Root_12;
     Trigger: typeof Trigger_4;
@@ -6289,6 +6757,10 @@ export declare const useAuthSuspense: () => {
     checkAuthStatus: () => Promise<AuthState>;
 };
 
+export { useBeforeUnload }
+
+export { useBlocker }
+
 /**
  * Hook to access collection control from the nearest `CollectionControlProvider`.
  *
@@ -6615,6 +7087,22 @@ export declare type UseDataTableOptions<TRow extends Record<string, unknown>, TF
      * the rows on the **current page**, not all pages.
      */
     onSelectionChange?: (ids: string[]) => void;
+    /**
+     * Expandable detail rows. Providing this enables the whole feature: a chevron
+     * column is added at the left edge (auto-pinned left, after the selection
+     * column) and `render`'s output appears in a full-width row beneath its parent.
+     *
+     * Grouped rather than flat so the parts can't be configured in a broken
+     * combination — a label or predicate without a renderer, or `expandedIds`
+     * without `onChange`, are all compile errors.
+     *
+     * **Requirement:** Each row must have a string or number `id` field.
+     * Expansion is keyed by `id`, so rows without one render no chevron.
+     *
+     * **Note:** Expansion is **not** cleared on page change — ids of rows no
+     * longer on the page simply do not render. Call `collapseAllRows()` to reset.
+     */
+    rowExpansion?: RowExpansionOptions<TRow>;
     /**
      * Sort behaviour configuration.
      *
@@ -6699,6 +7187,16 @@ export declare interface UseDataTableReturn<TRow extends Record<string, unknown>
     clearSelection?: () => void;
     isAllSelected: boolean;
     isIndeterminate: boolean;
+    /** Ids of the currently expanded rows. */
+    expandedIds: string[];
+    /** Whether `row` is currently expanded. Always `false` for rows without an `id`. */
+    isRowExpanded: (row: TRow) => boolean;
+    /** Toggle `row`'s detail panel. Undefined when `rowExpansion` is not provided. */
+    toggleRowExpansion?: (row: TRow) => void;
+    /** Collapse every expanded row. Undefined when `rowExpansion` is not provided. */
+    collapseAllRows?: () => void;
+    /** Expansion config (passthrough for `DataTable.Root`). */
+    rowExpansion?: RowExpansionOptions<TRow>;
 }
 
 /**
@@ -6720,7 +7218,7 @@ export declare interface UseDataTableReturn<TRow extends Record<string, unknown>
  * </Combobox.Parts.Root>
  * ```
  */
-declare const useFilter: typeof Combobox_2.useFilter;
+declare function useFilter(options?: ComboboxFilterOptions): ComboboxFilter;
 
 /**
  * Hook for robust string matching using `Intl.Collator`.
@@ -6741,12 +7239,16 @@ declare const useFilter: typeof Combobox_2.useFilter;
  * </Autocomplete.Parts.Root>
  * ```
  */
-declare const useFilter_2: getFilter;
+declare function useFilter_2(options?: AutocompleteFilterOptions): AutocompleteFilter;
 
 export { useLocation }
 
+export { useMatch }
+
 export { useNavigate }
 
+export { useNavigation }
+
 /**
  * Returns a function that opens the CommandPalette.
  *
@@ -6826,6 +7328,8 @@ export declare const useResolvedLocale: () => {
     language: string;
 };
 
+export { useResolvedPath }
+
 export { useRouteError }
 
 export { useSearchParams }
@@ -7055,3 +7559,603 @@ export declare function withURLCollectionState(options: UseCollectionOptions & {
 export { ZonedDateTime }
 
 export { }
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Title {
+    var displayName: string;
+}
+
+
+declare namespace Description {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Image {
+    var displayName: string;
+}
+
+
+declare namespace Fallback {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Viewport {
+    var displayName: string;
+}
+
+
+declare namespace Row {
+    var displayName: string;
+}
+
+
+declare namespace Interval {
+    var displayName: string;
+}
+
+
+declare namespace TimelineLink {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Trigger {
+    var displayName: string;
+}
+
+
+declare namespace Content {
+    var displayName: string;
+}
+
+
+declare namespace Item {
+    var displayName: string;
+}
+
+
+declare namespace LinkItem {
+    var displayName: string;
+}
+
+
+declare namespace CheckboxItem {
+    var displayName: string;
+}
+
+
+declare namespace CheckboxItemIndicator {
+    var displayName: string;
+}
+
+
+declare namespace RadioItem {
+    var displayName: string;
+}
+
+
+declare namespace RadioItemIndicator {
+    var displayName: string;
+}
+
+
+declare namespace RadioGroup {
+    var displayName: string;
+}
+
+
+declare namespace Group {
+    var displayName: string;
+}
+
+
+declare namespace GroupLabel {
+    var displayName: string;
+}
+
+
+declare namespace MenuSeparator {
+    var displayName: string;
+}
+
+
+declare namespace SubmenuRoot {
+    var displayName: string;
+}
+
+
+declare namespace SubmenuTrigger {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+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 Trigger {
+    var displayName: string;
+}
+
+
+declare namespace Close {
+    var displayName: string;
+}
+
+
+declare namespace Content {
+    var displayName: string;
+}
+
+
+declare namespace Header {
+    var displayName: string;
+}
+
+
+declare namespace Footer {
+    var displayName: string;
+}
+
+
+declare namespace Title {
+    var displayName: string;
+}
+
+
+declare namespace Description {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Header {
+    var displayName: string;
+}
+
+
+declare namespace Body {
+    var displayName: string;
+}
+
+
+declare namespace Footer {
+    var displayName: string;
+}
+
+
+declare namespace Row {
+    var displayName: string;
+}
+
+
+declare namespace Head {
+    var displayName: string;
+}
+
+
+declare namespace Cell {
+    var displayName: string;
+}
+
+
+declare namespace Caption {
+    var displayName: string;
+}
+
+
+declare namespace Provider {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Trigger {
+    var displayName: string;
+}
+
+
+declare namespace Content {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Header {
+    var displayName: string;
+}
+
+
+declare namespace Content {
+    var displayName: string;
+}
+
+
+declare namespace SelectRoot {
+    var displayName: string;
+}
+
+
+declare namespace SelectTrigger {
+    var displayName: string;
+}
+
+
+declare namespace SelectValue {
+    var displayName: string;
+}
+
+
+declare namespace SelectContent {
+    var displayName: string;
+}
+
+
+declare namespace SelectItem {
+    var displayName: string;
+}
+
+
+declare namespace SelectGroup {
+    var displayName: string;
+}
+
+
+declare namespace SelectGroupLabel {
+    var displayName: string;
+}
+
+
+declare namespace SelectSeparator {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Trigger {
+    var displayName: string;
+}
+
+
+declare namespace Close {
+    var displayName: string;
+}
+
+
+declare namespace Content {
+    var displayName: string;
+}
+
+
+declare namespace Header {
+    var displayName: string;
+}
+
+
+declare namespace Footer {
+    var displayName: string;
+}
+
+
+declare namespace Title {
+    var displayName: string;
+}
+
+
+declare namespace Description {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxRoot {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxInput {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxTrigger {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxInputGroup {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxContent {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxList {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxItem {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxEmpty {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxGroup {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxGroupLabel {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxClear {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxChips {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxChip {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxChipRemove {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxValue {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxStatus {
+    var displayName: string;
+}
+
+
+declare namespace ComboboxCollection {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Label {
+    var displayName: string;
+}
+
+
+declare namespace Control {
+    var displayName: string;
+}
+
+
+declare namespace Description {
+    var displayName: string;
+}
+
+
+declare namespace Error {
+    var displayName: string;
+}
+
+
+declare namespace Validity {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteRoot {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteValue {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteInput {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteTrigger {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteInputGroup {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteContent {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteList {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteItem {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteEmpty {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteClear {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteGroup {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteGroupLabel {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteCollection {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteStatus {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteStandalone {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteAsyncStandalone {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Legend {
+    var displayName: string;
+}
+
+
+declare namespace DataTableRoot {
+    var displayName: string;
+}
+
+
+declare namespace DataTableTable {
+    var displayName: string;
+}
+
+
+declare namespace DataTableFooter {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Items {
+    var displayName: string;
+}
+
+
+declare namespace Item {
+    var displayName: string;
+}
+
+
+declare namespace DataTableToolbar {
+    var displayName: string;
+}
+
+
+declare namespace DataTableFilters {
+    var displayName: string;
+}
+
+
+declare namespace AsyncErrorState {
+    var displayName: string;
+}
+
+
+declare namespace DataTableColumnSettings {
+    var displayName: string;
+}