@servicetitan/anvil2 3.0.6 → 3.0.8

package/dist/src/beta/components/FilterBar/internal/types.d.ts

@@ -1,6 +1,10 @@
 import { ReactNode } from 'react';
 import { DateFieldSingleProps } from '../../../../components/DateFieldSingle';
 import { DateFieldRangeProps } from '../../../../components/DateFieldRange';
+import { SelectMenuOption, SelectMenuProps, SelectMenuSyncProps } from '../../SelectMenu';
+import { MultiSelectMenuOption, MultiSelectMenuProps, MultiSelectMenuSyncProps } from '../../MultiSelectMenu';
+import { TreeSelectMenuProps, TreeSelectMenuSyncProps, TreeSelectMenuValue } from '../../TreeSelectMenu';
+import { DistributiveOmit } from '../../../../types';
 /**
  * Base properties shared by all filter types
  */
@@ -9,6 +13,8 @@ export type BaseFilter = {
     id: string;
     /** Display label for the filter */
     label: string;
+    /** When true, the filter is only reachable via the drawer and never rendered inline in the toolbar */
+    drawerOnly?: boolean;
 };
 /**
  * Built-in boolean filter type
@@ -29,14 +35,9 @@ export type FilterRenderProps<T = unknown> = {
     /** Callback to update the filter value */
     onChange: (value?: T) => void;
 };
-/**
- * Custom filter type allowing for complex filter implementations
- */
-export type CustomFilter<T = unknown> = BaseFilter & {
+type CustomFilterShared<T> = BaseFilter & {
     /** Identifies this as a custom filter */
     type: "custom";
-    /** Function to render the filter content in the button/popover */
-    buttonRender: (props: FilterRenderProps<T>) => ReactNode;
     /** Function to render the filter content in the drawer */
     drawerRender: (props: FilterRenderProps<T>) => ReactNode;
     /** Current value of the custom filter */
@@ -45,68 +46,62 @@ export type CustomFilter<T = unknown> = BaseFilter & {
     labelChipCount?: number;
 };
 /**
- * Single select filter type using Listbox component with optional search
+ * Custom filter type allowing for complex filter implementations.
+ *
+ * `buttonRender` is required for filters that can appear inline in the
+ * toolbar, and forbidden when `drawerOnly: true` since the filter never
+ * renders inline.
  */
-export type SingleSelectFilter<Item = {
-    id: string;
-    label: string;
-}> = BaseFilter & {
+export type CustomFilter<T = unknown> = (CustomFilterShared<T> & {
+    drawerOnly: true;
+    buttonRender?: never;
+}) | (CustomFilterShared<T> & {
+    drawerOnly?: false;
+    /** Function to render the filter content in the button/popover */
+    buttonRender: (props: FilterRenderProps<T>) => ReactNode;
+});
+/**
+ * Single select filter type backed by SelectMenuSync (toolbar) and
+ * SelectFieldSync (drawer). The consumer supplies a fixed `options` array;
+ * client-side filtering happens automatically via match-sorter (override with
+ * a custom `filter` function or MatchSorterOptions config).
+ *
+ * Uses DistributiveOmit so variant-specific fields survive — see AsyncSelectFilter.
+ *
+ * Filter-runtime concerns (`label`, `id`, `selectedOption`, `trigger`,
+ * `value`/`onSelectedOptionChange`, focus-lifecycle callbacks) are owned by
+ * FilterBar and the singleSelect adapter — consumers don't pass them.
+ */
+export type SingleSelectFilter = BaseFilter & {
     /** Identifies this as a single select filter */
     type: "singleSelect";
-    /** Array of items to select from */
-    items: Item[];
-    /** Currently selected item */
-    selectedItem?: Item;
-} & ({
-    /** Whether to show the search field */
-    hasSearch: true;
-    /** Required callback for search functionality when hasSearch is true */
-    onSearch: (searchTerm: string) => void;
-    /** Optional callback when search is cleared (only used when hasSearch is true) */
-    onSearchClear: () => void;
-    simpleDrawerVariant?: never;
-} | {
-    /** Whether to show the search field */
-    hasSearch?: false;
-    onSearch?: never;
-    onSearchClear?: never;
-    /** Whether to use simplified drawer rendering */
+    /** Currently selected option */
+    selectedOption?: SelectMenuOption;
+    /**
+     * When true, the drawer cell renders a Radio.Group over the full option set
+     * instead of the default SelectFieldSync combobox. The toolbar still uses
+     * SelectMenuSync regardless.
+     */
     simpleDrawerVariant?: boolean;
-});
+} & DistributiveOmit<SelectMenuSyncProps, "id" | "label" | "value" | "onSelectedOptionChange" | "trigger" | "onMenuKeyDown" | "onImplicitClose" | "onExplicitClose" | "clear">;
 /**
- * Multi select filter type using ListView component with optional search
+ * Multi select filter type backed by MultiSelectMenuSync (toolbar) and
+ * MultiSelectFieldSync (drawer). Same option/filter model as SingleSelectFilter.
+ * Inherits MultiSelectMenuSync's simplified `selectAll` / `selectFiltered`
+ * (boolean | { label }) — click handling and check state are managed automatically.
  */
-export type MultiSelectFilter<Item = {
-    id: string;
-    label: string;
-}> = BaseFilter & {
+export type MultiSelectFilter = BaseFilter & {
     /** Identifies this as a multi select filter */
     type: "multiSelect";
-    /** Array of items to select from */
-    items: Item[];
-    /** Currently selected items array */
-    selectedItems: Item[] | [];
-    /** Whether to use simplified drawer rendering */
-    simpleDrawerVariant?: boolean;
-} & ({
-    /** Whether to show the search field */
-    hasSearch: true;
-    /** Current search value */
-    searchValue?: string;
-    /** Required callback for search functionality when hasSearch is true */
-    onSearch: (searchTerm: string) => void;
-    /** Optional callback when search is cleared (only used when hasSearch is true) */
-    onSearchClear: () => void;
-    simpleDrawerVariant?: never;
-} | {
-    /** Whether to show the search field */
-    hasSearch?: false;
-    searchValue?: never;
-    onSearch?: never;
-    onSearchClear?: never;
-    /** Whether to use simplified drawer rendering */
+    /** Currently selected options */
+    selectedOptions?: MultiSelectMenuOption[];
+    /**
+     * When true, the drawer cell renders a Checkbox.Group over the full option
+     * set instead of the default MultiSelectFieldSync combobox. The toolbar
+     * still uses MultiSelectMenuSync regardless.
+     */
     simpleDrawerVariant?: boolean;
-});
+} & DistributiveOmit<MultiSelectMenuSyncProps, "id" | "label" | "value" | "onSelectedOptionsChange" | "trigger" | "onMenuKeyDown" | "onImplicitClose" | "onExplicitClose" | "clear">;
 /**
  * Single date filter type using DateFieldSingle component
  * Used for selecting a single date with calendar support
@@ -159,10 +154,177 @@ export type DateListFilter = BaseFilter & Pick<DateFieldSingleProps, "mode"> & {
     /** The currently selected option (consumer or library) */
     selectedOption?: DateListOption;
 };
+/**
+ * Async select filter type. Backed by SelectMenu in the toolbar and SelectField
+ * in the drawer, so the consumer supplies a `loadOptions` function instead of a
+ * static `items` array. Carries the full SelectMenu loader union (eager + lazy
+ * page/offset/group) plus pass-through configuration (pinned, cache, virtualize,
+ * search, displayMenuAs, etc.).
+ *
+ * Uses DistributiveOmit so variant-specific fields like `lazyOptions` and
+ * `groupToString` survive the omit — plain `Omit<SelectMenuProps, …>` would
+ * silently drop them, since it reduces unions to their common keys.
+ *
+ * Filter-runtime concerns (`label`, `id`, `selectedOption`, `trigger`,
+ * `value`/`onSelectedOptionChange`, focus-lifecycle callbacks) are owned by
+ * FilterBar and the asyncSelect adapter — consumers don't pass them.
+ */
+export type AsyncSelectFilter = BaseFilter & {
+    /** Identifies this as an async select filter */
+    type: "asyncSelect";
+    /** The currently selected option */
+    selectedOption?: SelectMenuOption;
+} & DistributiveOmit<SelectMenuProps, "id" | "label" | "value" | "onSelectedOptionChange" | "trigger" | "onMenuKeyDown" | "onImplicitClose" | "onExplicitClose" | "clear">;
+/**
+ * Async multi-select filter type. The multi-selection counterpart of
+ * AsyncSelectFilter — backed by MultiSelectMenu in the toolbar and
+ * MultiSelectField in the drawer, so the consumer supplies a `loadOptions`
+ * function instead of a static `items` array. Carries the full
+ * MultiSelectMenu loader union and pass-through configuration, including the
+ * `selectAll` and `selectFiltered` checkbox affordances.
+ *
+ * Filter-runtime concerns (`label`, `id`, `selectedOptions`, `trigger`,
+ * `value`/`onSelectedOptionsChange`, focus-lifecycle callbacks) are owned by
+ * FilterBar and the asyncMultiSelect adapter — consumers don't pass them.
+ */
+export type AsyncMultiSelectFilter = BaseFilter & {
+    /** Identifies this as an async multi-select filter */
+    type: "asyncMultiSelect";
+    /** The currently selected options */
+    selectedOptions?: MultiSelectMenuOption[];
+} & DistributiveOmit<MultiSelectMenuProps, "id" | "label" | "value" | "onSelectedOptionsChange" | "trigger" | "onMenuKeyDown" | "onImplicitClose" | "onExplicitClose" | "clear">;
+/**
+ * Value shape for a numeric range filter. Both bounds are optional —
+ * consumers may set only `min`, only `max`, or both. `null` represents
+ * "no filter applied" (treated as inactive).
+ */
+export type NumericRangeValue = {
+    min?: number;
+    max?: number;
+} | null;
+/**
+ * Numeric min/max range filter. Renders two NumberField inputs (compact
+ * stacked layout in the toolbar popover, side-by-side grid in the drawer).
+ *
+ * - `mode` toggles currency ($ prefix, 2dp) or percentage (% suffix, up to 3dp)
+ *   decorators on both inputs and on the formatted label.
+ * - `minValue` / `maxValue` clamp entered bounds to a valid range.
+ * - `inclusiveBounds` switches the field labels between Min/Max (inclusive)
+ *   and Above/Below (exclusive), and the label symbols between `≥`/`≤` and
+ *   `>`/`<`.
+ */
+export type NumericRangeFilter = BaseFilter & {
+    /** Identifies this as a numeric range filter */
+    type: "numericRange";
+    /** Current min/max value (or null when inactive) */
+    value?: NumericRangeValue;
+    /** Optional decorator mode applied to both inputs and the formatted label */
+    mode?: "currency" | "percentage";
+    /** Clamps entered values from below */
+    minValue?: number;
+    /** Clamps entered values from above */
+    maxValue?: number;
+    /** When true, label uses ≥/≤ and Min/Max; otherwise >/< and Above/Below */
+    inclusiveBounds?: boolean;
+    /** Increment for arrow-key / scroll adjustments on the NumberFields. */
+    step?: number;
+    /**
+     * Override the minimum fraction digits applied to both inputs and the
+     * formatted label. Defaults derived from `mode`: `2` for currency, `0`
+     * for percentage, unset for plain.
+     */
+    minimumFractionDigits?: number;
+    /**
+     * Override the maximum fraction digits applied to both inputs and the
+     * formatted label. Defaults derived from `mode`: `2` for currency, `3`
+     * for percentage, unset for plain.
+     */
+    maximumFractionDigits?: number;
+    /**
+     * Hide the increment/decrement controls on the NumberFields.
+     * @default true
+     */
+    hideControls?: boolean;
+};
+type TextInputFilterShared = BaseFilter & {
+    /** Identifies this as a text input filter */
+    type: "textInput";
+    /** Current text value (undefined or empty means inactive) */
+    value?: string;
+    /** Placeholder shown when the field is empty */
+    placeholder?: string;
+};
+/**
+ * Single text input filter. Renders a TextField — the field's own label is
+ * hidden inline in the toolbar (the filter button doubles as the label) and
+ * shown in the drawer cell.
+ *
+ * `placeholder` is shown when the field is empty; `maxLength` clamps entered
+ * text to that many characters. Set `showCounter: true` to render a
+ * `current/max` character counter under the input — `maxLength` is required
+ * (and must be a concrete `number`, not `undefined`) in that case, otherwise
+ * the counter renders with an empty denominator.
+ */
+export type TextInputFilter = (TextInputFilterShared & {
+    /** Show a `current/max` character counter under the input. */
+    showCounter: true;
+    /** Max character length; required when `showCounter` is true. */
+    maxLength: number;
+}) | (TextInputFilterShared & {
+    /** Show a `current/max` character counter under the input. */
+    showCounter?: false;
+    /** Optional max character length; entered text is truncated to this length. */
+    maxLength?: number;
+});
+/**
+ * Sync tree filter type. Backed by TreeSelectMenuSync in the toolbar and
+ * TreeSelectFieldSync in the drawer, so the consumer supplies a static
+ * `options` tree (with optional client-side `filter` override) instead of a
+ * `loadOptions` function. Selection is always an array of node values, even in
+ * `selectionMode: "single"`.
+ *
+ * Uses DistributiveOmit so variant-specific fields survive the omit, matching
+ * the select-family filters.
+ *
+ * Filter-runtime concerns (`label`, `id`, `selectedNodes`, `trigger`,
+ * `value`/`onSelectedOptionsChange`, focus-lifecycle callbacks) are owned by
+ * FilterBar and the tree adapter — consumers don't pass them. Like the
+ * select-family filters, the inline menu honors `controlledFiltering`: when it
+ * is on, selections are buffered as a draft and commit only on Apply; when off,
+ * they commit immediately.
+ */
+export type TreeFilter = BaseFilter & {
+    /** Identifies this as a tree filter */
+    type: "tree";
+    /** Currently selected tree node values */
+    selectedNodes?: TreeSelectMenuValue[];
+} & DistributiveOmit<TreeSelectMenuSyncProps, "id" | "label" | "value" | "onSelectedOptionsChange" | "trigger" | "onMenuKeyDown" | "onImplicitClose" | "onExplicitClose">;
+/**
+ * Async tree filter type. The async counterpart of TreeFilter — backed by
+ * TreeSelectMenu in the toolbar and TreeSelectField in the drawer, so the
+ * consumer supplies a `loadOptions` function (with `parentNode` for lazy branch
+ * loading) instead of a static `options` tree. Carries the full TreeSelectMenu
+ * pass-through configuration (cache, virtualize, displayMenuAs, initialLoad,
+ * selectionMode, valueConsistsOf, etc.).
+ *
+ * Filter-runtime concerns (`label`, `id`, `selectedNodes`, `trigger`,
+ * `value`/`onSelectedOptionsChange`, focus-lifecycle callbacks) are owned by
+ * FilterBar and the asyncTree adapter — consumers don't pass them. Like
+ * TreeFilter, the inline menu honors `controlledFiltering`: when it is on,
+ * selections are buffered as a draft and commit only on Apply; when off, they
+ * commit immediately.
+ */
+export type AsyncTreeFilter = BaseFilter & {
+    /** Identifies this as an async tree filter */
+    type: "asyncTree";
+    /** Currently selected tree node values */
+    selectedNodes?: TreeSelectMenuValue[];
+} & DistributiveOmit<TreeSelectMenuProps, "id" | "label" | "value" | "onSelectedOptionsChange" | "trigger" | "onMenuKeyDown" | "onImplicitClose" | "onExplicitClose">;
 /**
  * Union type of all available filter types
  * Uses unknown instead of any for better type safety
  */
-export type Filter = BooleanFilter | CustomFilter<any> | SingleSelectFilter<any> | MultiSelectFilter<any> | DateFilter | DateRangeFilter | DateListFilter;
+export type Filter = BooleanFilter | CustomFilter<any> | SingleSelectFilter | MultiSelectFilter | DateFilter | DateRangeFilter | DateListFilter | AsyncSelectFilter | AsyncMultiSelectFilter | TreeFilter | AsyncTreeFilter | NumericRangeFilter | TextInputFilter;
 /** Type representing all possible filter values */
-export type FilterValue = boolean | CustomFilter["value"] | SingleSelectFilter["selectedItem"] | MultiSelectFilter["selectedItems"] | DateFilter["value"] | DateRangeFilter["value"] | DateListFilter["selectedOption"];
+export type FilterValue = boolean | CustomFilter["value"] | SingleSelectFilter["selectedOption"] | MultiSelectFilter["selectedOptions"] | DateFilter["value"] | DateRangeFilter["value"] | DateListFilter["selectedOption"] | AsyncSelectFilter["selectedOption"] | AsyncMultiSelectFilter["selectedOptions"] | TreeFilter["selectedNodes"] | AsyncTreeFilter["selectedNodes"] | NumericRangeFilter["value"] | TextInputFilter["value"];
+export {};

package/dist/src/beta/components/FilterBar/internal/utils/dateListLibraryOptions.d.ts

@@ -18,8 +18,8 @@ export declare const dateListLibraryOptions: ReadonlyArray<{
 export declare const isDateListRangeLibraryId: (id: DateListLibraryOptionId) => boolean;
 /**
  * Build the display label for a committed dateList selection. Used by both
- * the FilterButton trigger and the FilterDrawer SelectField so the two
- * surfaces stay in sync.
+ * the toolbar `FilterTriggerButton` and the FilterDrawer `SelectField` so the
+ * two surfaces stay in sync.
  *
  * - Selection with `value: null` (e.g. "Any day") → option label only.
  * - Custom Range library option → just the formatted range (label omitted

package/dist/src/beta/components/FilterBar/internal/utils/filter-state.d.ts

@@ -1,71 +1,33 @@
 import { Filter, FilterValue } from '../types';
+export { hasChangedFilter } from './value-compare';
 /**
  * Returns an array of filters that are currently active (i.e., have a value set).
- *
- * @param {Filter[]} filters - Array of filter objects to check
- * @returns {Filter[]} Array of active filters
  */
 export declare const getActiveFilters: (filters: Filter[]) => Filter[];
 /**
  * Checks if any filters in the array have active values
- *
- * @param {Filter[]} filters - Array of filter objects to check
- * @returns {boolean} True if any filter has an active value
  */
 export declare const checkActiveFilters: (filters: Filter[]) => boolean;
 /**
  * Resets all filters to their default state
- *
- * @param {Filter[]} filters - Array of filter objects to reset
- * @returns {Filter[]} New array with reset filters
  */
 export declare const resetFilters: (filters: Filter[]) => Filter[];
 /**
  * Updates a single filter in an array of filters
- *
- * @param {Filter[]} filters - Array of filter objects
- * @param {string} filterId - ID of the filter to update
- * @param {FilterValue} value - New value for the filter
- * @returns {Filter[]} New array with updated filter
  */
 export declare const updateSingleFilter: (filters: Filter[], filterId: string, value: FilterValue) => Filter[];
-/**
- * Determines if two filter values are different.
- * For arrays (multiSelect), compares by id set (order-insensitive, avoids JSON serialization).
- * For singleSelect, compares by id if both are objects with id.
- * For dateList selections (objects with both id and value), compares id AND value
- * so re-picking the same library option with a different date still counts as a change.
- *
- * @param {T} a - First value to compare
- * @param {T} b - Second value to compare
- * @returns {boolean} True if the values are different
- */
-export declare const hasChangedFilter: <T>(a: T, b: T) => boolean;
 /**
  * Checks if the selection value of a filter has changed by comparing references.
  * Uses reference equality (===) to detect if the parent has provided a new value.
- *
- * @param {Filter} existingFilter - The current filter state
- * @param {Filter} newFilter - The incoming filter from props
- * @returns {boolean} True if the selection value reference has changed
  */
 export declare const hasFilterSelectionChanged: (existingFilter: Filter, newFilter: Filter) => boolean;
 /**
  * Preserves the selection state from an existing filter into a new filter.
- * Used when filter configuration updates but the selection value reference hasn't changed,
- * allowing us to maintain user selections through configuration updates.
- *
- * @param {Filter} newFilter - The new filter configuration from props
- * @param {Filter} existingFilter - The existing filter with user's selections
- * @returns {Filter} New filter with configuration from newFilter and selection from existingFilter
+ * Used when filter configuration updates but the selection value reference hasn't changed.
  */
 export declare const preserveFilterState: (newFilter: Filter, existingFilter: Filter) => Filter;
 /**
  * Creates a deep clone of filters with updated item references.
  * Ensures that selected items reference the current items array for proper equality checks.
- * Used when initializing draft state to ensure selections use current item references.
- *
- * @param {Filter[]} filters - Array of filter objects to clone
- * @returns {Filter[]} New array with cloned filters and updated item references
  */
 export declare const cloneFiltersWithItemRefs: (filters: Filter[]) => Filter[];

package/dist/src/beta/components/FilterBar/internal/utils/test.d.ts

@@ -1,4 +1,4 @@
-import { Filter, BooleanFilter, CustomFilter, SingleSelectFilter, MultiSelectFilter, DateFilter, DateListFilter, DateRangeFilter } from '../types';
+import { AsyncMultiSelectFilter, AsyncSelectFilter, Filter, BooleanFilter, CustomFilter, SingleSelectFilter, MultiSelectFilter, DateFilter, DateListFilter, DateRangeFilter, NumericRangeFilter, TextInputFilter, TreeFilter, AsyncTreeFilter } from '../types';
 export type TestValue = {
     id: number;
     label: string;
@@ -11,24 +11,12 @@ export declare const mockFilterOptions: {
 }[];
 export declare const defaultMockBooleanFilter: BooleanFilter;
 export declare const defaultMockCustomFilter: CustomFilter<TestValue>;
-export declare const defaultMockSingleSelectFilter: SingleSelectFilter<{
-    id: string;
-    label: string;
-}>;
-export declare const defaultMockMultiSelectFilter: MultiSelectFilter<{
-    id: string;
-    label: string;
-}>;
+export declare const defaultMockSingleSelectFilter: SingleSelectFilter;
+export declare const defaultMockMultiSelectFilter: MultiSelectFilter;
 export declare const defaultMockDateFilter: DateFilter;
 export declare const defaultMockDateRangeFilter: DateRangeFilter;
-export declare const defaultMockFilters: (BooleanFilter | DateFilter | DateRangeFilter | CustomFilter<TestValue> | SingleSelectFilter<{
-    id: string;
-    label: string;
-}> | MultiSelectFilter<{
-    id: string;
-    label: string;
-}>)[];
-export declare function createMockFilter<T = unknown>(overrides?: Partial<Filter | CustomFilter<T> | SingleSelectFilter<T>>): Filter | CustomFilter<T> | SingleSelectFilter<T>;
+export declare const defaultMockFilters: (BooleanFilter | SingleSelectFilter | MultiSelectFilter | DateFilter | DateRangeFilter | CustomFilter<TestValue>)[];
+export declare function createMockFilter<T = unknown>(overrides?: Partial<Filter | CustomFilter<T> | SingleSelectFilter>): Filter | CustomFilter<T> | SingleSelectFilter;
 export declare function createMockFilterContext(filters?: Filter[], contextOverrides?: {}): {
     filterGroupRef: {
         current: HTMLDivElement;
@@ -36,24 +24,24 @@ export declare function createMockFilterContext(filters?: Filter[], contextOverr
     filters: Filter[];
     updateFilter: import('vitest').Mock<(...args: any[]) => any>;
     onFilterChange: import('vitest').Mock<(...args: any[]) => any>;
-    hiddenFilters: never[];
-    addHiddenFilter: import('vitest').Mock<(...args: any[]) => any>;
-    removeHiddenFilter: import('vitest').Mock<(...args: any[]) => any>;
+    drawerOnlyFilters: never[];
     controlledFiltering: boolean;
     associatedContent: string;
+    showInlineFilters: boolean;
 };
 export declare function createMockBooleanFilter(overrides?: Partial<BooleanFilter>): BooleanFilter;
 export declare function createMockCustomFilter<T = unknown>(overrides?: Partial<CustomFilter<T>>): CustomFilter<T>;
-export declare function createMockSingleSelectFilter<T = {
-    id: string;
-    label: string;
-}>(overrides?: Partial<SingleSelectFilter<T>>): SingleSelectFilter<T>;
-export declare function createMockMultiSelectFilter<T = {
-    id: string;
-    label: string;
-}>(overrides?: Partial<MultiSelectFilter<T>>): MultiSelectFilter<T>;
+export declare function createMockSingleSelectFilter(overrides?: Partial<SingleSelectFilter>): SingleSelectFilter;
+export declare function createMockMultiSelectFilter(overrides?: Partial<MultiSelectFilter>): MultiSelectFilter;
 export declare function createMockDateFilter(overrides?: Partial<DateFilter>): DateFilter;
 export declare function createMockDateRangeFilter(overrides?: Partial<DateRangeFilter>): DateRangeFilter;
 export declare function createMockDateListFilter(overrides?: Partial<DateListFilter>): DateListFilter;
+export declare function createMockAsyncSelectFilter(overrides?: Partial<AsyncSelectFilter>): AsyncSelectFilter;
+export declare function createMockAsyncMultiSelectFilter(overrides?: Partial<AsyncMultiSelectFilter>): AsyncMultiSelectFilter;
+export declare function createMockTreeFilter(overrides?: Partial<TreeFilter>): TreeFilter;
+export declare function createMockAsyncTreeFilter(overrides?: Partial<AsyncTreeFilter>): AsyncTreeFilter;
+export declare function createMockNumericRangeFilter(overrides?: Partial<NumericRangeFilter>): NumericRangeFilter;
+export declare function createMockTextInputFilter(overrides?: Partial<TextInputFilter>): TextInputFilter;
 export declare const setupDesktopContainer: () => void;
 export declare const setupMobileContainer: () => void;
+export declare const setupSmContainer: () => void;

package/dist/src/beta/components/FilterBar/internal/utils/value-compare.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Determines if two filter values are different.
+ * For arrays (multiSelect), compares by id set (order-insensitive, avoids JSON serialization).
+ * For singleSelect, compares by id if both are objects with id.
+ * For dateList selections (objects with both id and value), compares id AND value
+ * so re-picking the same library option with a different date still counts as a change.
+ *
+ * Intentionally adapter-free — kept here (rather than in filter-state.ts) so that
+ * FilterPopoverButton can import it without pulling the adapter registry into
+ * the import graph. filter-state.ts depends on the adapter registry; the registry
+ * depends on FilterPopoverButton; FilterPopoverButton would otherwise depend on
+ * filter-state — closing a runtime-evaluated cycle.
+ */
+export declare const hasChangedFilter: <T>(a: T, b: T) => boolean;

package/dist/src/beta/components/MultiSelectField/internal/MultiSelectFieldComboboxMode.d.ts

@@ -2,4 +2,4 @@ import { MultiSelectFieldComboboxInternalProps } from './types';
 /**
  * Combobox mode: searchable multi-select using useCombobox.
  */
-export declare const MultiSelectFieldComboboxMode: ({ labelAiMark, id, helperUid, selectedOptions, onSelectedOptionsChange, displayAs, isDisabledOrReadOnly, disabled, readOnly, required, placeholder, size, error, hasHelperText, disableClearButton, prefix, suffix, label, hideLabel, hint, moreInfo, moreInfoId, errorMessages, warning, description, className, style, layoutStyles, pinned, groupToString, groupSorter, virtualize, options, loading, loadingMore, hasMore, loadOptions, loadMore, initialLoad, initialLoadPerformed, setInitialLoadPerformed, inputWrapperRef, debounceMs, selectAll, selectFiltered, singleRow, maxChips, getChipProps, onSearchChange, addItemLabel, onAddNewItem, handleRemoveOption, handleClear, }: MultiSelectFieldComboboxInternalProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MultiSelectFieldComboboxMode: ({ labelAiMark, id, helperUid, selectedOptions, onSelectedOptionsChange, displayAs, isDisabledOrReadOnly, disabled, readOnly, required, placeholder, size, error, hasHelperText, disableClearButton, prefix, suffix, label, hideLabel, hint, moreInfo, moreInfoId, errorMessages, warning, description, className, style, layoutStyles, pinned, groupToString, groupSorter, virtualize, options, loading, loadingMore, hasMore, loadOptions, loadMore, initialLoad, initialLoadPerformed, setInitialLoadPerformed, inputWrapperRef, debounceMs, selectAll, selectFiltered, bulkPending, onBulkActivate, singleRow, maxChips, getChipProps, onSearchChange, addItemLabel, onAddNewItem, handleRemoveOption, handleClear, }: MultiSelectFieldComboboxInternalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/beta/components/MultiSelectField/internal/MultiSelectFieldSelectMode.d.ts

@@ -3,4 +3,4 @@ import { MultiSelectFieldBaseInternalProps } from './types';
  * Select mode: non-searchable multi-select using useSelect.
  * Active when disableSearch is true.
  */
-export declare const MultiSelectFieldSelectMode: ({ labelAiMark, id, helperUid, selectedOptions, onSelectedOptionsChange, displayAs, isDisabledOrReadOnly, disabled, readOnly, required, placeholder, size, error, hasHelperText, disableClearButton, prefix, suffix, label, hideLabel, hint, moreInfo, moreInfoId, errorMessages, warning, description, className, style, layoutStyles, pinned, groupToString, groupSorter, virtualize, options, loading, loadingMore, hasMore, loadOptions, loadMore, initialLoad, initialLoadPerformed, setInitialLoadPerformed, inputWrapperRef, selectAll, singleRow, maxChips, getChipProps, addItemLabel, onAddNewItem, handleRemoveOption, handleClear, }: MultiSelectFieldBaseInternalProps) => import("react/jsx-runtime").JSX.Element;
+export declare const MultiSelectFieldSelectMode: ({ labelAiMark, id, helperUid, selectedOptions, onSelectedOptionsChange, displayAs, isDisabledOrReadOnly, disabled, readOnly, required, placeholder, size, error, hasHelperText, disableClearButton, prefix, suffix, label, hideLabel, hint, moreInfo, moreInfoId, errorMessages, warning, description, className, style, layoutStyles, pinned, groupToString, groupSorter, virtualize, options, loading, loadingMore, hasMore, loadOptions, loadMore, initialLoad, initialLoadPerformed, setInitialLoadPerformed, inputWrapperRef, selectAll, bulkPending, onBulkActivate, singleRow, maxChips, getChipProps, addItemLabel, onAddNewItem, handleRemoveOption, handleClear, }: MultiSelectFieldBaseInternalProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -49,9 +49,12 @@ export type MultiSelectFieldBaseInternalProps = {
     inputWrapperRef: RefObject<HTMLDivElement>;
     selectAll?: {
         label: string;
-        onClick: () => void;
         checkState: CheckState;
     };
+    /** True while a `compute`-driven bulk action's promise is in flight. */
+    bulkPending: boolean;
+    /** Called when the user activates the select-all or select-filtered row. */
+    onBulkActivate: (kind: "selectAll" | "selectFiltered", searchValue: string) => void;
     singleRow?: boolean;
     maxChips?: number;
     getChipProps?: (option: MultiSelectFieldOption) => MultiSelectFieldChipProps;
@@ -64,7 +67,6 @@ export type MultiSelectFieldComboboxInternalProps = MultiSelectFieldBaseInternal
     debounceMs: number;
     selectFiltered?: (searchValue: string) => {
         label?: string;
-        onClick: () => void;
         checkState: CheckState;
     };
     onSearchChange?: (searchValue: string) => void;

package/dist/src/beta/components/MultiSelectField/internal/useComboMultiple.d.ts

@@ -11,18 +11,20 @@ export type UseComboMultipleOptions = {
     groupToString?: (groupValue: MultiSelectFieldGroupByValue) => string;
     /** Function to sort group sections */
     groupSorter?: (a: MultiSelectFieldGroupByValue, b: MultiSelectFieldGroupByValue) => number;
-    /** Configuration for the "Select All" option (shown when search is empty) */
+    /** Configuration for the "Select All" option (shown when search is empty). */
     selectAll?: {
         label: string;
-        onClick: () => void;
         checkState: CheckState;
     };
-    /** Function that receives the search value and returns config for "Select Filtered" */
+    /** Function that receives the search value and returns config for "Select Filtered". */
     selectFiltered?: (searchValue: string) => {
         label?: string;
-        onClick: () => void;
         checkState: CheckState;
     };
+    /** True while a `compute`-driven bulk action is in flight. Disables option rows. */
+    bulkPending: boolean;
+    /** Called when the user activates the select-all or select-filtered row. */
+    onBulkActivate: (kind: "selectAll" | "selectFiltered", searchValue: string) => void;
     /** The currently selected options (controlled from outside) */
     selectedOptions: MultiSelectFieldOption[];
     onSelectedOptionsChange: (options: MultiSelectFieldOption[]) => void;
@@ -43,7 +45,7 @@ export type UseComboMultipleOptions = {
  * @param options - Configuration options for the hook
  * @returns Downshift combobox props and state
  */
-export declare const useComboMultiple: ({ options, pinned, groupToString, groupSorter, selectAll, selectFiltered, selectedOptions, onSelectedOptionsChange, onInputValueChange, onIsOpenChange, displayAs, disabled, loading, virtualize, onScrollToHighlight, }: UseComboMultipleOptions) => {
+export declare const useComboMultiple: ({ options, pinned, groupToString, groupSorter, selectAll, selectFiltered, bulkPending, onBulkActivate, selectedOptions, onSelectedOptionsChange, onInputValueChange, onIsOpenChange, displayAs, disabled, loading, virtualize, onScrollToHighlight, }: UseComboMultipleOptions) => {
     inputValue: string;
     wrapperDivRef: import('react').RefObject<HTMLDivElement>;
     getToggleButtonProps: <Options>(options?: import('downshift').UseComboboxGetToggleButtonPropsOptions & Options) => import('downshift').Overwrite<import('downshift').UseComboboxGetToggleButtonPropsReturnValue, Options>;

package/dist/src/beta/components/MultiSelectField/internal/useSelectModeMultiple.d.ts

@@ -8,9 +8,12 @@ export type UseSelectModeMultipleOptions = {
     groupSorter?: (a: MultiSelectFieldGroupByValue, b: MultiSelectFieldGroupByValue) => number;
     selectAll?: {
         label: string;
-        onClick: () => void;
         checkState: CheckState;
     };
+    /** True while a `compute`-driven bulk action is in flight. Disables option rows. */
+    bulkPending: boolean;
+    /** Called when the user activates the select-all row. */
+    onBulkActivate: (kind: "selectAll" | "selectFiltered", searchValue: string) => void;
     selectedOptions: MultiSelectFieldOption[];
     onSelectedOptionsChange: (options: MultiSelectFieldOption[]) => void;
     onIsOpenChange?: (changes: {
@@ -25,7 +28,7 @@ export type UseSelectModeMultipleOptions = {
  * Wraps downshift's useSelect for non-searchable multi-select fields.
  * Keeps menu open after selection and handles bulk actions.
  */
-export declare const useSelectModeMultiple: ({ options, pinned, groupToString, groupSorter, selectAll, selectedOptions, onSelectedOptionsChange, onIsOpenChange, displayAs, disabled, virtualize, onScrollToHighlight, }: UseSelectModeMultipleOptions) => {
+export declare const useSelectModeMultiple: ({ options, pinned, groupToString, groupSorter, selectAll, bulkPending, onBulkActivate, selectedOptions, onSelectedOptionsChange, onIsOpenChange, displayAs, disabled, virtualize, onScrollToHighlight, }: UseSelectModeMultipleOptions) => {
     wrapperDivRef: import('react').RefObject<HTMLDivElement>;
     getToggleButtonProps: <Options>(options?: import('downshift').UseSelectGetToggleButtonPropsOptions & Options, otherOptions?: import('downshift').GetPropsCommonOptions) => import('downshift').Overwrite<import('downshift').UseSelectGetToggleButtonReturnValue, Options>;
     getLabelProps: <Options>(options?: import('downshift').UseSelectGetLabelPropsOptions & Options) => import('downshift').Overwrite<import('downshift').UseSelectGetLabelPropsReturnValue, Options>;