@servicetitan/anvil2 3.0.6 → 3.0.7

package/dist/src/beta/components/MultiSelectField/types.d.ts

@@ -1,8 +1,9 @@
 import { AriaAttributes, CSSProperties, ReactElement, ReactNode } from 'react';
-import { AiMarkWithTooltipOrPopoverProps, CheckState, LayoutUtilProps, Size } from '../../../types';
-import { SelectFieldGroupByValue, SelectFieldOption } from '../SelectField/types';
+import { AiMarkWithTooltipOrPopoverProps, LayoutUtilProps, Size } from '../../../types';
+import { SelectFieldGroupByValue, SelectFieldOption, SelectFieldOptionContent } from '../SelectField/types';
 import { ChipProps } from '../../../components/Chip';
 import { AddNewItemProps } from '../../../internal/types/addNewItemTypes';
+import { BulkActionConfig } from '../../../internal/types/bulkActionTypes';
 /**
  * Partial chip props that can be returned from the `getChipProps` callback.
  * Supports `icon` or `avatar` (mutually exclusive) and all other chip props as optional overrides.
@@ -34,6 +35,11 @@ export type MultiSelectFieldHandle = {
     invalidate: () => void;
 };
 export type MultiSelectFieldGroupByValue = SelectFieldGroupByValue;
+/**
+ * Rich content configuration for a MultiSelectField option row.
+ * Controls the avatar, icon, description, and chip display within an option.
+ */
+export type MultiSelectFieldOptionContent = SelectFieldOptionContent;
 export type MultiSelectFieldOption = SelectFieldOption;
 export type MultiSelectFieldGroupedOption = MultiSelectFieldOption & {
     group: MultiSelectFieldGroupByValue;
@@ -210,27 +216,18 @@ type MultiSelectFieldCommonProps = {
      * Configuration for the "Select All" option at the top of the list.
      * When provided, a "Select All" option will be shown while the search input is empty.
      *
+     * Pass exactly one of `onClick` (fire-and-forget; the consumer commits via
+     * `onSelectedOptionsChange`) or `compute` (returns the next selection; the
+     * field commits the result for you, with sync or async support).
+     *
+     * While a `compute` promise is pending, the bulk row shows a loading state,
+     * all option rows are disabled, and stale resolutions are silently discarded.
+     *
      * Select All and Select Filtered are mutually exclusive:
      * - Select All is shown when the search input is empty.
      * - Select Filtered (if provided) is shown when a search term is active.
      */
-    selectAll?: {
-        /**
-         * The label to display for the "Select All" option.
-         * @default "Select All"
-         */
-        label?: string;
-        /**
-         * Callback when the "Select All" option is clicked.
-         * The parent component is responsible for handling the select/deselect all logic.
-         */
-        onClick: () => void;
-        /**
-         * Check state for the "Select All" option.
-         * @default false
-         */
-        checkState: boolean | CheckState;
-    };
+    selectAll?: BulkActionConfig;
     /**
      * Function that receives the current search value and returns configuration for
      * the "Select Filtered" option at the top of the list.
@@ -238,28 +235,16 @@ type MultiSelectFieldCommonProps = {
      * When provided and a search term is active, a "Select Filtered" option will be shown
      * instead of "Select All". This allows selecting all options matching the current filter.
      *
+     * See `selectAll` for the `onClick` / `compute` choice.
+     *
      * Select All and Select Filtered are mutually exclusive:
      * - Select All (if provided) is shown when the search input is empty.
      * - Select Filtered is shown when a search term is active.
      *
      * @param searchValue - The current search input value
-     * @returns Configuration object with label, onClick, and checkState
-     *
-     * @example
-     * selectFiltered={(searchValue) => ({
-     *   label: `Select items matching "${searchValue}"`,
-     *   onClick: () => handleSelectFiltered(searchValue),
-     *   checkState: allFilteredSelected ? "checked" : "unchecked",
-     * })}
-     */
-    selectFiltered?: (searchValue: string) => {
-        /** The label to display. @default `Select items matching "${searchValue}"` */
-        label?: string;
-        /** Callback when clicked. */
-        onClick: () => void;
-        /** Check state for the option. */
-        checkState: boolean | CheckState;
-    };
+     * @returns BulkActionConfig describing the row
+     */
+    selectFiltered?: (searchValue: string) => BulkActionConfig;
     /**
      * When true, restricts the field to a single row height.
      * Overflow chips will be collapsed into a "+N" indicator.

package/dist/src/beta/components/MultiSelectMenu/MultiSelectMenu.d.ts

@@ -18,6 +18,7 @@ import { MultiSelectMenuHandle, MultiSelectMenuProps } from './types';
  * - Controlled selection state
  * - Configurable popover width
  * - Optional "Add new item" affordance below the option list with consumer-owned dialog
+ * - Optional confirmation mode that buffers selection until Apply is clicked
  *
  * @example
  * <MultiSelectMenu

package/dist/src/beta/components/MultiSelectMenu/types.d.ts

@@ -1,8 +1,18 @@
 import { KeyboardEvent, ReactElement, RefObject } from 'react';
-import { CheckState } from '../../../types';
-import { SelectFieldGroupByValue, SelectFieldOption } from '../SelectField/types';
+import { SelectFieldGroupByValue, SelectFieldOption, SelectFieldOptionContent } from '../SelectField/types';
 import { MultiSelectFieldCacheOptions, MultiSelectFieldEagerLoader, MultiSelectFieldGroupLazyLoader, MultiSelectFieldOffsetLazyLoader, MultiSelectFieldPageLazyLoader, MultiSelectFieldPinnedOptions, MultiSelectFieldSearchProps } from '../MultiSelectField/types';
 import { AddNewItemProps } from '../../../internal/types/addNewItemTypes';
+import { ConfirmationProp } from '../../../internal/types/confirmationTypes';
+import { BulkActionConfig } from '../../../internal/types/bulkActionTypes';
+/**
+ * Configuration for the "Select All" / "Select Filtered" rows.
+ */
+export type MultiSelectMenuBulkActionConfig = BulkActionConfig;
+/**
+ * Rich content configuration for a MultiSelectMenu option row.
+ * Controls the avatar, icon, description, and chip display within an option.
+ */
+export type MultiSelectMenuOptionContent = SelectFieldOptionContent;
 export type MultiSelectMenuOption = SelectFieldOption;
 export type MultiSelectMenuGroupByValue = SelectFieldGroupByValue;
 /**
@@ -121,28 +131,58 @@ type MultiSelectMenuCommonProps = {
     /**
      * Configuration for the "Select All" option at the top of the list.
      * Shown when the search input is empty.
+     *
+     * Pass exactly one of `onClick` (fire-and-forget; the consumer commits via
+     * `onSelectedOptionsChange`) or `compute` (returns the next selection;
+     * integrates with confirmation drafts and supports async resolution).
+     *
+     * `compute` is required when you want the action to participate in the
+     * confirmation draft. While a `compute` promise is pending, the menu shows
+     * a loading state, disables all options, and disables Apply.
      */
-    selectAll?: {
-        label?: string;
-        onClick: () => void;
-        checkState: boolean | CheckState;
-    };
+    selectAll?: MultiSelectMenuBulkActionConfig;
     /**
      * Function that receives the current search value and returns configuration for
      * the "Select Filtered" option at the top of the list.
      * Shown when a search term is active (instead of Select All).
+     *
+     * See `selectAll` for the `onClick` / `compute` choice.
      */
-    selectFiltered?: (searchValue: string) => {
-        label?: string;
-        onClick: () => void;
-        checkState: boolean | CheckState;
-    };
+    selectFiltered?: (searchValue: string) => MultiSelectMenuBulkActionConfig;
     /**
      * Width of the popover. Only applies when `displayMenuAs="popover"` (or when the adaptive mode resolves to popover). Has no effect in dialog mode.
      * Accepts a CSS width value or "reference" to match the trigger element's width.
      * @default 320
      */
     popoverWidth?: "reference" | number | string;
+    /**
+     * When set, the menu becomes a buffered selection: clicks update a draft
+     * value inside the open menu, and `onSelectedOptionsChange` only fires when
+     * the user clicks Apply. Dismissing the menu (Escape, click outside,
+     * toggling the trigger) discards the draft. Pass `true` for the default
+     * "Apply" / "Cancel" labels, or an object to customize.
+     *
+     * Note: a `selectAll` / `selectFiltered` row configured with `onClick`
+     * bypasses the draft and applies immediately. Use the `compute` variant
+     * to integrate the bulk action with the draft.
+     * @default undefined (off — selections apply immediately)
+     */
+    confirmation?: ConfirmationProp;
+    /**
+     * Configures a "Clear" button in the menu footer. Presence of this prop
+     * enables the button; omit to suppress.
+     *
+     * - `onClick` — called when the user clicks Clear.
+     * - `label` — button label (default "Clear").
+     * - `disabled` — whether the button is inert. Filter adapters typically
+     *   tie this to `!isActive(filter)` so the button is dim when nothing is
+     *   selected.
+     */
+    clear?: {
+        onClick: () => void;
+        label?: string;
+        disabled?: boolean;
+    };
 } & MultiSelectMenuSearchProps & AddNewItemProps;
 type MultiSelectMenuGroupingProps = {
     /**

package/dist/src/beta/components/SavedFiltersButton/SavedFiltersButton.d.ts

@@ -0,0 +1,40 @@
+import { SavedFiltersButtonProps } from './types';
+/**
+ * `SavedFiltersButton` is an opt-in companion to FilterBar that lets users
+ * apply, save, edit, and delete preset filter selections. It is fully
+ * stateless: the consumer owns the `savedFilters` array and writes its own
+ * persistence (server, localStorage, etc.) by reacting to the callbacks the
+ * component fires.
+ *
+ * Visually it's a single Button trigger that opens a popover listing the
+ * presets, with two footer actions:
+ *
+ * - **Save Current Filter** opens a drawer that snapshots `currentFilters`
+ *   into a new preset.
+ * - **Edit Saved Filters** opens a drawer listing every preset with edit
+ *   affordances; clicking edit on a row drills into a per-preset form
+ *   reusing the FilterBar adapter `renderDrawer` machinery.
+ *
+ * Apply, save, update, and delete are all delivered as consumer callbacks
+ * (`onApplySavedFilter`, `onSaveCurrentFilter`, `onUpdateSavedFilter`,
+ * `onDeleteSavedFilter`). Promise-returning callbacks are supported with
+ * loading state on the relevant submit button and success/error alerts on
+ * the parent drawer.
+ *
+ * @example
+ * <SavedFiltersButton
+ *   savedFilters={presets}
+ *   currentFilters={filters}
+ *   onApplySavedFilter={(preset) => setFilters(preset.filters)}
+ *   onSaveCurrentFilter={async ({ name, filters }) => {
+ *     await api.savePreset({ name, filters });
+ *     refetchPresets();
+ *   }}
+ *   onUpdateSavedFilter={async (id, update) => api.updatePreset(id, update)}
+ *   onDeleteSavedFilter={async (id) => api.deletePreset(id)}
+ * />
+ */
+export declare const SavedFiltersButton: {
+    (props: SavedFiltersButtonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/beta/components/SavedFiltersButton/index.d.ts

@@ -0,0 +1,2 @@
+export { SavedFiltersButton } from './SavedFiltersButton';
+export type { SavedFilter, SavedFiltersAlertText, SavedFiltersButtonProps, } from './types';

package/dist/src/beta/components/SavedFiltersButton/internal/AddSavedFilterDrawer.d.ts

@@ -0,0 +1,27 @@
+import { Filter } from '../../FilterBar/internal/types';
+type AddSavedFilterDrawerProps = {
+    open: boolean;
+    onClose: () => void;
+    /** Snapshot of filters captured when the drawer opened. */
+    filtersSnapshot: Filter[];
+    onSave: (payload: {
+        name: string;
+        filters: Filter[];
+    }) => void | Promise<void>;
+    /**
+     * Consumer-supplied name validator. Returning a string blocks Add and is
+     * surfaced as the field's error message; `undefined` allows submit.
+     */
+    validateName?: (name: string) => string | undefined;
+};
+/**
+ * Drawer rendered when the user clicks "Save Current Filter" in the
+ * SavedFiltersButton popover. Captures a name and emits `onSave` with the
+ * filters snapshot. Supports async `onSave`; while pending the Add button
+ * shows a loading spinner and the form is disabled.
+ *
+ * If `onSave` rejects, the drawer stays open with the current input so the
+ * user can retry or cancel. On success the drawer closes.
+ */
+export declare const AddSavedFilterDrawer: ({ open, onClose, filtersSnapshot, onSave, validateName, }: AddSavedFilterDrawerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/beta/components/SavedFiltersButton/internal/EditSavedFiltersDrawer.d.ts

@@ -0,0 +1,38 @@
+import { SavedFilter, SavedFiltersAlertText } from '../types';
+type EditSavedFiltersDrawerProps = {
+    open: boolean;
+    onClose: () => void;
+    savedFilters: SavedFilter[];
+    /** Drilldown's "Update Filter" action. May return a promise. */
+    onUpdate?: (id: string, update: {
+        name: string;
+        filters: SavedFilter["filters"];
+    }) => void | Promise<void>;
+    /** Drilldown's "Delete Filter" action. May return a promise. */
+    onDelete?: (id: string) => void | Promise<void>;
+    /**
+     * Optional drag-to-reorder callback. When provided, the list view renders
+     * each row as a `DndSort.Card` with a drag handle and emits the new
+     * `orderedIds` after a drop. When omitted, the list renders as a static
+     * stack with no handles.
+     */
+    onReorder?: (orderedIds: string[]) => void | Promise<void>;
+    /**
+     * Optional validator for the name field in the drilldown. The `currentId`
+     * is set to the preset being edited so the consumer can permit the row's
+     * own name in uniqueness checks.
+     */
+    validateName?: (name: string, currentId?: string) => string | undefined;
+    /** Optional override for the auto-managed alert text. */
+    alertText?: SavedFiltersAlertText;
+};
+/**
+ * Drawer that lets the user manage existing saved filters. Composed of two
+ * views — a list of presets (the Drawer host) and a per-preset edit screen
+ * (a `DrillDown` child) that reuses the FilterBar adapter `renderDrawer`
+ * machinery to render edit fields. Navigation between the two is driven by
+ * `useDrillDown`, which also wires the back-button affordance built into
+ * `DrillDown.Header`.
+ */
+export declare const EditSavedFiltersDrawer: ({ open, onClose, savedFilters, onUpdate, onDelete, onReorder, validateName, alertText, }: EditSavedFiltersDrawerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/beta/components/SavedFiltersButton/types.d.ts

@@ -0,0 +1,147 @@
+import { ReactNode } from 'react';
+import { Filter } from '../FilterBar/internal/types';
+/**
+ * A consumer-owned preset of filter values. The component never mutates these
+ * — it only emits callbacks describing the user's intent (apply, save, update,
+ * delete). The consumer holds the source-of-truth list and re-renders
+ * `SavedFiltersButton` with the updated array.
+ *
+ * `filters` is a snapshot of the bar's full filter schema with the preset's
+ * values baked in, in the same shape as `FilterBar`'s `filters` prop. That
+ * uniformity lets the edit drilldown reuse the FilterBar adapter
+ * `renderDrawer` machinery without bespoke per-filter-type rendering.
+ */
+export type SavedFilter = {
+    id: string;
+    name: string;
+    filters: Filter[];
+    /**
+     * When true, this preset cannot be edited from the Edit drawer — its row
+     * renders without an Edit affordance and the drilldown is unreachable.
+     * Useful for marking system / seeded presets as immutable while still
+     * letting users edit their own.
+     */
+    disableEdit?: boolean;
+    /**
+     * When true, the "Delete Filter" button is omitted from the drilldown
+     * footer for this preset. Independent of `disableEdit` — a preset can be
+     * editable but not deletable, or vice versa.
+     */
+    disableDelete?: boolean;
+};
+/**
+ * Text overrides for the auto-managed success / error Alerts that appear on
+ * the "Edit Saved Filters" drawer after a save, update, delete, or reorder
+ * settles.
+ *
+ * All entries are optional; unset values fall back to generic defaults.
+ */
+export type SavedFiltersAlertText = {
+    saveSuccess?: string;
+    saveError?: string;
+    updateSuccess?: string;
+    updateError?: string;
+    deleteSuccess?: string;
+    deleteError?: string;
+    /**
+     * Surfaced on the list view when `onReorderSavedFilters` rejects. No
+     * matching `reorderSuccess` — successful reorders don't show an alert,
+     * because the new order is its own visible confirmation.
+     */
+    reorderError?: string;
+};
+export type SavedFiltersButtonProps = {
+    /** The presets to list. Consumer owns the storage. */
+    savedFilters: SavedFilter[];
+    /**
+     * The filters currently committed in the FilterBar (or any analogous
+     * filter source). Used as the snapshot payload when the user clicks
+     * "Save Current Filter."
+     */
+    currentFilters: Filter[];
+    /**
+     * Called when the user picks a preset from the list. The consumer is
+     * responsible for pushing `saved.filters` into their FilterBar (or
+     * equivalent) state. The popover closes immediately after click.
+     */
+    onApplySavedFilter: (saved: SavedFilter) => void;
+    /**
+     * Called when the user submits the "Save Current Filter" drawer. The
+     * payload `filters` is the snapshot of `currentFilters` at the moment the
+     * drawer opened. May return a promise; while pending, the Add button
+     * shows a loading state. Rejecting surfaces an error alert; resolving
+     * surfaces a success alert and closes the drawer.
+     */
+    onSaveCurrentFilter: (payload: {
+        name: string;
+        filters: Filter[];
+    }) => void | Promise<void>;
+    /**
+     * Called when the user submits the drilldown's "Update Filter" action.
+     * Same async / alert semantics as `onSaveCurrentFilter`.
+     */
+    onUpdateSavedFilter: (id: string, update: {
+        name: string;
+        filters: Filter[];
+    }) => void | Promise<void>;
+    /**
+     * Called when the user clicks "Delete Filter" in the drilldown. Same
+     * async / alert semantics as `onSaveCurrentFilter`.
+     */
+    onDeleteSavedFilter: (id: string) => void | Promise<void>;
+    /**
+     * Optional validation for the name field in the save / edit flows. Return
+     * an error string to block submit (Add / Update is disabled); return
+     * `undefined` when valid. The optional `currentId` is set during an edit
+     * flow so the consumer can permit the row's own name in uniqueness
+     * checks.
+     */
+    validateName?: (name: string, currentId?: string) => string | undefined;
+    /** Optional override for the auto-managed alert text. */
+    alertText?: SavedFiltersAlertText;
+    /**
+     * Optional id of the preset that is currently applied. When set, the
+     * matching row in the popover renders with a check affordance. The
+     * component does no comparison itself — the consumer is responsible for
+     * tracking which preset (if any) reflects the current filter state, and
+     * for clearing the id when the filters drift (e.g. the user edited a
+     * filter directly).
+     *
+     * Defaults to `undefined`, in which case no row is marked active.
+     */
+    activeSavedFilterId?: string;
+    /**
+     * Optional trigger label override.
+     * @default "Saved Filters"
+     */
+    label?: string;
+    /**
+     * Optional override for the popover's empty-state content, shown when
+     * `savedFilters` is empty. Defaults to "No saved filters yet."
+     *
+     * - Pass a `string` to keep the default subdued/small `Text` styling — only
+     *   the wording changes.
+     * - Pass any other `ReactNode` (a CTA, an illustration, a styled block) to
+     *   take full control of the empty-state content.
+     *
+     * Separately, when `savedFilters` is empty the "Edit Saved Filters" footer
+     * button is disabled, so this empty-state is the only thing the user sees
+     * in the popover.
+     */
+    emptyState?: ReactNode;
+    /**
+     * Called when the user drags a preset to a new position in the "Edit Saved
+     * Filters" drawer. The payload is the full list of preset ids in their new
+     * order; the consumer is responsible for re-sorting their `savedFilters`
+     * array to match.
+     *
+     * Providing this callback opts the Edit drawer into drag-to-reorder UI —
+     * each row picks up a drag handle and keyboard-accessible drop affordance.
+     * Omitting it renders the list as a static stack with no handles.
+     *
+     * May return a promise. A rejection surfaces as a danger alert on the
+     * list view using `alertText.reorderError` (or the thrown Error's message
+     * when present).
+     */
+    onReorderSavedFilters?: (orderedIds: string[]) => void | Promise<void>;
+};

package/dist/src/beta/components/SelectField/types.d.ts

@@ -1,6 +1,6 @@
 import { AriaAttributes, CSSProperties, ReactElement, ReactNode } from 'react';
 import { AiMarkWithTooltipOrPopoverProps, LayoutUtilProps, Size } from '../../../types';
-import { AvatarProps, ChipProps, IconProps } from '../../..';
+import { OptionContent } from '../../../internal/types/optionContent';
 import { AddNewItemProps } from '../../../internal/types/addNewItemTypes';
 /**
  * Configuration options for the SelectField cache.
@@ -21,6 +21,11 @@ export type SelectFieldHandle = {
     invalidate: () => void;
 };
 export type SelectFieldGroupByValue = string | number;
+/**
+ * Rich content configuration for a SelectField option row.
+ * Controls the avatar, icon, description, and chip display within an option.
+ */
+export type SelectFieldOptionContent = OptionContent;
 export type SelectFieldOption = {
     id: string | number;
     label: string;
@@ -28,16 +33,7 @@ export type SelectFieldOption = {
     group?: SelectFieldGroupByValue;
     disabled?: boolean;
     extra?: Record<string, unknown>;
-    content?: {
-        title?: string;
-        description?: string;
-        chips?: Pick<ChipProps, "label" | "color" | "textWrap">[];
-        avatar?: Pick<AvatarProps, "name" | "status" | "color" | "image">;
-        icon?: Pick<IconProps, "svg" | "color"> & {
-            /** Accessible label for the icon. When omitted, the icon is treated as decorative. */
-            label?: string;
-        };
-    };
+    content?: SelectFieldOptionContent;
 };
 export type SelectFieldGroupedOption = SelectFieldOption & {
     group: SelectFieldGroupByValue;

package/dist/src/beta/components/SelectMenu/internal/useMenuInteraction.d.ts

@@ -12,6 +12,13 @@ export type UseMenuInteractionConfig = {
     id: string;
     triggerRef: RefObject<HTMLButtonElement>;
     label: string;
+    /**
+     * Controlled open state. The consumer owns `[isOpen, setIsOpen]` so other
+     * hooks in the same render (e.g. `useConfirmationDraft`) can read the same
+     * value without a one-render lag.
+     */
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
     onImplicitClose?: () => void;
     onExplicitClose?: () => void;
 };
@@ -56,7 +63,7 @@ type ItemReturnProps = {
 };
 export type GetMenuPropsFn = (opts?: MenuPropsArg) => MenuReturnProps;
 export type GetItemPropsFn = (opts: ItemPropsArg) => ItemReturnProps;
-export declare const useMenuInteraction: ({ items, sectionsMeta: _sectionsMeta, onItemActivate, selectedItemIds, displayAs: _displayAs, closeOnActivate, disabled, id, triggerRef, label, onImplicitClose, onExplicitClose, }: UseMenuInteractionConfig) => {
+export declare const useMenuInteraction: ({ items, sectionsMeta: _sectionsMeta, onItemActivate, selectedItemIds, displayAs: _displayAs, closeOnActivate, disabled, id, triggerRef, label, isOpen, setIsOpen, onImplicitClose, onExplicitClose, }: UseMenuInteractionConfig) => {
     isOpen: boolean;
     openMenu: () => void;
     closeMenu: (options?: {

package/dist/src/beta/components/SelectMenu/types.d.ts

@@ -1,6 +1,11 @@
 import { KeyboardEvent, ReactElement, RefObject } from 'react';
-import { SelectFieldCacheOptions, SelectFieldEagerLoader, SelectFieldGroupByValue, SelectFieldGroupLazyLoader, SelectFieldGroupedOption, SelectFieldOffsetLazyLoader, SelectFieldOption, SelectFieldPageLazyLoader, SelectFieldPinnedOptions, SelectFieldSearchProps } from '../SelectField/types';
+import { SelectFieldCacheOptions, SelectFieldEagerLoader, SelectFieldGroupByValue, SelectFieldGroupLazyLoader, SelectFieldGroupedOption, SelectFieldOffsetLazyLoader, SelectFieldOption, SelectFieldOptionContent, SelectFieldPageLazyLoader, SelectFieldPinnedOptions, SelectFieldSearchProps } from '../SelectField/types';
 import { AddNewItemProps } from '../../../internal/types/addNewItemTypes';
+/**
+ * Rich content configuration for a SelectMenu option row.
+ * Controls the avatar, icon, description, and chip display within an option.
+ */
+export type SelectMenuOptionContent = SelectFieldOptionContent;
 export type SelectMenuOption = SelectFieldOption;
 export type SelectMenuGroupByValue = SelectFieldGroupByValue;
 export type SelectMenuGroupedOption = SelectFieldGroupedOption;
@@ -125,6 +130,21 @@ type SelectMenuCommonProps = {
      * @default 320
      */
     popoverWidth?: "reference" | number | string;
+    /**
+     * Configures a "Clear" button in the menu footer. Presence of this prop
+     * enables the button; omit to suppress.
+     *
+     * - `onClick` — called when the user clicks Clear.
+     * - `label` — button label (default "Clear").
+     * - `disabled` — whether the button is inert. Filter adapters typically
+     *   tie this to `!isActive(filter)` so the button is dim when nothing is
+     *   selected.
+     */
+    clear?: {
+        onClick: () => void;
+        label?: string;
+        disabled?: boolean;
+    };
 } & SelectMenuSearchProps & AddNewItemProps;
 type SelectMenuGroupingProps = {
     /**

package/dist/src/beta/components/Table/DataTable/internal/DataTablePagination.d.ts

@@ -1,3 +1,9 @@
 import { PaginationProps } from '../../../../..';
+type DataTableCursorPaginationProps = Pick<PaginationProps, "page" | "itemsPerPage" | "onPageChange" | "onItemsPerPageChange" | "itemsPerPageOptions"> & {
+    hasNextPage?: boolean;
+    hasPrevPage?: boolean;
+};
 export type DataTablePaginationProps = Pick<PaginationProps, "page" | "itemsPerPage" | "totalItemCount" | "showCount" | "onPageChange" | "onItemsPerPageChange" | "itemsPerPageOptions">;
 export declare const DataTablePagination: ({ showCount, ...props }: DataTablePaginationProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DataTableCursorPagination: ({ page, itemsPerPage, itemsPerPageOptions, hasNextPage, hasPrevPage, onPageChange, onItemsPerPageChange, }: DataTableCursorPaginationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/beta/components/Table/DataTable/types.d.ts

@@ -53,9 +53,12 @@ export type DataTableCacheOptions = {
     maxSize?: number;
 };
 /**
- * Configuration for pagination in DataTable
+ * Pagination behavior for DataTable.
+ * "offset" uses numbered pages with a known total row count.
+ * "cursor" uses previous/next availability for unknown-total pagination.
  */
-export type DataTablePaginationConfig<T> = {
+export type DataTablePaginationMode = "offset" | "cursor";
+type DataTablePaginationBaseConfig<T> = {
     /**
      * Number of rows displayed per page
      * @default 25
@@ -96,28 +99,57 @@ export type DataTablePaginationConfig<T> = {
      * Callback when page changes. Receives the new page index (0-based)
      */
     onPageChange?: (pageIndex: number) => void;
+    /**
+     * Key that triggers data refetch when changed.
+     * Useful for forcing refetch when external filters change.
+     * When changed, the page index automatically resets to 0.
+     */
+    refreshKey?: string | number;
+    /**
+     * Configuration for caching loadPageData results.
+     * Caching is enabled by default. Set `{ enabled: false }` to disable.
+     */
+    cache?: DataTableCacheOptions;
+};
+export type DataTableOffsetPaginationConfig<T> = DataTablePaginationBaseConfig<T> & {
+    /**
+     * Offset pagination mode.
+     * @default "offset"
+     */
+    mode?: "offset";
     /**
      * Whether to display the item count information in pagination
      * @default true
      */
     showCount?: boolean;
     /**
-     * Total number of rows across all pages. Falls back to data.length if not provided.
+     * Total number of rows across all pages in offset mode. Falls back to data.length if not provided.
      * Useful for server-side pagination scenarios where totalRowCount may differ from data array length.
      */
     totalRowCount?: number;
+    hasNextPage?: never;
+    hasPrevPage?: never;
+};
+export type DataTableCursorPaginationConfig<T> = DataTablePaginationBaseConfig<T> & {
     /**
-     * Key that triggers data refetch when changed.
-     * Useful for forcing refetch when external filters change.
-     * When changed, the page index automatically resets to 0.
+     * Cursor pagination mode for datasets where the total row count is unknown.
      */
-    refreshKey?: string | number;
+    mode: "cursor";
     /**
-     * Configuration for caching loadPageData results.
-     * Caching is enabled by default. Set `{ enabled: false }` to disable.
+     * Whether another page is available.
      */
-    cache?: DataTableCacheOptions;
+    hasNextPage: boolean;
+    /**
+     * Whether a previous page is available.
+     */
+    hasPrevPage: boolean;
+    showCount?: never;
+    totalRowCount?: never;
 };
+/**
+ * Configuration for pagination in DataTable
+ */
+export type DataTablePaginationConfig<T> = DataTableOffsetPaginationConfig<T> | DataTableCursorPaginationConfig<T>;
 /**
  * Ref handle for DataTable component
  * @property {function} refresh - Triggers a data refetch and resets the page index to 0. Useful for manually refreshing data after external changes (e.g., after a mutation).
@@ -135,3 +167,4 @@ export type DataTableRef = {
      */
     clearCache: () => void;
 };
+export {};

package/dist/src/beta/components/Toolbar/internal/ToolbarContext.d.ts

@@ -25,9 +25,10 @@ export type ToolbarContextProps = {
      */
     orderedIds?: string[];
     /**
-     * Overflow behavior type (wrap or collapse)
+     * Overflow behavior type. Defaults to wrap behavior when omitted.
+     * @default "wrap"
      */
-    overflow: ToolbarOverflowTypes;
+    overflow?: ToolbarOverflowTypes;
     /**
      * Size of toolbar child components
      */