@servicetitan/anvil2 2.2.0 → 2.3.0

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

@@ -0,0 +1,5 @@
+import { MultiSelectFieldComboboxInternalProps } from './types';
+/**
+ * Combobox mode: searchable multi-select using useCombobox.
+ */
+export declare const MultiSelectFieldComboboxMode: ({ id, helperUid, selectedOptions, onSelectedOptionsChange, displayAs, isDisabledOrReadOnly, disabled, readOnly, required, placeholder, size, error, hasHelperText, disableClearButton, prefix, suffix, label, labelNode, hideLabel, hint, 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, onSearchChange, handleRemoveOption, handleClear, }: MultiSelectFieldComboboxInternalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/beta/components/MultiSelectField/internal/MultiSelectFieldInput.d.ts

@@ -12,7 +12,6 @@ import { MultiSelectFieldOption } from '../types';
  * @property {boolean} [error] - Shows error styling on the input when true
  * @property {() => void} [onClear] - Callback fired when the clear button is clicked
  * @property {string} [id] - HTML id attribute for the input element
- * @property {string} [popoverTarget] - Target identifier for popover association
  * @property {RefObject<HTMLDivElement>} [inputWrapperRef] - Ref for the input wrapper div element
  * @property {PassThroughProps<"div">} [htmlInputWrapperProps] - Additional props passed to the wrapper div
  * @property {PassThroughProps<"input">} [inputProps] - Additional props passed to the input element
@@ -34,7 +33,6 @@ export type MultiSelectFieldInputProps = {
     error?: boolean;
     onClear?: () => void;
     id?: string;
-    popoverTarget?: string;
     inputWrapperRef?: RefObject<HTMLDivElement>;
     htmlInputWrapperProps?: PassThroughProps<"div">;
     inputProps?: PassThroughProps<"input">;

package/dist/beta/components/MultiSelectField/internal/MultiSelectFieldList.d.ts

@@ -1,15 +1,12 @@
 import { MultiSelectFieldDownshiftItem, MultiSelectFieldOption } from '../types';
-import { UseComboboxPropGetters } from 'downshift';
 import { CSSProperties, MutableRefObject } from 'react';
 import { FieldListBaseHandle } from '../../SelectField/internal/FieldListBase';
-import { SectionMeta } from '../../SelectField/internal/types';
-type GetMenuProps = UseComboboxPropGetters<MultiSelectFieldDownshiftItem>["getMenuProps"];
-type GetItemProps = UseComboboxPropGetters<MultiSelectFieldDownshiftItem>["getItemProps"];
+import { GetItemPropsFn, GetMenuPropsFn, SectionMeta } from '../../SelectField/internal/types';
 export type MultiSelectFieldListProps = {
     isOpen: boolean;
     items: MultiSelectFieldDownshiftItem[];
-    getMenuProps: GetMenuProps;
-    getItemProps: GetItemProps;
+    getMenuProps: GetMenuPropsFn;
+    getItemProps: GetItemPropsFn;
     highlightedIndex: number;
     highlightChangeTypeRef?: MutableRefObject<string>;
     selectedOptions: MultiSelectFieldOption[];
@@ -25,4 +22,3 @@ export type MultiSelectFieldListProps = {
     virtualize?: boolean;
 };
 export declare const MultiSelectFieldList: import('react').ForwardRefExoticComponent<MultiSelectFieldListProps & import('react').RefAttributes<FieldListBaseHandle>>;
-export {};

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

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

package/dist/beta/components/MultiSelectField/internal/MultiSelectFieldTrigger.d.ts

@@ -0,0 +1,30 @@
+import { Size } from '../../../../types';
+import { ReactElement, RefObject } from 'react';
+import { MultiSelectFieldOption } from '../types';
+export type MultiSelectFieldTriggerProps = {
+    placeholder?: string;
+    size?: Extract<Size, "small" | "medium" | "large">;
+    disableClearButton?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    error?: boolean;
+    onClear?: () => void;
+    id?: string;
+    popoverTarget?: string;
+    inputWrapperRef?: RefObject<HTMLDivElement>;
+    toggleButtonProps?: Record<string, any>;
+    prefix?: string | ReactElement;
+    suffix?: string | ReactElement;
+    selectedOptions?: MultiSelectFieldOption[];
+    onRemoveOption?: (option: MultiSelectFieldOption) => void;
+    singleRow?: boolean;
+    maxChips?: number;
+};
+/**
+ * Non-searchable trigger for MultiSelectField when disableSearch is true.
+ * Renders chips for selected items in a div-based trigger (no input element).
+ */
+export declare const MultiSelectFieldTrigger: {
+    ({ placeholder, size, disableClearButton, disabled, readOnly, error, onClear, id, inputWrapperRef, toggleButtonProps, prefix, suffix, selectedOptions, onRemoveOption, singleRow, maxChips, popoverTarget, }: MultiSelectFieldTriggerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

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

@@ -0,0 +1,67 @@
+import { ReactElement, RefObject } from 'react';
+import { CheckState } from '../../../../types';
+import { MultiSelectFieldOption, MultiSelectFieldProps } from '../types';
+export type MultiSelectFieldBaseInternalProps = {
+    id: string;
+    helperUid: string;
+    selectedOptions: MultiSelectFieldOption[];
+    onSelectedOptionsChange: (options: MultiSelectFieldOption[]) => void;
+    displayAs: "popover" | "dialog";
+    isDisabledOrReadOnly: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    size?: "small" | "medium" | "large";
+    error?: boolean | string | ReactElement | string[];
+    hasHelperText: boolean;
+    disableClearButton: boolean;
+    prefix?: string | ReactElement;
+    suffix?: string | ReactElement;
+    label: string;
+    labelNode?: React.ReactNode;
+    hideLabel?: boolean;
+    hint?: ReactElement | string;
+    errorMessages?: string | ReactElement | string[];
+    warning?: string | string[];
+    description?: ReactElement | string;
+    className?: string;
+    style?: React.CSSProperties;
+    layoutStyles?: React.CSSProperties;
+    pinned?: MultiSelectFieldProps["pinned"];
+    groupToString?: (groupValue: string | number) => string;
+    groupSorter?: (a: string | number, b: string | number) => number;
+    virtualize?: boolean;
+    options: MultiSelectFieldOption[];
+    loading: boolean;
+    loadingMore: boolean;
+    hasMore: boolean;
+    loadOptions: (searchValue: string, opts?: {
+        initial?: boolean;
+    }) => Promise<void>;
+    loadMore: (searchValue: string) => Promise<void>;
+    initialLoad: "immediate" | "open";
+    initialLoadPerformed: boolean;
+    setInitialLoadPerformed: (val: boolean) => void;
+    inputWrapperRef: RefObject<HTMLDivElement>;
+    selectAll?: {
+        label: string;
+        onClick: () => void;
+        checkState: CheckState;
+    };
+    singleRow?: boolean;
+    maxChips?: number;
+    handleRemoveOption: (option: {
+        id: string | number;
+    }) => void;
+    handleClear: () => void;
+};
+export type MultiSelectFieldComboboxInternalProps = MultiSelectFieldBaseInternalProps & {
+    debounceMs: number;
+    selectFiltered?: (searchValue: string) => {
+        label?: string;
+        onClick: () => void;
+        checkState: CheckState;
+    };
+    onSearchChange?: (searchValue: string) => void;
+};

package/dist/beta/components/MultiSelectField/internal/useChipLayout.d.ts

@@ -0,0 +1,19 @@
+import { RefObject } from 'react';
+type UseChipLayoutOptions = {
+    selectedOptionsLength: number;
+    singleRow?: boolean;
+    maxChips?: number;
+};
+/**
+ * Manages chip layout calculations shared between MultiSelectFieldInput and
+ * MultiSelectFieldTrigger. Handles single-row overflow detection, visible chip
+ * count, and the "+N" hidden chip indicator.
+ * @param options - Configuration for chip layout behaviour
+ * @returns rowsRef to attach to the chip container, plus computed display/hidden counts
+ */
+export declare function useChipLayout({ selectedOptionsLength, singleRow, maxChips, }: UseChipLayoutOptions): {
+    rowsRef: RefObject<HTMLDivElement>;
+    displayCount: number;
+    hiddenCount: number;
+};
+export {};

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

@@ -1,7 +1,6 @@
 import { UseComboboxProps } from 'downshift';
 import { MultiSelectFieldDownshiftItem, MultiSelectFieldGroupByValue, MultiSelectFieldOption, MultiSelectFieldPinnedOptions } from '../types';
 import { CheckState } from '../../../../types';
-import { SectionMeta } from '../../SelectField/internal/types';
 export type UseComboMultipleOptions = {
     /** An array of currently loaded options */
     options: MultiSelectFieldOption[];
@@ -54,7 +53,7 @@ export declare const useComboMultiple: ({ options, pinned, groupToString, groupS
     highlightChangeTypeRef: import('react').MutableRefObject<string>;
     isOpen: boolean;
     downshiftItems: import('../..').SelectFieldDownshiftItem[];
-    sectionsMeta: SectionMeta[];
+    sectionsMeta: import('../../SelectField/internal/types').SectionMeta[];
     closeMenu: () => void;
     openMenu: () => void;
     toggleMenu: () => void;

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

@@ -0,0 +1,40 @@
+import { MultiSelectFieldGroupByValue, MultiSelectFieldOption, MultiSelectFieldPinnedOptions } from '../types';
+import { CheckState } from '../../../../types';
+export type UseSelectModeMultipleOptions = {
+    options: MultiSelectFieldOption[];
+    pinned?: MultiSelectFieldPinnedOptions;
+    groupToString?: (groupValue: MultiSelectFieldGroupByValue) => string;
+    groupSorter?: (a: MultiSelectFieldGroupByValue, b: MultiSelectFieldGroupByValue) => number;
+    selectAll?: {
+        label: string;
+        onClick: () => void;
+        checkState: CheckState;
+    };
+    selectedOptions: MultiSelectFieldOption[];
+    onSelectedOptionsChange: (options: MultiSelectFieldOption[]) => void;
+    onIsOpenChange?: (changes: {
+        isOpen?: boolean;
+    }) => void;
+    displayAs: "popover" | "dialog";
+    disabled: boolean;
+    virtualize?: boolean;
+};
+/**
+ * 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, }: 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>;
+    getMenuProps: <Options>(options?: import('downshift').UseSelectGetMenuPropsOptions & Options, otherOptions?: import('downshift').GetPropsCommonOptions) => import('downshift').Overwrite<import('downshift').UseSelectGetMenuReturnValue, Options>;
+    getItemProps: <Options>(options: import('downshift').UseSelectGetItemPropsOptions<import('../..').SelectFieldDownshiftItem> & Options) => Omit<import('downshift').Overwrite<import('downshift').UseSelectGetItemPropsReturnValue, Options>, "item" | "index">;
+    highlightedIndex: number;
+    isOpen: boolean;
+    downshiftItems: import('../..').SelectFieldDownshiftItem[];
+    sectionsMeta: import('../../SelectField/internal/types').SectionMeta[];
+    closeMenu: () => void;
+    openMenu: () => void;
+    toggleMenu: () => void;
+    selectedOptions: import('../..').SelectFieldOption[];
+};

package/dist/beta/components/MultiSelectField/internal/useToggleSelection.d.ts

@@ -0,0 +1,21 @@
+import { SelectFieldOption } from '../../SelectField/types';
+import { NormalizedPinnedSection } from '../../SelectField/internal/usePinnedOptions';
+type UseToggleSelectionParams = {
+    options: SelectFieldOption[];
+    pinnedSections: NormalizedPinnedSection[];
+    selectedOptions: SelectFieldOption[];
+    onSelectedOptionsChange: (options: SelectFieldOption[]) => void;
+};
+/**
+ * Shared multi-select toggle logic: computes allPinnedOptions and provides
+ * handleItemClick to add/remove an option from the selection.
+ * Used by both useComboMultiple and useSelectModeMultiple.
+ */
+export declare const useToggleSelection: ({ options, pinnedSections, selectedOptions, onSelectedOptionsChange, }: UseToggleSelectionParams) => {
+    handleItemClick: (option: {
+        id: string | number;
+        label: string;
+    }) => void;
+    allPinnedOptions: SelectFieldOption[];
+};
+export {};

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

@@ -268,6 +268,13 @@ type MultiSelectFieldCommonProps = {
      * @default 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
+     */
+    disableSearch?: boolean;
 } & MultiSelectFieldSearchProps & LayoutUtilProps;
 type MultiSelectFieldGroupingProps = {
     /**

package/dist/beta/components/SelectField/internal/FieldDialog/FieldDialog.d.ts

@@ -4,7 +4,7 @@ export declare const FieldDialog: ({ id, isOpen, onClose, field, children, title
     isOpen: boolean;
     onClose: () => void;
     title: string;
-    field: React.ReactNode;
+    field?: React.ReactNode;
     children: React.ReactNode;
     initialFocusResolver?: (focusables: FocusableElement[]) => FocusableElement;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/beta/components/SelectField/internal/FieldListBase.d.ts

@@ -1,16 +1,15 @@
-import { UseComboboxPropGetters } from 'downshift';
 import { SelectFieldDownshiftItem } from '../types';
 import { CSSProperties, MutableRefObject } from 'react';
 import { CheckState } from '../../../../types';
-import { SectionMeta } from './types';
+import { GetItemPropsFn, GetMenuPropsFn, SectionMeta } from './types';
 export type FieldListBaseHandle = {
     scrollToTop: () => void;
 };
 export type FieldListBaseProps = {
     isOpen: boolean;
     items: SelectFieldDownshiftItem[];
-    getMenuProps: UseComboboxPropGetters<SelectFieldDownshiftItem>["getMenuProps"];
-    getItemProps: UseComboboxPropGetters<SelectFieldDownshiftItem>["getItemProps"];
+    getMenuProps: GetMenuPropsFn;
+    getItemProps: GetItemPropsFn;
     highlightedIndex: number;
     highlightChangeTypeRef?: MutableRefObject<string>;
     getCheckedState: (item: SelectFieldDownshiftItem) => CheckState;

package/dist/beta/components/SelectField/internal/SelectFieldComboboxMode.d.ts

@@ -0,0 +1,6 @@
+import { SelectFieldComboboxInternalProps } from './types';
+/**
+ * Combobox mode: searchable select using useCombobox.
+ * This is the default behavior when disableSearch is false.
+ */
+export declare const SelectFieldComboboxMode: ({ id, helperUid, selectedOption, onSelectedOptionChange, displayAs, isDisabledOrReadOnly, disabled, readOnly, required, placeholder, size, error, hasHelperText, disableClearButton, prefix, suffix, label, labelNode, hideLabel, hint, errorMessages, warning, description, className, style, layoutStyles, pinned, groupToString, groupSorter, virtualize, options, loading, loadingMore, hasMore, loadOptions, loadMore, initialLoad, initialLoadPerformed, setInitialLoadPerformed, inputWrapperRef, debounceMs, }: SelectFieldComboboxInternalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/beta/components/SelectField/internal/SelectFieldInput.d.ts

@@ -12,7 +12,6 @@ import { ReactElement, RefObject } from 'react';
  * @property {boolean} [error] - Shows error styling on the input when true
  * @property {() => void} [onClear] - Callback fired when the clear button is clicked
  * @property {string} [id] - HTML id attribute for the input element
- * @property {string} [popoverTarget] - Target identifier for popover association
  * @property {RefObject<HTMLDivElement>} [inputWrapperRef] - Ref for the input wrapper div element
  * @property {PassThroughProps<"div">} [htmlInputWrapperProps] - Additional props passed to the wrapper div
  * @property {PassThroughProps<"input">} [inputProps] - Additional props passed to the input element
@@ -31,7 +30,6 @@ export type SelectFieldInputProps = {
     error?: boolean;
     onClear?: () => void;
     id?: string;
-    popoverTarget?: string;
     inputWrapperRef?: RefObject<HTMLDivElement>;
     htmlInputWrapperProps?: PassThroughProps<"div">;
     inputProps?: PassThroughProps<"input">;

package/dist/beta/components/SelectField/internal/SelectFieldLabel.d.ts

@@ -1,7 +1,8 @@
 import { ReactNode } from 'react';
-import { UseComboboxPropGetters } from 'downshift';
-import { SelectFieldDownshiftItem } from '../types';
-type GetLabelProps = UseComboboxPropGetters<SelectFieldDownshiftItem>["getLabelProps"];
+type GetLabelProps = (options?: object) => {
+    id: string;
+    htmlFor: string;
+};
 /**
  * Props for the SelectFieldLabel component
  * @property {string} label - The text content to display as the label

package/dist/beta/components/SelectField/internal/SelectFieldList.d.ts

@@ -1,14 +1,11 @@
 import { SelectFieldDownshiftItem, SelectFieldOption } from '../types';
-import { UseComboboxPropGetters } from 'downshift';
 import { CSSProperties, MutableRefObject } from 'react';
-import { SectionMeta } from './types';
-type GetMenuProps = UseComboboxPropGetters<SelectFieldDownshiftItem>["getMenuProps"];
-type GetItemProps = UseComboboxPropGetters<SelectFieldDownshiftItem>["getItemProps"];
+import { GetItemPropsFn, GetMenuPropsFn, SectionMeta } from './types';
 export type SelectFieldListProps = {
     isOpen: boolean;
     items: SelectFieldDownshiftItem[];
-    getMenuProps: GetMenuProps;
-    getItemProps: GetItemProps;
+    getMenuProps: GetMenuPropsFn;
+    getItemProps: GetItemPropsFn;
     highlightedIndex: number;
     highlightChangeTypeRef?: MutableRefObject<string>;
     selectedOption: SelectFieldOption | null;
@@ -27,4 +24,3 @@ export declare const SelectFieldList: {
     ({ selectedOption, virtualize, ...rest }: SelectFieldListProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
-export {};

package/dist/beta/components/SelectField/internal/SelectFieldListItem.d.ts

@@ -1,16 +1,14 @@
-import { UseComboboxPropGetters } from 'downshift';
 import { SelectFieldDownshiftItem } from '../types';
 import { CheckState } from '../../../../types';
-type GetItemProps = UseComboboxPropGetters<SelectFieldDownshiftItem>["getItemProps"];
+import { GetItemPropsFn } from './types';
 export type SelectFieldListItemProps = {
     item: SelectFieldDownshiftItem;
     index: number;
     highlighted: boolean;
     disabled: boolean;
-    getItemProps: GetItemProps;
+    getItemProps: GetItemPropsFn;
     selectionType: "single" | "multiple";
     checked: CheckState;
     isListScrolled?: boolean;
 };
 export declare const SelectFieldListItem: ({ item, index, highlighted, disabled, getItemProps, selectionType, checked, isListScrolled, }: SelectFieldListItemProps) => import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/beta/components/SelectField/internal/SelectFieldSelectMode.d.ts

@@ -0,0 +1,6 @@
+import { SelectFieldBaseInternalProps } from './types';
+/**
+ * Select mode: non-searchable select using useSelect.
+ * Active when disableSearch is true.
+ */
+export declare const SelectFieldSelectMode: ({ id, helperUid, selectedOption, onSelectedOptionChange, displayAs, isDisabledOrReadOnly, disabled, readOnly, placeholder, size, error, hasHelperText, disableClearButton, prefix, suffix, label, labelNode, hideLabel, hint, errorMessages, warning, description, className, style, layoutStyles, pinned, groupToString, groupSorter, virtualize, options, loading, loadingMore, hasMore, loadOptions, loadMore, initialLoad, initialLoadPerformed, setInitialLoadPerformed, inputWrapperRef, required, }: SelectFieldBaseInternalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/beta/components/SelectField/internal/SelectFieldTrigger.d.ts

@@ -0,0 +1,27 @@
+import { Size } from '../../../../types';
+import { ReactElement, RefObject } from 'react';
+export type SelectFieldTriggerProps = {
+    placeholder?: string;
+    size?: Extract<Size, "small" | "medium" | "large">;
+    disableClearButton?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    error?: boolean;
+    onClear?: () => void;
+    id?: string;
+    popoverTarget?: string;
+    inputWrapperRef?: RefObject<HTMLDivElement>;
+    toggleButtonProps?: Record<string, any>;
+    /** The display text (selected option label or empty) */
+    displayValue?: string;
+    prefix?: string | ReactElement;
+    suffix?: string | ReactElement;
+};
+/**
+ * Non-searchable select trigger for SelectField when disableSearch is true.
+ * Renders a div-based trigger instead of an input, suitable for the listbox ARIA pattern.
+ */
+export declare const SelectFieldTrigger: {
+    ({ placeholder, size, disableClearButton, disabled, readOnly, error, onClear, id, inputWrapperRef, toggleButtonProps, displayValue, prefix, suffix, popoverTarget, }: SelectFieldTriggerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/beta/components/SelectField/internal/buildDownshiftItems.d.ts

@@ -0,0 +1,22 @@
+import { SelectFieldDownshiftItem, SelectFieldOption } from '../types';
+import { SectionMeta } from './types';
+import { NormalizedPinnedSection } from './usePinnedOptions';
+import { NormalizedGroupSection } from './useGroupedOptions';
+export declare function mapOptionToDownshiftItem(option: SelectFieldOption): SelectFieldDownshiftItem;
+type BuildDownshiftItemsParams = {
+    prefixItems?: SelectFieldDownshiftItem[];
+    pinnedSections: NormalizedPinnedSection[];
+    groupSections: NormalizedGroupSection[];
+    ungroupedItems: SelectFieldDownshiftItem[];
+};
+/**
+ * Assembles the flat downshiftItems array and sectionsMeta.
+ * Order: prefixItems → pinned sections → group sections → ungrouped items.
+ * Multi-select hooks pass bulk action items (select-all / select-filtered) as prefixItems;
+ * single-select hooks omit it.
+ */
+export declare function buildDownshiftItems({ prefixItems, pinnedSections, groupSections, ungroupedItems, }: BuildDownshiftItemsParams): {
+    downshiftItems: SelectFieldDownshiftItem[];
+    sectionsMeta: SectionMeta[];
+};
+export {};

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

@@ -1,3 +1,5 @@
+import { ReactElement, RefObject } from 'react';
+import { SelectFieldOption, SelectFieldProps } from '../types';
 /**
  * Metadata about list sections for rendering purposes.
  * Used by both SelectFieldList and MultiSelectFieldList to render section headers and dividers.
@@ -14,3 +16,58 @@ export type SectionMeta = {
     endIndex: number;
     loading?: boolean;
 };
+export type SelectFieldBaseInternalProps = {
+    id: string;
+    helperUid: string;
+    selectedOption: SelectFieldOption | null;
+    onSelectedOptionChange: (option: SelectFieldOption | null) => void;
+    displayAs: "popover" | "dialog";
+    isDisabledOrReadOnly: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    size?: "small" | "medium" | "large";
+    error?: boolean | string | ReactElement | string[];
+    hasHelperText: boolean;
+    disableClearButton: boolean;
+    prefix?: string | ReactElement;
+    suffix?: string | ReactElement;
+    label: string;
+    labelNode?: React.ReactNode;
+    hideLabel?: boolean;
+    hint?: ReactElement | string;
+    errorMessages?: string | ReactElement | string[];
+    warning?: string | string[];
+    description?: ReactElement | string;
+    className?: string;
+    style?: React.CSSProperties;
+    layoutStyles?: React.CSSProperties;
+    pinned?: SelectFieldProps["pinned"];
+    groupToString?: (groupValue: string | number) => string;
+    groupSorter?: (a: string | number, b: string | number) => number;
+    virtualize?: boolean;
+    options: SelectFieldOption[];
+    loading: boolean;
+    loadingMore: boolean;
+    hasMore: boolean;
+    loadOptions: (searchValue: string, opts?: {
+        initial?: boolean;
+    }) => Promise<void>;
+    loadMore: (searchValue: string) => Promise<void>;
+    initialLoad: "immediate" | "open";
+    initialLoadPerformed: boolean;
+    setInitialLoadPerformed: (val: boolean) => void;
+    inputWrapperRef: RefObject<HTMLDivElement>;
+};
+export type SelectFieldComboboxInternalProps = SelectFieldBaseInternalProps & {
+    debounceMs: number;
+};
+/**
+ * Loose prop getter types compatible with both downshift's useCombobox and useSelect.
+ * Using `any` for the return types is intentional: the actual runtime shapes are identical
+ * between the two hooks, but their compile-time generic types diverge.
+ */
+export type GetMenuPropsFn = (...args: any[]) => any;
+export type GetItemPropsFn = (...args: any[]) => any;
+export type GetLabelPropsFn = (...args: any[]) => any;

package/dist/beta/components/SelectField/internal/useCombo.d.ts

@@ -7,10 +7,6 @@ export type UseComboOptions = {
     pinned?: SelectFieldPinnedOptions;
     groupToString?: (groupValue: SelectFieldGroupByValue) => string;
     groupSorter?: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number;
-    selectAll?: {
-        label: string;
-        onClick: () => void;
-    };
     selectedOption: SelectFieldOption | null;
     onSelectedOptionChange: (option: SelectFieldOption | null) => void;
     displayAs: "popover" | "dialog";
@@ -21,7 +17,7 @@ export type UseComboOptions = {
 /**
  * The purpose of useCombo is to provide an abstraction over the downshift combobox hook.
  */
-export declare const useCombo: ({ options, pinned, groupToString, groupSorter, selectAll, selectedOption, onSelectedOptionChange, onInputValueChange, onIsOpenChange, displayAs, disableHighlightOnOpen, disabled, virtualize, }: UseComboOptions) => {
+export declare const useCombo: ({ options, pinned, groupToString, groupSorter, selectedOption, onSelectedOptionChange, onInputValueChange, onIsOpenChange, displayAs, disableHighlightOnOpen, disabled, virtualize, }: UseComboOptions) => {
     inputValue: string;
     wrapperDivRef: import('react').RefObject<HTMLDivElement>;
     getToggleButtonProps: <Options>(options?: import('downshift').UseComboboxGetToggleButtonPropsOptions & Options) => import('downshift').Overwrite<import('downshift').UseComboboxGetToggleButtonPropsReturnValue, Options>;

package/dist/beta/components/SelectField/internal/useProcessedOptions.d.ts

@@ -0,0 +1,19 @@
+import { SelectFieldGroupByValue, SelectFieldOption, SelectFieldPinnedOptions } from '../types';
+type UseProcessedOptionsParams = {
+    options: SelectFieldOption[];
+    pinned?: SelectFieldPinnedOptions;
+    searchValue: string;
+    groupToString?: (groupValue: SelectFieldGroupByValue) => string;
+    groupSorter?: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number;
+};
+/**
+ * Shared pipeline for processing options: pinned → grouped → sorted.
+ * Used by all four downshift-wrapping hooks (useCombo, useSelectMode,
+ * useComboMultiple, useSelectModeMultiple).
+ */
+export declare const useProcessedOptions: ({ options, pinned, searchValue, groupToString, groupSorter, }: UseProcessedOptionsParams) => {
+    pinnedSections: import('./usePinnedOptions').NormalizedPinnedSection[];
+    ungroupedItems: import('..').SelectFieldDownshiftItem[];
+    groupSections: import('./useGroupedOptions').NormalizedGroupSection[];
+};
+export {};

package/dist/beta/components/SelectField/internal/useSelectMode.d.ts

@@ -0,0 +1,34 @@
+import { SelectFieldDownshiftItem, SelectFieldGroupByValue, SelectFieldOption, SelectFieldPinnedOptions } from '../types';
+export type UseSelectModeOptions = {
+    options: SelectFieldOption[];
+    pinned?: SelectFieldPinnedOptions;
+    groupToString?: (groupValue: SelectFieldGroupByValue) => string;
+    groupSorter?: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number;
+    selectedOption: SelectFieldOption | null;
+    onSelectedOptionChange: (option: SelectFieldOption | null) => void;
+    onIsOpenChange?: (changes: {
+        isOpen?: boolean;
+    }) => void;
+    displayAs: "popover" | "dialog";
+    disableHighlightOnOpen?: boolean;
+    disabled: boolean;
+    virtualize?: boolean;
+};
+/**
+ * Wraps downshift's useSelect for non-searchable select fields.
+ * Returns a compatible interface to useCombo (minus getInputProps/inputValue).
+ */
+export declare const useSelectMode: ({ options, pinned, groupToString, groupSorter, selectedOption, onSelectedOptionChange, onIsOpenChange, displayAs, disableHighlightOnOpen, disabled, virtualize, }: UseSelectModeOptions) => {
+    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>;
+    getMenuProps: <Options>(options?: import('downshift').UseSelectGetMenuPropsOptions & Options, otherOptions?: import('downshift').GetPropsCommonOptions) => import('downshift').Overwrite<import('downshift').UseSelectGetMenuReturnValue, Options>;
+    getItemProps: <Options>(options: import('downshift').UseSelectGetItemPropsOptions<SelectFieldDownshiftItem> & Options) => Omit<import('downshift').Overwrite<import('downshift').UseSelectGetItemPropsReturnValue, Options>, "item" | "index">;
+    highlightedIndex: number;
+    highlightChangeTypeRef: import('react').MutableRefObject<string>;
+    isOpen: boolean;
+    downshiftItems: SelectFieldDownshiftItem[];
+    sectionsMeta: import('./types').SectionMeta[];
+    closeMenu: () => void;
+    openMenu: () => void;
+};

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

@@ -239,6 +239,13 @@ type SelectFieldCommonSelectFieldProps = {
      * @default 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
+     */
+    disableSearch?: boolean;
 } & SelectFieldSearchProps & SelectFieldAddNewOptionProps & LayoutUtilProps;
 type SelectFieldGroupingProps = {
     /**

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

@@ -1,8 +1,8 @@
 import { ComponentPropsWithoutRef, Ref } from 'react';
 import { LayoutUtilProps } from '../../../../types';
 import { ColumnDef, CustomTableFooterCellProps, TableRow } from '../types';
-import { DataTablePaginationConfig, DataTableRef } from './types';
-export type { DataTableRef };
+import { DataTableEmptyState, DataTablePaginationConfig, DataTableRef } from './types';
+export type { DataTableRef, DataTableEmptyState };
 /**
  * Represents a sorted column configuration for DataTable
  */
@@ -81,6 +81,11 @@ export type DataTableProps<T> = LayoutUtilProps & ComponentPropsWithoutRef<"div"
      * The sorted column.
      */
     sortedColumn?: SortedColumn;
+    /**
+     * Configuration for the empty state displayed when the table has no data.
+     * Only shown when data is empty and the table is not loading.
+     */
+    emptyState?: DataTableEmptyState;
 };
 declare function DataTableInner<T>(props: DataTableProps<T>, ref: Ref<DataTableRef>): import("react/jsx-runtime").JSX.Element;
 /**
@@ -99,6 +104,7 @@ declare function DataTableInner<T>(props: DataTableProps<T>, ref: Ref<DataTableR
  * - Default and Strong backgrounds
  * - Pagination support with configurable items per page
  * - Imperative refresh via ref
+ * - Customizable empty state with optional SVG illustration and content
  *
  * @param props - The props for the DataTable component
  * @param props.data - The data for the table. Must be an array of objects with an `id` property.
@@ -115,6 +121,7 @@ declare function DataTableInner<T>(props: DataTableProps<T>, ref: Ref<DataTableR
  * @param props.pagination - Pagination configuration. When provided, enables pagination and filters data to show only the current page. When undefined, all data is shown and no pagination controls are rendered.
  * @param props.selectedRowIds - The selected row ids.
  * @param props.sortedColumn - The sorted column.
+ * @param props.emptyState - Configuration for the empty state displayed when the table has no data.
  * @param props.style - The style of the table container.
  * @param props.rest - The rest of the props for the DataTable component, spread to the div surrounding the table.
  *