@servicetitan/anvil2 3.14.1 → 3.15.0

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

@@ -5,9 +5,8 @@ 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.
- * Core props (`label`, `onClose`, `className`, `title`, `size`) are managed by the component and excluded from this type.
+ * Per-option chip overrides. `icon` and `avatar` are mutually exclusive;
+ * identity, removal, and sizing stay field-owned.
  */
 export type MultiSelectFieldChipProps = Partial<Omit<ChipProps, "icon" | "avatar" | "label" | "onClose" | "className" | "title" | "size">> & ({
     icon?: ChipProps["icon"];
@@ -16,367 +15,250 @@ export type MultiSelectFieldChipProps = Partial<Omit<ChipProps, "icon" | "avatar
     icon?: never;
     avatar?: ChipProps["avatar"];
 });
-/**
- * Configuration options for the MultiSelectField cache.
- * @property enabled - Whether caching is enabled. Defaults to true.
- * @property maxSize - Maximum number of cached entries before clearing the cache. Defaults to 15.
- */
+/** Per-search cache for `loadOptions` results. */
 export type MultiSelectFieldCacheOptions = {
+    /** Stays on unless `false`. Defaults to `true`. */
     enabled?: boolean;
+    /** Distinct search keys kept. Exceeding this wipes the map. Defaults to `15`. */
     maxSize?: number;
 };
-/**
- * Imperative handle for the MultiSelectField component.
- * @property clearCache - Clears the options cache.
- * @property invalidate - Clears the cache and triggers a fresh options load from the data source.
- */
+/** Imperative cache control for a mounted {@link MultiSelectField}. */
 export type MultiSelectFieldHandle = {
+    /** Drops cached `loadOptions` results without fetching. */
     clearCache: () => void;
+    /** Drops the cache and fetches options again. */
     invalidate: () => void;
 };
+/** Alias of {@link SelectFieldGroupByValue}. */
 export type MultiSelectFieldGroupByValue = SelectFieldGroupByValue;
-/**
- * Rich content configuration for a MultiSelectField option row.
- * Controls the avatar, icon, description, and chip display within an option.
- */
+/** Alias of {@link SelectFieldOptionContent}. */
 export type MultiSelectFieldOptionContent = SelectFieldOptionContent;
+/** Alias of {@link SelectFieldOption}. */
 export type MultiSelectFieldOption<TID extends string | number = string | number> = SelectFieldOption<TID>;
+/** Option that must have `group`. */
 export type MultiSelectFieldGroupedOption<TID extends string | number = string | number> = MultiSelectFieldOption<TID> & {
     group: MultiSelectFieldGroupByValue;
 };
+/** Option that must not have `group`. */
 export type MultiSelectFieldUngroupedOption<TID extends string | number = string | number> = Omit<MultiSelectFieldOption<TID>, "group"> & {
     group?: never;
 };
+/** Sync or async option list. */
 export type MultiSelectFieldOptionsResult<TID extends string | number = string | number> = MultiSelectFieldOption<TID>[] | Promise<MultiSelectFieldOption<TID>[]>;
 export type MultiSelectFieldEagerLoader<TID extends string | number = string | number> = (searchValue: string) => MultiSelectFieldOptionsResult<TID>;
 export type MultiSelectFieldOffsetLazyResult<TID extends string | number = string | number> = {
     options: MultiSelectFieldUngroupedOption<TID>[];
+    /** When true, scrolling to the end loads another batch. */
     hasMore?: boolean;
 };
 export type MultiSelectFieldOffsetLazyLoader<TID extends string | number = string | number> = (searchValue: string, offset: number, limit: number) => MultiSelectFieldOffsetLazyResult<TID> | Promise<MultiSelectFieldOffsetLazyResult<TID>>;
 export type MultiSelectFieldPageLazyResult<TID extends string | number = string | number> = {
     options: MultiSelectFieldUngroupedOption<TID>[];
+    /** When true, scrolling to the end loads another page. */
     hasMore?: boolean;
 };
 export type MultiSelectFieldPageLazyLoader<TID extends string | number = string | number> = (searchValue: string, pageNumber: number, pageSize: number) => MultiSelectFieldPageLazyResult<TID> | Promise<MultiSelectFieldPageLazyResult<TID>>;
 export type MultiSelectFieldGroupLazyResult<TID extends string | number = string | number> = {
     options: MultiSelectFieldGroupedOption<TID>[];
+    /** When true, scrolling to the end loads the next group. */
     hasMore?: boolean;
 };
 export type MultiSelectFieldGroupLazyLoader<TID extends string | number = string | number> = (searchValue: string, previousGroupKey: MultiSelectFieldGroupByValue | null) => MultiSelectFieldGroupLazyResult<TID> | Promise<MultiSelectFieldGroupLazyResult<TID>>;
 export type MultiSelectFieldSearchProps = {
-    /**
-     * The current search value.
-     * Not a preferred usage. You likely don't need to control the searchValue yourself.
-     */
+    /** Unused. Search is combobox-owned; prefer the search argument to `loadOptions`. */
     searchValue?: string;
-    /**
-     * Callback when the search value changes.
-     * Not a preferred usage. Lean on the searchValue in the loadOptions function instead.
-     */
+    /** Fires as the search field changes. Prefer the search argument to `loadOptions`. */
     onSearchChange?: (searchValue: string) => void;
-    /**
-     * The number of milliseconds to debounce the search input.
-     */
+    /** Debounce for `loadOptions` while typing. Defaults to `200`. */
     debounceMs?: number;
 };
 export type MultiSelectFieldPinnedOptionsSection<TID extends string | number = string | number> = {
+    /**
+     * Static list, or a loader keyed by the current search. Function results
+     * may be cached per search.
+     */
     options: MultiSelectFieldOption<TID>[] | ((searchValue: string) => MultiSelectFieldOption<TID>[] | Promise<MultiSelectFieldOption<TID>[]>);
+    /** Section heading. */
     label: string;
     /**
-     * Whether to re-call the loader when search value changes.
-     * Only applies when `options` is a function. Defaults to true.
-     * When false, the loader is called once and the result is reused for all search values.
-     *
-     * You may wish to use this, for example, if you are loading a set of "favorites" options that should not be re-loaded when the search value changes.
+     * Re-calls a function `options` when search changes. Defaults to `true`.
+     * `false` loads once and reuses the result for every search.
      */
     searchReactive?: boolean;
     /**
-     * Maximum number of search results to cache per section.
-     * Only applies when `options` is a function and `searchReactive` is true.
-     * Oldest entries are evicted when the limit is reached. Defaults to 15.
+     * Cached searches per function section when `searchReactive` is true.
+     * Oldest entries evict first. Defaults to `15`.
      */
     cacheSize?: number;
 };
-/**
- * There are two ways to configure pinned options.
- * 1. A labeled pinned options object (e.g. "Favorites", "Recent", "AI Suggestions", etc.)
- * 2. An array of labeled pinned options objects (e.g. [{"label": "Favorites", "options": [...]}])
- */
+/** Pinned sections above the loaded list: one section or an array of sections. */
 export type MultiSelectFieldPinnedOptions<TID extends string | number = string | number> = MultiSelectFieldPinnedOptionsSection<TID> | MultiSelectFieldPinnedOptionsSection<TID>[];
 type MultiSelectFieldCommonProps<TID extends string | number> = {
     /**
-     * The id of the multi-select field.
+     * Prefix for the input, trigger, popover, and dialog ids. Defaults to a
+     * generated id.
      */
     id?: string;
-    /**
-     * The label of the multi-select field.
-     */
+    /** Visible {@link FieldLabel} and dialog title. */
     label: string;
     /**
-     * The placeholder of the multi-select field.
+     * Native combobox placeholder while search is empty, even with chips.
+     * Listbox mode shows it only when nothing is selected.
      */
     placeholder?: string;
-    /**
-     * The size of the multi-select field.
-     */
+    /** Control size. Defaults to `medium`. */
     size?: Extract<Size, "small" | "medium" | "large">;
-    /**
-     * The selected options. Must be controlled state.
-     */
+    /** Controlled selected options. Pass `[]` for none. */
     value: MultiSelectFieldOption<TID>[];
-    /**
-     * The callback to call when the selected options change.
-     * @param options - The new array of selected options.
-     */
+    /** Called with the next selection. */
     onSelectedOptionsChange: (options: MultiSelectFieldOption<TID>[]) => void;
     /**
-     * Defines the initial loading behavior of the options. Controls when loadOptions is called.
-     * @default "auto"
-     * @description "auto" default behavior, currently equivalent to "immediate".
-     * @description "immediate" will load the initial options when the component is mounted.
-     * @description "open" will load the initial options if/when the user opens the dropdown.
+     * When `loadOptions` first runs. `"auto"` is `"immediate"` (mount). `"open"`
+     * waits for the first open. Defaults to `"auto"`.
      */
     initialLoad?: "auto" | "immediate" | "open";
-    /**
-     * The options to pin to the top of the list.
-     */
+    /** Favorites, recents, and similar sections. */
     pinned?: MultiSelectFieldPinnedOptions<TID>;
-    /**
-     * Configuration for caching loadOptions results.
-     * Caching is enabled by default. Set `{ enabled: false }` to disable.
-     */
+    /** Per-search `loadOptions` cache. Pass `{ enabled: false }` to disable. */
     cache?: MultiSelectFieldCacheOptions;
     /**
-     * The way to display the menu.
-     * @default "auto"
-     * @description "auto" will display the menu as a popover on mobile and a dialog on desktop.
-     * @description "popover" will always display the menu as a popover.
-     * @description "dialog" will always display the menu as a dialog.
+     * Menu surface. `"auto"` is a dialog on mobile and a popover otherwise.
+     * Defaults to `"auto"`.
      */
     displayMenuAs?: "auto" | "popover" | "dialog";
     /**
-     * Error state for the field. Pass `true` to indicate error styling without a message.
-     * Pass a string, string[], or ReactElement (deprecated) for error messages.
+     * Error styling. `true` is style-only; a string, string[], or React element
+     * (deprecated) also renders a message.
      */
     error?: boolean | string | ReactElement | string[];
     /**
-     * Visually hides the label while keeping it accessible to screen readers.
-     * @default false
+     * Hides the visual label while keeping it available to assistive technology.
+     * Defaults to `false`.
      */
     hideLabel?: boolean;
-    /**
-     * Hint text displayed below the input field.
-     */
+    /** Always shown below the field, including with error or warning. */
     hint?: ReactElement | string;
-    /**
-     * Additional information to display in a tooltip next to the label.
-     */
+    /** Tooltip next to the label. */
     moreInfo?: ReactNode;
-    /**
-     * Description text displayed below the input field.
-     */
+    /** Extra copy after `hint`. */
     description?: ReactElement | string;
     /**
      * @deprecated No longer used. Error messages always use `aria-live="assertive"`.
      */
     errorAriaLive?: AriaAttributes["aria-live"];
-    /**
-     * Warning message(s) to display. Supports a single string or an array of strings.
-     */
+    /** Warning copy with icon. */
     warning?: string | string[];
-    /**
-     * Whether the field is required. Shows a red asterisk (*) next to the label.
-     */
+    /** Shows the required indicator. Listbox mode also sets `aria-required` on the trigger. */
     required?: boolean;
     /**
-     * AI mark configuration to display next to the label.
-     * Can be a boolean to show a simple AI mark, or an object with tooltip/popover configuration.
+     * AI mark after the label. `true` is sparkle-only; pass tooltip/popover
+     * config for the richer mark.
      */
     labelAiMark?: AiMarkWithTooltipOrPopoverProps["aiMark"];
-    /**
-     * Whether the field is disabled.
-     * When disabled, the input is still focusable but menu items cannot be selected.
-     */
+    /** Blocks selection. Combobox uses a native-disabled input; listbox uses `aria-disabled` on the trigger. */
     disabled?: boolean;
-    /**
-     * Whether the field is read-only.
-     * When read-only, the input is still focusable but menu items cannot be selected.
-     */
+    /** Focusable, but menu rows and chips cannot change the selection. */
     readOnly?: boolean;
-    /**
-     * When `true`, applies a subdued primary background to the field to draw attention to it.
-     * @default false
-     */
+    /** Subdued primary field background. Defaults to `false`. */
     isHighlighted?: boolean;
-    /**
-     * Content to display before the input field.
-     */
+    /** Chrome before the chips in the input or listbox trigger. */
     prefix?: string | ReactElement;
-    /**
-     * Content to display after the input field.
-     */
+    /** Chrome after the search input. Listbox mode shows it only with no selection. */
     suffix?: string | ReactElement;
     /**
-     * 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.
-     *
-     * `checkState` may be a static value or a function of the current selection,
-     * so the row's checkbox can reflect how much of the set is selected.
-     *
-     * 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.
+     * Select All row when search is empty. Pass `onClick` (consumer commits) or
+     * `compute` (field commits, sync or async). Pending `compute` disables rows.
+     * `checkState` may be static or a function of the current selection.
      */
     selectAll?: BulkActionConfig<TID>;
     /**
-     * Function that receives the current search value and returns configuration for
-     * the "Select Filtered" option at the top of the list.
-     *
-     * 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 BulkActionConfig describing the row
+     * Select Filtered row when search is non-empty. Same `onClick` / `compute`
+     * choice as `selectAll`. Unused when `disableSearch`.
      */
     selectFiltered?: (searchValue: string) => BulkActionConfig<TID>;
     /**
-     * When true, restricts the field to a single row height.
-     * Overflow chips will be collapsed into a "+N" indicator.
-     * @default false
+     * Keeps chips on one row and collapses overflow into a `+N` chip. Defaults
+     * to `false`.
      */
     singleRow?: boolean;
     /**
-     * Maximum number of chips to display before showing a "+N" indicator.
-     * Applies regardless of fixedHeight setting.
-     * @default 10
+     * Most chips rendered before the `+N` chip, whether or not `singleRow`.
+     * Defaults to `10`.
      */
     maxChips?: number;
-    /**
-     * Custom CSS class name for the wrapper element.
-     */
     className?: string;
-    /**
-     * Custom inline styles for the wrapper element.
-     */
     style?: CSSProperties;
-    /**
-     * Whether to virtualize the dropdown list using windowed rendering.
-     * Enable this for large option sets to improve performance by only rendering visible items.
-     * @default false
-     */
+    /** Windowed option rendering for large lists. Defaults to `false`. */
     virtualize?: boolean;
     /**
-     * Whether to disable the search input.
-     * When true, the input is replaced with a non-editable select trigger and the ARIA pattern
-     * changes from combobox to listbox.
-     * @default false
+     * Replaces the combobox input with a non-editable listbox trigger. Defaults
+     * to `false`.
      */
     disableSearch?: boolean;
     /**
-     * Callback to customize chip props for each selected option.
-     * Allows customizing chip appearance (color, icon, avatar, etc.) per option.
-     * Core props (label, onClose, className, title, size) are managed by the component and excluded from this type.
-     * @param option - The selected option the chip represents
-     * @returns Partial chip props to merge onto the chip
+     * Per-option appearance overrides. Label, removal, title, class, and size
+     * remain field-owned.
      */
     getChipProps?: (option: MultiSelectFieldOption<TID>) => MultiSelectFieldChipProps;
 } & MultiSelectFieldSearchProps & LayoutUtilProps & AddNewItemProps & DataAttributes;
 type MultiSelectFieldGroupingProps = {
     /**
-     * Function to convert a group value to a display label.
-     * Only used when options have a `group` property.
-     * @param groupValue - The group value from the option's `group` property
-     * @returns The formatted group label
+     * Turns an option `group` value into a section heading. Unused when options
+     * have no `group`.
      */
     groupToString?: (groupValue: MultiSelectFieldGroupByValue) => string;
     /**
-     * Custom comparator function to sort groups.
-     * Receives two group values and returns a number indicating sort order.
-     * Without this, groups appear in the order they are first encountered.
-     * @param a - First group value to compare
-     * @param b - Second group value to compare
-     * @returns Negative if a < b, positive if a > b, zero if equal
+     * Orders groups. Unused when options have no `group`.
      */
     groupSorter?: (a: MultiSelectFieldGroupByValue, b: MultiSelectFieldGroupByValue) => number;
 };
 type MultiSelectFieldNonGroupingProps = {
-    /**
-     * Incompatible with non-group lazy loading.
-     */
     groupToString?: never;
-    /**
-     * Incompatible with non-group lazy loading.
-     */
     groupSorter?: never;
 };
+/** Page-number scroll loading. */
 export type MultiSelectFieldPropsLazyPage<TID extends string | number = string | number> = MultiSelectFieldCommonProps<TID> & {
-    /**
-     * Lazy loading mode using page-based pagination.
-     * Options will be loaded on demand when the user scrolls to the bottom of the list.
-     * This mode only supports flat options (i.e. cannot be used with grouped options).
-     */
+    /** Scroll pagination by page number. Grouping props are not allowed. */
     lazy: "page";
     lazyOptions?: {
+        /** Options per `loadOptions` call. Defaults to `20`. */
         pageSize?: number;
     };
-    /**
-     * Function to load the options.
-     */
+    /** Called with search, page number, and page size. Return `{ options, hasMore }`. */
     loadOptions: MultiSelectFieldPageLazyLoader<TID>;
 } & MultiSelectFieldNonGroupingProps;
+/** Offset scroll loading. */
 export type MultiSelectFieldPropsLazyOffset<TID extends string | number = string | number> = MultiSelectFieldCommonProps<TID> & {
-    /**
-     * Lazy loading mode using offset-based pagination.
-     * Options will be loaded on demand when the user scrolls to the bottom of the list.
-     * This mode only supports flat options (i.e. cannot be used with grouped options).
-     */
+    /** Scroll pagination by offset. Grouping props are not allowed. */
     lazy: "offset";
     lazyOptions?: {
+        /** Options per `loadOptions` call. Defaults to `20`. */
         limit?: number;
     };
-    /**
-     * Function to load the options.
-     */
+    /** Called with search, offset, and limit. Return `{ options, hasMore }`. */
     loadOptions: MultiSelectFieldOffsetLazyLoader<TID>;
 } & MultiSelectFieldNonGroupingProps;
+/** Group-key scroll loading. */
 export type MultiSelectFieldPropsLazyGroup<TID extends string | number = string | number> = MultiSelectFieldCommonProps<TID> & {
-    /**
-     * Lazy loading mode using incremental group loading.
-     * Groups will be loaded on demand when the user scrolls to the bottom of the list.
-     * This mode supports grouped options.
-     */
+    /** Scroll pagination by group key. */
     lazy: "group";
+    /** Present so this branch matches other lazy variants. */
     lazyOptions?: object;
-    /**
-     * Function to load the options.
-     */
+    /** Called with search and the previous group key (`null` first). Return `{ options, hasMore }`. */
     loadOptions: MultiSelectFieldGroupLazyLoader<TID>;
 } & MultiSelectFieldGroupingProps;
+/** Eager `loadOptions`. */
 export type MultiSelectFieldPropsEager<TID extends string | number = string | number> = MultiSelectFieldCommonProps<TID> & {
-    /**
-     * Whether the options are lazy loaded. If true, the options will be loaded on demand when the user scrolls to the bottom of the list.
-     * @default false
-     */
+    /** Eager fetch on `initialLoad`. No scroll pagination. */
     lazy?: false;
-    /**
-     * Function to load the options.
-     */
+    /** Called with the current search. Return options or a promise of options. */
     loadOptions: MultiSelectFieldEagerLoader<TID>;
 } & MultiSelectFieldGroupingProps;
+/** Page, offset, or group lazy {@link MultiSelectFieldProps}. */
 export type MultiSelectFieldPropsLazy<TID extends string | number = string | number> = MultiSelectFieldPropsLazyPage<TID> | MultiSelectFieldPropsLazyOffset<TID> | MultiSelectFieldPropsLazyGroup<TID>;
+/**
+ * Multi-select field. Discriminated by `lazy`: omit or `false` for eager
+ * `loadOptions`; `"page"` / `"offset"` / `"group"` for lazy loaders.
+ */
 export type MultiSelectFieldProps<TID extends string | number = string | number> = MultiSelectFieldPropsLazy<TID> | MultiSelectFieldPropsEager<TID>;
 export {};

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

@@ -1,32 +1,3 @@
 import { MultiSelectMenuHandle, MultiSelectMenuProps } from './types';
-/**
- * MultiSelectMenu component for selecting multiple options from a dropdown triggered by any element.
- *
- * Features:
- * - Attaches to any trigger element via a render prop
- * - Multiple selection with checkbox indicators
- * - Optional search input rendered inside the popover/dialog
- * - Lazy loading with pagination (page, offset, or group modes)
- * - Optional "Select All" functionality
- * - Optional "Select Filtered" functionality
- * - Pinned options support
- * - Grouped options support
- * - Supports both popover and dialog display modes
- * - Adaptive display based on device (mobile uses dialog)
- * - Cache support for loadOptions results
- * - Full accessibility support with ARIA attributes
- * - 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
- *   trigger={(props) => <Button {...props}>Select books</Button>}
- *   label="Books"
- *   value={selectedOptions}
- *   onSelectedOptionsChange={setSelectedOptions}
- *   loadOptions={loadOptions}
- * />
- */
+/** Multi-select menu opened from a custom trigger. Selection is controlled. */
 export declare const MultiSelectMenu: import('react').ForwardRefExoticComponent<MultiSelectMenuProps & import('react').RefAttributes<MultiSelectMenuHandle>>;

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

@@ -2,53 +2,29 @@ import { MatchSorterOptions } from 'match-sorter';
 import { MultiSelectMenuProps, MultiSelectMenuOption } from './types';
 import { SyncFilterFn } from '../../internal/functions/syncFilterUtils';
 export type MultiSelectMenuSyncProps<TID extends string | number = string | number> = Omit<MultiSelectMenuProps<TID>, "loadOptions" | "lazy" | "debounceMs" | "cache" | "initialLoad" | "selectAll" | "selectFiltered"> & {
-    /**
-     * The options to display in the multi-select menu.
-     */
+    /** In-memory options. Search filters this list instead of calling `loadOptions`. */
     options: MultiSelectMenuOption<TID>[];
     /**
-     * Controls how options are filtered and sorted when the user types a search value.
-     * Can be a function that returns options in the desired display order,
-     * or a MatchSorterOptions object to customize the default match-sorter behavior.
-     *
-     * By default, options are filtered by `label` and `searchText` using match-sorter.
+     * Filter and sort as the user types. A function returns the display order;
+     * a match-sorter options object customizes the default. Defaults to
+     * match-sorter on `label` and `searchText`.
      */
     filter?: SyncFilterFn<TID, MultiSelectMenuOption<TID>> | MatchSorterOptions<MultiSelectMenuOption<TID>>;
     /**
-     * Enables the "Select All" option at the top of the list.
-     * Can be a boolean to enable with default label, or an object to customize the label.
-     * Click handling and check state are managed automatically.
+     * Select All when search is empty. `true` uses the default label; an object
+     * customizes the label. Click and check state are owned by Sync.
      */
     selectAll?: boolean | {
         label?: string | ((checked: boolean) => string);
     };
     /**
-     * Enables the "Select Filtered" option when a search term is active.
-     * Can be a boolean to enable with default label, or a function returning a config with a custom label.
-     * Click handling and check state are managed automatically.
+     * Select Filtered when search is non-empty. `true` uses the default label;
+     * a function may return a custom label. Click and check state are owned by
+     * Sync.
      */
     selectFiltered?: boolean | ((searchValue: string) => {
         label?: string;
     });
 };
-/**
- * MultiSelectMenuSync is a simplified version of MultiSelectMenu for client-side option sets.
- *
- * Features:
- * - Accepts `options` instead of `loadOptions` and `lazy`
- * - Performs client-side filtering of the options
- * - Simplified `selectAll` prop that automatically handles click and check state
- * - Simplified `selectFiltered` prop that automatically selects/deselects filtered options
- * - Supports all other props of MultiSelectMenu
- *
- * @example
- * <MultiSelectMenuSync
- *   trigger={(props) => <Button {...props}>Pick books</Button>}
- *   label="Books"
- *   options={bookOptions}
- *   value={selectedOptions}
- *   onSelectedOptionsChange={setSelectedOptions}
- *   selectAll
- * />
- */
+/** {@link MultiSelectMenu} for a client-side `options` list. */
 export declare const MultiSelectMenuSync: (props: MultiSelectMenuSyncProps) => import("react/jsx-runtime").JSX.Element;