@servicetitan/anvil2 3.10.0 → 3.11.0

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

@@ -26,8 +26,8 @@ export type SelectFieldGroupByValue = string | number;
  * Controls the avatar, icon, description, and chip display within an option.
  */
 export type SelectFieldOptionContent = OptionContent;
-export type SelectFieldOption = {
-    id: string | number;
+export type SelectFieldOption<TID extends number | string = string | number> = {
+    id: TID;
     label: string;
     searchText?: string;
     group?: SelectFieldGroupByValue;
@@ -40,29 +40,29 @@ export type SelectFieldOption = {
     extra?: Record<string, unknown>;
     content?: SelectFieldOptionContent;
 };
-export type SelectFieldGroupedOption = SelectFieldOption & {
+export type SelectFieldGroupedOption<TID extends number | string = string | number> = SelectFieldOption<TID> & {
     group: SelectFieldGroupByValue;
 };
-export type SelectFieldUngroupedOption = Omit<SelectFieldOption, "group"> & {
+export type SelectFieldUngroupedOption<TID extends number | string = string | number> = Omit<SelectFieldOption<TID>, "group"> & {
     group?: never;
 };
-export type SelectFieldOptionsResult = SelectFieldOption[] | Promise<SelectFieldOption[]>;
-export type SelectFieldEagerLoader = (searchValue: string) => SelectFieldOptionsResult;
-export type SelectFieldOffsetLazyResult = {
-    options: SelectFieldUngroupedOption[];
+export type SelectFieldOptionsResult<TID extends number | string = string | number> = SelectFieldOption<TID>[] | Promise<SelectFieldOption<TID>[]>;
+export type SelectFieldEagerLoader<TID extends number | string = string | number> = (searchValue: string) => SelectFieldOptionsResult<TID>;
+export type SelectFieldOffsetLazyResult<TID extends number | string = string | number> = {
+    options: SelectFieldUngroupedOption<TID>[];
     hasMore?: boolean;
 };
-export type SelectFieldOffsetLazyLoader = (searchValue: string, offset: number, limit: number) => SelectFieldOffsetLazyResult | Promise<SelectFieldOffsetLazyResult>;
-export type SelectFieldPageLazyResult = {
-    options: SelectFieldUngroupedOption[];
+export type SelectFieldOffsetLazyLoader<TID extends number | string = string | number> = (searchValue: string, offset: number, limit: number) => SelectFieldOffsetLazyResult<TID> | Promise<SelectFieldOffsetLazyResult<TID>>;
+export type SelectFieldPageLazyResult<TID extends number | string = string | number> = {
+    options: SelectFieldUngroupedOption<TID>[];
     hasMore?: boolean;
 };
-export type SelectFieldPageLazyLoader = (searchValue: string, pageNumber: number, pageSize: number) => SelectFieldPageLazyResult | Promise<SelectFieldPageLazyResult>;
-export type SelectFieldGroupLazyResult = {
-    options: SelectFieldGroupedOption[];
+export type SelectFieldPageLazyLoader<TID extends number | string = string | number> = (searchValue: string, pageNumber: number, pageSize: number) => SelectFieldPageLazyResult<TID> | Promise<SelectFieldPageLazyResult<TID>>;
+export type SelectFieldGroupLazyResult<TID extends number | string = string | number> = {
+    options: SelectFieldGroupedOption<TID>[];
     hasMore?: boolean;
 };
-export type SelectFieldGroupLazyLoader = (searchValue: string, previousGroupKey: SelectFieldGroupByValue | null) => SelectFieldGroupLazyResult | Promise<SelectFieldGroupLazyResult>;
+export type SelectFieldGroupLazyLoader<TID extends number | string = string | number> = (searchValue: string, previousGroupKey: SelectFieldGroupByValue | null) => SelectFieldGroupLazyResult<TID> | Promise<SelectFieldGroupLazyResult<TID>>;
 export type SelectFieldSearchProps = {
     /**
      * The current search value.
@@ -94,8 +94,8 @@ type SelectFieldAddNewOptionProps = {
         renderDialogContent: (searchValue: string) => React.ReactNode;
     };
 };
-export type SelectFieldPinnedOptionsSection = {
-    options: SelectFieldOption[] | ((searchValue: string) => SelectFieldOption[] | Promise<SelectFieldOption[]>);
+export type SelectFieldPinnedOptionsSection<TID extends number | string = string | number> = {
+    options: SelectFieldOption<TID>[] | ((searchValue: string) => SelectFieldOption<TID>[] | Promise<SelectFieldOption<TID>[]>);
     label: string;
     /**
      * Whether to re-call the loader when search value changes.
@@ -117,8 +117,8 @@ export type SelectFieldPinnedOptionsSection = {
  * 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": [...]}])
  */
-export type SelectFieldPinnedOptions = SelectFieldPinnedOptionsSection | SelectFieldPinnedOptionsSection[];
-type SelectFieldCommonSelectFieldProps = {
+export type SelectFieldPinnedOptions<TID extends number | string = string | number> = SelectFieldPinnedOptionsSection<TID> | SelectFieldPinnedOptionsSection<TID>[];
+type SelectFieldCommonSelectFieldProps<TID extends number | string = string | number> = {
     /**
      * The id of the select field.
      */
@@ -138,12 +138,12 @@ type SelectFieldCommonSelectFieldProps = {
     /**
      * The value of the select field. Must be controlled state.
      */
-    value: SelectFieldOption | null;
+    value: SelectFieldOption<TID> | null;
     /**
      * The callback to call when an item is clicked.
      * @param option - The option that was selected.
      */
-    onSelectedOptionChange: (option: SelectFieldOption | null) => void;
+    onSelectedOptionChange: (option: SelectFieldOption<TID> | null) => void;
     /**
      * Defines the initial loading behavior of the options. Controls when loadOptions is called.
      * @default "auto"
@@ -155,7 +155,7 @@ type SelectFieldCommonSelectFieldProps = {
     /**
      * The options to pin to the top of the list.
      */
-    pinned?: SelectFieldPinnedOptions;
+    pinned?: SelectFieldPinnedOptions<TID>;
     /**
      * Whether to disable the clear button.
      * @default false
@@ -286,7 +286,7 @@ type SelectFieldNonGroupingProps = {
      */
     groupSorter?: never;
 };
-export type SelectFieldPropsLazyPage = SelectFieldCommonSelectFieldProps & {
+export type SelectFieldPropsLazyPage<TID extends number | string = string | number> = SelectFieldCommonSelectFieldProps<TID> & {
     /**
      * Lazy loading mode using page-based pagination.
      * Options will be loaded on demand when the user scrolls to the bottom of the list.
@@ -299,9 +299,9 @@ export type SelectFieldPropsLazyPage = SelectFieldCommonSelectFieldProps & {
     /**
      * Function to load the options.
      */
-    loadOptions: SelectFieldPageLazyLoader;
+    loadOptions: SelectFieldPageLazyLoader<TID>;
 } & SelectFieldNonGroupingProps;
-export type SelectFieldPropsLazyOffset = SelectFieldCommonSelectFieldProps & {
+export type SelectFieldPropsLazyOffset<TID extends number | string = string | number> = SelectFieldCommonSelectFieldProps<TID> & {
     /**
      * Lazy loading mode using offset-based pagination.
      * Options will be loaded on demand when the user scrolls to the bottom of the list.
@@ -314,9 +314,9 @@ export type SelectFieldPropsLazyOffset = SelectFieldCommonSelectFieldProps & {
     /**
      * Function to load the options.
      */
-    loadOptions: SelectFieldOffsetLazyLoader;
+    loadOptions: SelectFieldOffsetLazyLoader<TID>;
 } & SelectFieldNonGroupingProps;
-export type SelectFieldPropsLazyGroup = SelectFieldCommonSelectFieldProps & {
+export type SelectFieldPropsLazyGroup<TID extends number | string = string | number> = SelectFieldCommonSelectFieldProps<TID> & {
     /**
      * Lazy loading mode using incremental group loading.
      * Groups will be loaded on demand when the user scrolls to the bottom of the list.
@@ -327,9 +327,9 @@ export type SelectFieldPropsLazyGroup = SelectFieldCommonSelectFieldProps & {
     /**
      * Function to load the options.
      */
-    loadOptions: SelectFieldGroupLazyLoader;
+    loadOptions: SelectFieldGroupLazyLoader<TID>;
 } & SelectFieldGroupingProps;
-export type SelectFieldPropsEager = SelectFieldCommonSelectFieldProps & {
+export type SelectFieldPropsEager<TID extends number | string = string | number> = SelectFieldCommonSelectFieldProps<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
@@ -338,8 +338,8 @@ export type SelectFieldPropsEager = SelectFieldCommonSelectFieldProps & {
     /**
      * Function to load the options.
      */
-    loadOptions: SelectFieldEagerLoader;
+    loadOptions: SelectFieldEagerLoader<TID>;
 } & SelectFieldGroupingProps;
-export type SelectFieldPropsLazy = SelectFieldPropsLazyPage | SelectFieldPropsLazyOffset | SelectFieldPropsLazyGroup;
-export type SelectFieldProps = SelectFieldPropsLazy | SelectFieldPropsEager;
+export type SelectFieldPropsLazy<TID extends number | string = string | number> = SelectFieldPropsLazyPage<TID> | SelectFieldPropsLazyOffset<TID> | SelectFieldPropsLazyGroup<TID>;
+export type SelectFieldProps<TID extends number | string = string | number> = SelectFieldPropsLazy<TID> | SelectFieldPropsEager<TID>;
 export {};

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

@@ -20,6 +20,13 @@ export type TextProps = HeadlineProps<"h1"> | HeadlineProps<"h2"> | HeadlineProp
  * <Text variant="headline" el="h2" size="medium">Sub Heading</Text>
  *
  * @example
+ * // Drop the trailing margin when aligning a headline against a sibling
+ * <Flex alignItems="center" gap="2">
+ *   <Text variant="headline" el="h2" noMargin>Invoices</Text>
+ *   <Chip>Draft</Chip>
+ * </Flex>
+ *
+ * @example
  * <Text variant="eyebrow" size="small">Category Label</Text>
  *
  * @example

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

@@ -25,6 +25,13 @@ export type HeadlineProps<T extends "h1" | "h2" | "h3" | "h4" | "h5" | "h6"> = C
      * Use `true` for the sparkle only, or pass tooltip/popover configuration.
      */
     aiMark?: boolean | AiMarkWithTooltipOrPopoverConfig;
+    /**
+     * Removes the headline's bottom margin so its layout box hugs the text.
+     * Use when the headline is aligned against a sibling element, such as a
+     * Chip or Badge, where the trailing margin would offset the alignment.
+     * @default false
+     */
+    noMargin?: boolean;
     inline?: never;
     subdued?: never;
 };
@@ -47,6 +54,7 @@ export type EyebrowProps = ComponentPropsWithoutRef<"span"> & LayoutUtilProps &
     inline?: never;
     subdued?: never;
     aiMark?: never;
+    noMargin?: never;
 };
 /**
  * Props for body text variant
@@ -72,6 +80,7 @@ export type BodyTextProps = ComponentPropsWithoutRef<"p"> & LayoutUtilProps & {
     inline?: never;
     el?: never;
     aiMark?: never;
+    noMargin?: never;
 };
 /**
  * Props for inline body text variant
@@ -99,4 +108,5 @@ export type BodyTextInlineProps = ComponentPropsWithoutRef<"span"> & LayoutUtilP
     subdued?: boolean;
     el?: never;
     aiMark?: never;
+    noMargin?: never;
 };

package/dist/src/internal/functions/buildSelectItems.d.ts

@@ -2,12 +2,12 @@ import { SelectFieldOption } from '../../components/SelectField/types';
 import { SectionMeta, SelectItem } from '../types/selectFieldInternalTypes';
 import { NormalizedPinnedSection } from '../hooks/usePinnedOptions';
 import { NormalizedGroupSection } from '../hooks/useGroupedOptions';
-export declare function toSelectItem(option: SelectFieldOption): SelectItem;
-type BuildSelectItemsParams = {
+export declare function toSelectItem<TID extends string | number>(option: SelectFieldOption<TID>): SelectItem<TID>;
+type BuildSelectItemsParams<TID extends string | number> = {
     prefixItems?: SelectItem[];
-    pinnedSections: NormalizedPinnedSection[];
-    groupSections: NormalizedGroupSection[];
-    ungroupedItems: SelectItem[];
+    pinnedSections: NormalizedPinnedSection<TID>[];
+    groupSections: NormalizedGroupSection<TID>[];
+    ungroupedItems: SelectItem<TID>[];
 };
 /**
  * Assembles the flat items array and sectionsMeta.
@@ -15,8 +15,8 @@ type BuildSelectItemsParams = {
  * Multi-select hooks pass bulk action items (select-all / select-filtered) as prefixItems;
  * single-select hooks omit it.
  */
-export declare function buildSelectItems({ prefixItems, pinnedSections, groupSections, ungroupedItems, }: BuildSelectItemsParams): {
-    items: SelectItem[];
+export declare function buildSelectItems<TID extends string | number>({ prefixItems, pinnedSections, groupSections, ungroupedItems, }: BuildSelectItemsParams<TID>): {
+    items: SelectItem<TID>[];
     sectionsMeta: SectionMeta[];
 };
 export {};

package/dist/src/internal/functions/syncFilterUtils.d.ts

@@ -1,10 +1,10 @@
 import { MatchSorterOptions } from 'match-sorter';
 import { SelectFieldOption, SelectFieldGroupByValue } from '../../components/SelectField/types';
-export type SyncFilterFn<T extends SelectFieldOption = SelectFieldOption> = (options: T[], searchValue: string) => T[];
-export declare const defaultSyncFilter: SyncFilterFn;
-export declare const toSyncFilterFn: <T extends SelectFieldOption = SelectFieldOption>(filter: SyncFilterFn<T> | MatchSorterOptions<T>) => SyncFilterFn<T>;
+export type SyncFilterFn<TID extends string | number = string | number, T extends SelectFieldOption<TID> = SelectFieldOption<TID>> = (options: T[], searchValue: string) => T[];
+export declare const defaultSyncFilter: <TID extends string | number, T extends SelectFieldOption<TID> = SelectFieldOption<TID>>(options: T[], searchValue: string) => T[];
+export declare const toSyncFilterFn: <TID extends string | number, T extends SelectFieldOption<TID> = SelectFieldOption<TID>>(filter: SyncFilterFn<TID, T> | MatchSorterOptions<T>) => SyncFilterFn<TID, T>;
 /**
  * Sorts options by group using the provided comparator while maintaining
  * the original order within each group (stable sort).
  */
-export declare const sortByGroup: <T extends SelectFieldOption = SelectFieldOption>(options: T[], groupSorter: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number) => T[];
+export declare const sortByGroup: <TID extends string | number, T extends SelectFieldOption<TID> = SelectFieldOption<TID>>(options: T[], groupSorter: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number) => T[];

package/dist/src/internal/hooks/useGroupedOptions.d.ts

@@ -5,17 +5,17 @@ import { SelectItem } from '../types/selectFieldInternalTypes';
  * @property label - The group label (derived from groupToString or String(groupValue))
  * @property options - The options belonging to this group
  */
-export type NormalizedGroupSection = {
+export type NormalizedGroupSection<TID extends string | number> = {
     label: string;
-    options: SelectFieldOption[];
+    options: SelectFieldOption<TID>[];
 };
-type UseGroupedOptionsResult = {
+type UseGroupedOptionsResult<TID extends string | number> = {
     /** Options that have a group property, converted to downshift items */
-    groupedItems: SelectItem[];
+    groupedItems: SelectItem<TID>[];
     /** Options that don't have a group property, converted to downshift items */
-    ungroupedItems: SelectItem[];
+    ungroupedItems: SelectItem<TID>[];
     /** Metadata about each group section for rendering */
-    groupSections: NormalizedGroupSection[];
+    groupSections: NormalizedGroupSection<TID>[];
 };
 /**
  * Hook that processes options and groups them by their `group` property.
@@ -27,7 +27,7 @@ type UseGroupedOptionsResult = {
  * @param groupToString - Optional function to convert group values to display labels
  * @returns Grouped items, ungrouped items, and group section metadata
  */
-export declare function useGroupedOptions(options: SelectFieldOption[], groupToString?: (groupValue: SelectFieldGroupByValue) => string): UseGroupedOptionsResult;
+export declare function useGroupedOptions<TID extends string | number>(options: SelectFieldOption<TID>[], groupToString?: (groupValue: SelectFieldGroupByValue) => string): UseGroupedOptionsResult<TID>;
 /**
  * Sorts group sections using the provided comparator function.
  * The group value is extracted from the first option in each section.
@@ -36,5 +36,5 @@ export declare function useGroupedOptions(options: SelectFieldOption[], groupToS
  * @param groupSorter - Comparator function for group values
  * @returns A new array of sorted sections
  */
-export declare function sortGroupSections(sections: NormalizedGroupSection[], groupSorter: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number): NormalizedGroupSection[];
+export declare function sortGroupSections<TID extends string | number>(sections: NormalizedGroupSection<TID>[], groupSorter: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number): NormalizedGroupSection<TID>[];
 export {};

package/dist/src/internal/hooks/usePinnedOptions.d.ts

@@ -5,13 +5,13 @@ import { SelectFieldOption, SelectFieldPinnedOptions } from '../../components/Se
  * @property options - The pinned options for this section
  * @property loading - Whether this section is still loading its options
  */
-export type NormalizedPinnedSection = {
+export type NormalizedPinnedSection<TID extends string | number> = {
     label: string;
-    options: SelectFieldOption[];
+    options: SelectFieldOption<TID>[];
     loading?: boolean;
 };
-type UsePinnedOptionsResult = {
-    pinnedSections: NormalizedPinnedSection[];
+type UsePinnedOptionsResult<TID extends string | number> = {
+    pinnedSections: NormalizedPinnedSection<TID>[];
 };
 /**
  * Hook that normalizes and loads pinned options from various input formats.
@@ -33,5 +33,5 @@ type UsePinnedOptionsResult = {
  * @param searchValue - Current search input value
  * @returns Normalized pinned sections with per-section loading state
  */
-export declare function usePinnedOptions(pinned: SelectFieldPinnedOptions | undefined, searchValue: string): UsePinnedOptionsResult;
+export declare function usePinnedOptions<TID extends string | number>(pinned: SelectFieldPinnedOptions<TID> | undefined, searchValue: string): UsePinnedOptionsResult<TID>;
 export {};

package/dist/src/internal/hooks/useProcessedOptions.d.ts

@@ -1,7 +1,7 @@
 import { SelectFieldGroupByValue, SelectFieldOption, SelectFieldPinnedOptions } from '../../components/SelectField/types';
-type UseProcessedOptionsParams = {
-    options: SelectFieldOption[];
-    pinned?: SelectFieldPinnedOptions;
+type UseProcessedOptionsParams<TID extends string | number> = {
+    options: SelectFieldOption<TID>[];
+    pinned?: SelectFieldPinnedOptions<TID>;
     searchValue: string;
     groupToString?: (groupValue: SelectFieldGroupByValue) => string;
     groupSorter?: (a: SelectFieldGroupByValue, b: SelectFieldGroupByValue) => number;
@@ -11,9 +11,9 @@ type UseProcessedOptionsParams = {
  * 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('../types/selectFieldInternalTypes').SelectItem[];
-    groupSections: import('./useGroupedOptions').NormalizedGroupSection[];
+export declare const useProcessedOptions: <TID extends string | number>({ options, pinned, searchValue, groupToString, groupSorter, }: UseProcessedOptionsParams<TID>) => {
+    pinnedSections: import('./usePinnedOptions').NormalizedPinnedSection<TID>[];
+    ungroupedItems: import('../types/selectFieldInternalTypes').SelectItem<TID>[];
+    groupSections: import('./useGroupedOptions').NormalizedGroupSection<TID>[];
 };
 export {};

package/dist/src/internal/hooks/useSelectFieldLoading/useSelectFieldLoading.d.ts

@@ -17,26 +17,26 @@ export type CacheConfig = {
      */
     maxSize?: number;
 };
-type UseSelectFieldLoadingConfigLazyPage = Pick<SelectFieldPropsLazyPage, "lazy" | "loadOptions"> & {
+type UseSelectFieldLoadingConfigLazyPage<TID extends string | number> = Pick<SelectFieldPropsLazyPage<TID>, "lazy" | "loadOptions"> & {
     pageSize: number;
     cache?: CacheConfig;
 };
-type UseSelectFieldLoadingConfigLazyOffset = Pick<SelectFieldPropsLazyOffset, "lazy" | "loadOptions"> & {
+type UseSelectFieldLoadingConfigLazyOffset<TID extends string | number> = Pick<SelectFieldPropsLazyOffset<TID>, "lazy" | "loadOptions"> & {
     limit: number;
     cache?: CacheConfig;
 };
-type UseSelectFieldLoadingConfigLazyGroup = Pick<SelectFieldPropsLazyGroup, "lazy" | "loadOptions"> & {
+type UseSelectFieldLoadingConfigLazyGroup<TID extends string | number> = Pick<SelectFieldPropsLazyGroup<TID>, "lazy" | "loadOptions"> & {
     cache?: CacheConfig;
 };
-type UseSelectFieldLoadingConfigEager = Pick<SelectFieldPropsEager, "lazy" | "loadOptions"> & {
+type UseSelectFieldLoadingConfigEager<TID extends string | number> = Pick<SelectFieldPropsEager<TID>, "lazy" | "loadOptions"> & {
     cache?: CacheConfig;
 };
-export type UseSelectFieldLoadingConfig = UseSelectFieldLoadingConfigLazyPage | UseSelectFieldLoadingConfigLazyOffset | UseSelectFieldLoadingConfigLazyGroup | UseSelectFieldLoadingConfigEager;
-export type UseSelectFieldLoadingReturn = {
+export type UseSelectFieldLoadingConfig<TID extends string | number> = UseSelectFieldLoadingConfigLazyPage<TID> | UseSelectFieldLoadingConfigLazyOffset<TID> | UseSelectFieldLoadingConfigLazyGroup<TID> | UseSelectFieldLoadingConfigEager<TID>;
+export type UseSelectFieldLoadingReturn<TID extends string | number> = {
     /**
      * Current loaded options array
      */
-    options: SelectFieldOption[];
+    options: SelectFieldOption<TID>[];
     /**
      * Boolean indicating initial load in progress
      */
@@ -98,5 +98,5 @@ export type UseSelectFieldLoadingReturn = {
  *   pageSize: 10
  * });
  */
-export declare function useSelectFieldLoading(config: UseSelectFieldLoadingConfig): UseSelectFieldLoadingReturn;
+export declare function useSelectFieldLoading<TID extends string | number>(config: UseSelectFieldLoadingConfig<TID>): UseSelectFieldLoadingReturn<TID>;
 export {};

package/dist/src/internal/hooks/useSelectOrchestration.d.ts

@@ -22,12 +22,12 @@ export type UseSelectOrchestrationConfig = {
  * Centralizes adaptive view resolution, loading config construction, option loading lifecycle,
  * and imperative handle setup (clearCache/invalidate).
  */
-export declare function useSelectOrchestration(config: UseSelectOrchestrationConfig): {
+export declare function useSelectOrchestration<TID extends string | number>(config: UseSelectOrchestrationConfig): {
     displayAs: "dialog" | "popover";
     initialLoad: "open" | "immediate";
     initialLoadPerformed: boolean;
     setInitialLoadPerformed: import('react').Dispatch<import('react').SetStateAction<boolean>>;
-    options: import('../..').SelectFieldOption[];
+    options: import('../..').SelectFieldOption<TID>[];
     loading: boolean;
     loadingMore: boolean;
     hasMore: boolean;

package/dist/src/internal/hooks/useToggleSelection.d.ts

@@ -1,21 +1,21 @@
 import { SelectFieldOption } from '../../components/SelectField/types';
 import { NormalizedPinnedSection } from './usePinnedOptions';
-type UseToggleSelectionParams = {
-    options: SelectFieldOption[];
-    pinnedSections: NormalizedPinnedSection[];
-    selectedOptions: SelectFieldOption[];
-    onSelectedOptionsChange: (options: SelectFieldOption[]) => void;
+type UseToggleSelectionParams<TID extends string | number> = {
+    options: SelectFieldOption<TID>[];
+    pinnedSections: NormalizedPinnedSection<TID>[];
+    selectedOptions: SelectFieldOption<TID>[];
+    onSelectedOptionsChange: (options: SelectFieldOption<TID>[]) => 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) => {
+export declare const useToggleSelection: <TID extends string | number>({ options, pinnedSections, selectedOptions, onSelectedOptionsChange, }: UseToggleSelectionParams<TID>) => {
     handleItemClick: (option: {
-        id: string | number;
+        id: TID;
         label: string;
     }) => void;
-    allPinnedOptions: SelectFieldOption[];
+    allPinnedOptions: SelectFieldOption<TID>[];
 };
 export {};

package/dist/src/internal/types/bulkActionTypes.d.ts

@@ -12,13 +12,13 @@ import { SelectFieldOption } from '../../components/SelectField/types';
  * `unchecked` when none is. This is the async equivalent of the automatic
  * check-state behavior the `*Sync` variants provide.
  */
-export type BulkActionCheckState = boolean | CheckState | ((current: SelectFieldOption[]) => boolean | CheckState);
+export type BulkActionCheckState<TID extends string | number = string | number> = boolean | CheckState | ((current: SelectFieldOption<TID>[]) => boolean | CheckState);
 /**
  * Label for a "Select All" / "Select Filtered" row. A function form is
  * resolved against the live selection (the confirmation draft when
  * confirmation is enabled, otherwise the committed value).
  */
-export type BulkActionLabel = string | ((current: SelectFieldOption[]) => string);
+export type BulkActionLabel<TID extends string | number = string | number> = string | ((current: SelectFieldOption<TID>[]) => string);
 /**
  * Configuration for the "Select All" / "Select Filtered" rows in a
  * MultiSelectMenu or MultiSelectField.
@@ -39,26 +39,26 @@ export type BulkActionLabel = string | ((current: SelectFieldOption[]) => string
  * `CheckState`) or a function that derives the state from the current
  * selection, so the row's checkbox can reflect how much of the set is selected.
  */
-export type BulkActionConfig = {
-    label?: BulkActionLabel;
-    checkState: BulkActionCheckState;
+export type BulkActionConfig<TID extends string | number> = {
+    label?: BulkActionLabel<TID>;
+    checkState: BulkActionCheckState<TID>;
     onClick: () => void;
     compute?: never;
 } | {
-    label?: BulkActionLabel;
-    checkState: BulkActionCheckState;
-    compute: (current: SelectFieldOption[]) => SelectFieldOption[] | Promise<SelectFieldOption[]>;
+    label?: BulkActionLabel<TID>;
+    checkState: BulkActionCheckState<TID>;
+    compute: (current: SelectFieldOption<TID>[]) => SelectFieldOption<TID>[] | Promise<SelectFieldOption<TID>[]>;
     onClick?: never;
 };
 /**
  * Normalized form used internally after `checkState`'s `boolean` shorthand has
  * been resolved to a `CheckState`.
  */
-export type ResolvedBulkAction = {
+export type ResolvedBulkAction<TID extends string | number = string | number> = {
     label?: string;
     checkState: CheckState;
     onClick?: () => void;
-    compute?: (current: SelectFieldOption[]) => SelectFieldOption[] | Promise<SelectFieldOption[]>;
+    compute?: (current: SelectFieldOption<TID>[]) => SelectFieldOption<TID>[] | Promise<SelectFieldOption<TID>[]>;
 };
 /**
  * Resolves a `BulkActionCheckState` into a concrete `CheckState`.
@@ -67,8 +67,8 @@ export type ResolvedBulkAction = {
  * The `boolean` shorthand maps `true → "checked"` and `false → "unchecked"`;
  * a `CheckState` is passed through, defaulting to `"indeterminate"`.
  */
-export declare function resolveBulkActionCheckState(checkState: BulkActionCheckState, current: SelectFieldOption[]): CheckState;
+export declare function resolveBulkActionCheckState<TID extends string | number>(checkState: BulkActionCheckState<TID>, current: SelectFieldOption<TID>[]): CheckState;
 /**
  * Resolves a `BulkActionLabel` into a display string.
  */
-export declare function resolveBulkActionLabel(label: BulkActionLabel | undefined, current: SelectFieldOption[], fallback?: string): string;
+export declare function resolveBulkActionLabel<TID extends string | number>(label: BulkActionLabel<TID> | undefined, current: SelectFieldOption<TID>[], fallback?: string): string;

package/dist/src/internal/types/selectFieldInternalTypes.d.ts

@@ -19,11 +19,11 @@ export type SectionMeta = {
     endIndex: number;
     loading?: boolean;
 };
-export type SelectFieldBaseInternalProps = {
+export type SelectFieldBaseInternalProps<TID extends string | number> = {
     id: string;
     helperUid: string;
-    selectedOption: SelectFieldOption | null;
-    onSelectedOptionChange: (option: SelectFieldOption | null) => void;
+    selectedOption: SelectFieldOption<TID> | null;
+    onSelectedOptionChange: (option: SelectFieldOption<TID> | null) => void;
     displayAs: "popover" | "dialog";
     isDisabledOrReadOnly: boolean;
     disabled?: boolean;
@@ -49,11 +49,11 @@ export type SelectFieldBaseInternalProps = {
     className?: string;
     style?: React.CSSProperties;
     layoutStyles?: React.CSSProperties;
-    pinned?: SelectFieldProps["pinned"];
+    pinned?: SelectFieldProps<TID>["pinned"];
     groupToString?: (groupValue: string | number) => string;
     groupSorter?: (a: string | number, b: string | number) => number;
     virtualize?: boolean;
-    options: SelectFieldOption[];
+    options: SelectFieldOption<TID>[];
     loading: boolean;
     loadingMore: boolean;
     hasMore: boolean;
@@ -69,7 +69,7 @@ export type SelectFieldBaseInternalProps = {
     /** Consumer-supplied `data-*` attributes forwarded to the field wrapper. */
     dataAttributes?: DataAttributes;
 } & AddNewItemProps;
-export type SelectFieldComboboxInternalProps = SelectFieldBaseInternalProps & {
+export type SelectFieldComboboxInternalProps<TID extends string | number> = SelectFieldBaseInternalProps<TID> & {
     debounceMs: number;
 };
 /**
@@ -80,10 +80,10 @@ export type SelectFieldComboboxInternalProps = SelectFieldBaseInternalProps & {
 export type GetMenuPropsFn = (...args: any[]) => any;
 export type GetItemPropsFn = (...args: any[]) => any;
 export type GetLabelPropsFn = (...args: any[]) => any;
-export type SelectItem = {
+export type SelectItem<TID extends string | number = string | number> = {
     id: string | number;
     type: "option" | "pinned-option" | "grouped-option" | "select-all" | "select-filtered";
-    original: SelectFieldOption;
+    original: SelectFieldOption<TID>;
     disabled?: boolean;
     checkState?: CheckState;
 };