@tailor-platform/app-shell 1.12.0 → 1.14.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,17 +21,25 @@ 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';
@@ -35,11 +49,17 @@ 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';
@@ -272,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>;
 };
 
 /**
@@ -718,7 +737,7 @@ declare const AutocompleteParts: {
 
 declare type AutocompleteParts = typeof AutocompleteParts;
 
-declare type AutocompletePickedRootProps<Value> = Pick<AutocompleteRootProps<Value>, "value" | "defaultValue" | "onValueChange" | "filter" | "disabled" | "children"> & {
+declare type AutocompletePickedRootProps<Value> = Pick<AutocompleteRootProps<Value>, "value" | "defaultValue" | "onValueChange" | "filter" | "disabled" | "children" | "name" | "form" | "required" | "inputRef" | "id"> & {
     items?: readonly Value[];
 };
 
@@ -760,6 +779,29 @@ declare interface AutocompletePropsBase<T> {
     "aria-labelledby"?: string;
     /** ID applied to the combobox input element. */
     id?: string;
+    /**
+     * Identifies the field when a form is submitted, so the current text is
+     * picked up by **native** form submission (`new FormData(form)`, a plain
+     * `<form>`, server actions).
+     *
+     * Autocomplete's value is the raw input string, so no value-serialisation
+     * hook is needed (unlike `Select` and `Combobox`).
+     *
+     * **Inside a `Field.Root`, the field's `name` wins and this prop is ignored** —
+     * the hidden input is named after the field. Set it only when the control is
+     * used outside a `Field.Root` (or when it must differ from the field name,
+     * which it cannot).
+     */
+    name?: string;
+    /**
+     * `id` of the form that owns the input. Use when the autocomplete is
+     * rendered outside the `<form>` element it belongs to.
+     */
+    form?: string;
+    /** Whether a value must be entered before the owning form can be submitted. */
+    required?: boolean;
+    /** Ref to the underlying input element. */
+    inputRef?: React_2.Ref<HTMLInputElement>;
 }
 
 declare function AutocompleteRoot<Value>(props: AutocompletePickedRootProps<Value>): JSX.Element;
@@ -875,6 +917,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;
 
@@ -968,8 +1014,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;
@@ -1234,6 +1286,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
  */
@@ -1317,9 +1421,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;
 }
 
 /**
@@ -1372,13 +1482,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
@@ -1455,7 +1565,7 @@ declare type ColumnTypeBranch<TRow extends Record<string, unknown>> = {
 
 export declare const Combobox: ComboboxComponent;
 
-declare type ComboboxAsyncCreatableProps<T extends object> = (ComboboxAsyncOwnProps<T> & CreatableProps<T> & Omit<ComboboxPropsSingle<T>, "mapItem">) | (ComboboxAsyncOwnProps<T> & CreatableProps<T> & Omit<ComboboxPropsMultiple<T>, "mapItem">);
+declare type ComboboxAsyncCreatableProps<T extends object> = (ComboboxAsyncOwnProps<T> & CreatableProps<T> & Omit<ComboboxPropsSingle<T>, "mapItem" | "itemToStringValue">) | (ComboboxAsyncOwnProps<T> & CreatableProps<T> & Omit<ComboboxPropsMultiple<T>, "mapItem" | "itemToStringValue">);
 
 /** Fetcher type for `Combobox.Async`. */
 export declare type ComboboxAsyncFetcher<T> = AsyncFetcher<T>;
@@ -1632,6 +1742,37 @@ declare interface ComboboxPropsBase<T> {
     "aria-labelledby"?: string;
     /** ID applied to the combobox input element. */
     id?: string;
+    /**
+     * Identifies the field when a form is submitted. Base UI renders a hidden
+     * input under this name, so the selected value is picked up by **native**
+     * form submission (`new FormData(form)`, a plain `<form>`, server actions).
+     *
+     * For non-string items, pair this with `itemToStringValue` to control how
+     * the value is serialised.
+     *
+     * **Inside a `Field.Root`, the field's `name` wins and this prop is ignored** —
+     * the hidden input is named after the field. Set it only when the control is
+     * used outside a `Field.Root` (or when it must differ from the field name,
+     * which it cannot).
+     */
+    name?: string;
+    /**
+     * `id` of the form that owns the hidden input. Use when the combobox is
+     * rendered outside the `<form>` element it belongs to.
+     */
+    form?: string;
+    /** Whether a value must be chosen before the owning form can be submitted. */
+    required?: boolean;
+    /** Ref to the hidden input that carries the value during form submission. */
+    inputRef?: React_2.Ref<HTMLInputElement>;
+    /**
+     * Converts a non-string item to the string written into the hidden input on
+     * form submission. Items shaped `{ value, label }` use `value` automatically.
+     *
+     * Distinct from `mapItem`, which controls what the user sees. Not available
+     * on the creatable variants, which own value serialisation.
+     */
+    itemToStringValue?: (item: T) => string;
 }
 
 declare interface ComboboxPropsMultiple<T> extends ComboboxPropsBase<T> {
@@ -1660,7 +1801,7 @@ declare namespace ComboboxRoot {
     var displayName: string;
 }
 
-declare type ComboboxRootProps<Value, Multiple extends boolean | undefined = false> = Pick<React_2.ComponentProps<typeof Combobox_2.Root<Value, Multiple>>, "items" | "value" | "defaultValue" | "onValueChange" | "multiple" | "filter" | "inputValue" | "onInputValueChange" | "onOpenChange" | "itemToStringLabel" | "itemToStringValue" | "disabled" | "children">;
+declare type ComboboxRootProps<Value, Multiple extends boolean | undefined = false> = Pick<React_2.ComponentProps<typeof Combobox_2.Root<Value, Multiple>>, "items" | "value" | "defaultValue" | "onValueChange" | "multiple" | "filter" | "inputValue" | "onInputValueChange" | "onOpenChange" | "itemToStringLabel" | "itemToStringValue" | "disabled" | "children" | "name" | "form" | "required" | "inputRef" | "id">;
 
 declare function ComboboxStandalone<T extends object>(props: ComboboxStaticCreatableProps<T>): React_2.JSX.Element;
 
@@ -1668,9 +1809,9 @@ declare function ComboboxStandalone<I>(props: ComboboxStaticPlainProps<I>): Reac
 
 declare type ComboboxStaticCreatableProps<T extends object> = ({
     items: T[];
-} & CreatableProps<T> & Omit<ComboboxPropsSingle<T>, "mapItem">) | ({
+} & CreatableProps<T> & Omit<ComboboxPropsSingle<T>, "mapItem" | "itemToStringValue">) | ({
     items: T[];
-} & CreatableProps<T> & Omit<ComboboxPropsMultiple<T>, "mapItem">);
+} & CreatableProps<T> & Omit<ComboboxPropsMultiple<T>, "mapItem" | "itemToStringValue">);
 
 /**
  * @property items - Items to display. May be a flat array of `T` or an array of
@@ -2144,13 +2285,15 @@ export declare const DataTable: {
      * **Requires `control`** — `useDataTable()` must receive `control` from
      * `useCollectionVariables()`, otherwise this component throws at render time.
      *
-     * **Go-to-first / go-to-last buttons** — Rendered only when `totalPages` is
-     * non-null (i.e. the backend returns a total count). When `totalPages` is
-     * `null`, these buttons and the page counter are omitted.
+     * **Go-to-first / go-to-last buttons** — The first-page button is always
+     * rendered. The last-page button and page counter are rendered only when
+     * `totalPages` is non-null (i.e. the backend returns a `total` count).
      */
     readonly Pagination: typeof DataTablePagination;
 };
 
+declare type DataTableBooleanFilterOperator = OperatorForFilterType["boolean"];
+
 /**
  * Context value provided by `DataTable.Root`.
  *
@@ -2232,6 +2375,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;
@@ -2266,6 +2451,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;
 
@@ -2294,6 +2481,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;
@@ -2320,6 +2509,19 @@ declare namespace DataTableToolbar {
     var displayName: string;
 }
 
+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 {
     /**
@@ -3443,14 +3645,39 @@ declare namespace Footer_3 {
  *   <button type="submit">Submit</button>
  * </Form>
  * ```
+ *
+ * @example
+ * ### Submitting from outside the form
+ * Give the form an `id` and point a detached submit button at it with the
+ * native `form` attribute. Useful when the save action lives in a page
+ * header or a dialog footer rather than beside the fields.
+ * ```tsx
+ * <Layout.Header
+ *   title="Create product"
+ *   actions={[
+ *     <Button key="save" type="submit" form="product-form">
+ *       Save
+ *     </Button>,
+ *   ]}
+ * />
+ * <Form id="product-form" onFormSubmit={(values) => save(values)}>
+ *   …
+ * </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"> & {
+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" | "id"> & {
     children: React_2.ReactNode;
     /**
      * Low-level submit handler that receives the native `FormEvent`.
@@ -3737,6 +3964,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.
  *
@@ -3863,12 +4096,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
@@ -3936,6 +4174,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;
 
@@ -3945,17 +4186,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>> {
     /**
@@ -3972,6 +4202,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;
 
@@ -3983,6 +4215,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. */
@@ -4022,10 +4256,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. */
@@ -4036,11 +4274,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).
@@ -4130,6 +4378,16 @@ declare interface MoneyCellOptions<TRow extends Record<string, unknown>> {
 
 export { Navigate }
 
+export { NavigateFunction }
+
+export { NavigateOptions }
+
+export { Navigation }
+
+export { NavLink }
+
+export { NavLinkProps }
+
 /**
  * Extract the node type from a cursor connection result.
  */
@@ -4139,6 +4397,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.
  */
@@ -4259,6 +4519,8 @@ declare namespace Panel {
     var displayName: string;
 }
 
+export { Params }
+
 export { parseAbsolute }
 
 export { parseDate }
@@ -4290,7 +4552,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;
@@ -5012,6 +5290,36 @@ declare interface SelectPropsBase<T> {
     "aria-labelledby"?: string;
     /** ID applied to the combobox trigger element. */
     id?: string;
+    /**
+     * Identifies the field when a form is submitted. Base UI renders a hidden
+     * input under this name, so the selected value is picked up by **native**
+     * form submission (`new FormData(form)`, a plain `<form>`, server actions).
+     *
+     * For non-string items, pair this with `itemToStringValue` to control how
+     * the value is serialised.
+     *
+     * **Inside a `Field.Root`, the field's `name` wins and this prop is ignored** —
+     * the hidden input is named after the field. Set it only when the control is
+     * used outside a `Field.Root` (or when it must differ from the field name,
+     * which it cannot).
+     */
+    name?: string;
+    /**
+     * `id` of the form that owns the hidden input. Use when the select is
+     * rendered outside the `<form>` element it belongs to.
+     */
+    form?: string;
+    /** Whether a value must be chosen before the owning form can be submitted. */
+    required?: boolean;
+    /** Ref to the hidden input that carries the value during form submission. */
+    inputRef?: React_2.Ref<HTMLInputElement>;
+    /**
+     * Converts a non-string item to the string written into the hidden input on
+     * form submission. Items shaped `{ value, label }` use `value` automatically.
+     *
+     * Distinct from `mapItem`, which controls what the user sees.
+     */
+    itemToStringValue?: (item: T) => string;
 }
 
 declare interface SelectPropsMultiple<T> extends SelectPropsBase<T> {
@@ -5044,7 +5352,7 @@ declare namespace SelectRoot {
     var displayName: string;
 }
 
-declare type SelectRootProps<Value, Multiple extends boolean | undefined = false> = Pick<React_2.ComponentProps<typeof Select_2.Root<Value, Multiple>>, "value" | "defaultValue" | "onValueChange" | "open" | "onOpenChange" | "modal" | "multiple" | "itemToStringLabel" | "disabled" | "children">;
+declare type SelectRootProps<Value, Multiple extends boolean | undefined = false> = Pick<React_2.ComponentProps<typeof Select_2.Root<Value, Multiple>>, "value" | "defaultValue" | "onValueChange" | "open" | "onOpenChange" | "modal" | "multiple" | "itemToStringLabel" | "itemToStringValue" | "disabled" | "children" | "name" | "form" | "required" | "inputRef" | "id">;
 
 declare function SelectSeparator({ className, ...props }: React_2.ComponentProps<"div">): JSX.Element;
 
@@ -5656,6 +5964,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 }
 
 /**
@@ -5678,7 +6047,7 @@ export declare const Timeline: {
     Viewport: typeof Viewport;
     Row: typeof Row_2;
     Interval: typeof Interval;
-    Link: typeof Link_2;
+    Link: typeof TimelineLink;
 };
 
 /**
@@ -5858,6 +6227,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.
  */
@@ -6028,6 +6408,8 @@ declare namespace Title_3 {
     var displayName: string;
 }
 
+export { To }
+
 export declare const Tooltip: {
     Root: typeof Root_12;
     Trigger: typeof Trigger_4;
@@ -6478,6 +6860,10 @@ export declare const useAuthSuspense: () => {
     checkAuthStatus: () => Promise<AuthState>;
 };
 
+export { useBeforeUnload }
+
+export { useBlocker }
+
 /**
  * Hook to access collection control from the nearest `CollectionControlProvider`.
  *
@@ -6935,7 +7321,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`.
@@ -6956,12 +7342,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.
  *
@@ -7041,6 +7431,8 @@ export declare const useResolvedLocale: () => {
     language: string;
 };
 
+export { useResolvedPath }
+
 export { useRouteError }
 
 export { useSearchParams }
@@ -7270,3 +7662,603 @@ export declare function withURLCollectionState(options: UseCollectionOptions & {
 export { ZonedDateTime }
 
 export { }
+
+
+declare namespace AutocompleteStandalone {
+    var displayName: string;
+}
+
+
+declare namespace AutocompleteAsyncStandalone {
+    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 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 Provider {
+    var displayName: string;
+}
+
+
+declare namespace Root {
+    var displayName: string;
+}
+
+
+declare namespace Trigger {
+    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 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 Image {
+    var displayName: string;
+}
+
+
+declare namespace Fallback {
+    var displayName: string;
+}
+
+
+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 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 Root {
+    var displayName: string;
+}
+
+
+declare namespace List {
+    var displayName: string;
+}
+
+
+declare namespace Tab {
+    var displayName: string;
+}
+
+
+declare namespace Panel {
+    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 DataTableRoot {
+    var displayName: string;
+}
+
+
+declare namespace DataTableTable {
+    var displayName: string;
+}
+
+
+declare namespace DataTableFooter {
+    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 Root {
+    var displayName: string;
+}
+
+
+declare namespace Legend {
+    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 Content {
+    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;
+}