@servicetitan/anvil2 3.13.7 → 3.14.0

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

@@ -1,65 +1,18 @@
 export interface UsePlatformReturnValue {
-    /** True if the user is on an iPhone */
     isIPhone: boolean;
-    /** True if the user is on an iPad */
     isIPad: boolean;
-    /** True if the user is on any iOS device (iPhone or iPad) */
     isIOS: boolean;
-    /** True if the user is on a Mac computer */
     isMac: boolean;
-    /** True if the user is on any Apple device (iPhone, iPad, or Mac) */
     isAppleDevice: boolean;
-    /** True if the browser is WebKit-based (Safari, Chrome, etc.) */
     isWebKit: boolean;
-    /** True if the browser is Chrome */
     isChrome: boolean;
-    /** True if the browser is Firefox */
     isFirefox: boolean;
-    /** True if the user is on an Android device */
     isAndroid: boolean;
 }
 /**
- * Custom hook for detecting the user's platform and browser.
- *
- * This hook provides platform and browser detection capabilities for implementing
- * platform-specific behavior in components. It detects:
- * - iOS devices (iPhone, iPad)
- * - macOS computers
- * - Android devices
- * - WebKit-based browsers (Safari, Chrome)
- * - Specific browsers (Chrome, Firefox)
- *
- * @internal This hook is not exported because it hasn't been rigorously tested.
- *
- * @returns Object containing boolean flags for different platforms and browsers
- *
- * @example
- * const {
- *   isIPhone,
- *   isIPad,
- *   isIOS,
- *   isMac,
- *   isAppleDevice,
- *   isWebKit,
- *   isChrome,
- *   isFirefox,
- *   isAndroid
- * } = usePlatform();
- *
- * if (isIOS) {
- *   // Handle iOS-specific logic
- * }
+ * Platform flags from {@link detectPlatform}. First render matches that helper
+ * (all false without `window`); an effect re-runs it after mount.
  */
 export declare function usePlatform(): UsePlatformReturnValue;
-/**
- * Detects the current platform and browser based on user agent and platform information.
- *
- * This function analyzes the navigator.userAgent and navigator.platform to determine
- * the user's device type and browser. It handles edge cases like:
- * - MSStream detection for Windows Phone
- * - iPad detection using maxTouchPoints
- * - WebKit vs Chrome differentiation
- *
- * @returns Object containing boolean flags for different platforms and browsers
- */
+/** Without `window`/`navigator`, every flag is false. */
 export declare function detectPlatform(): UsePlatformReturnValue;

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

@@ -1 +1,5 @@
+/**
+ * Keeps content visible after close so the mounted popover does not appear
+ * empty during its closing delay. Defaults to 300 ms.
+ */
 export declare const usePopoverCloseDelayWorkaround: (popoverOpen: boolean, delay?: number) => boolean;

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

@@ -1,25 +1,5 @@
 import { OpenCloseTransitionStateEffects } from '../useOpenCloseTransitionStates';
 /**
- * Effects configuration for dialog transition states
- * @property {() => void} [onOpenAnimationStart] - Callback when opening animation starts
- * @property {() => void} [onCloseAnimationStart] - Callback when closing animation starts
- * @property {() => void} [onOpenAnimationComplete] - Callback when opening animation completes
- * @property {() => void} [onCloseAnimationComplete] - Callback when closing animation completes
- */
-/**
- * Custom hook for managing popover transition states and animations.
- *
- * Features:
- * - Manages popover open/close transition states
- * - Handles animation timing based on CSS animation duration
- * - Provides callbacks for animation lifecycle events
- * - Supports controlled popover state management
- * - Automatically handles showPopover() and closePopover() calls
- * - Provides utility flags for open/closed states
- *
- * @param popover - The popover element
- * @param openProp - The open prop controlling popover visibility
- * @param options - Additional, optional options including callbacks for animation start, complete, and initialization
- * @returns Object containing popover state, control functions, and utility flags
+ * Times open/close transition state from the popover's CSS animation duration.
  */
 export declare const usePopoverTransitionStates: (popover: HTMLElement | undefined, openProp: boolean | undefined, options?: OpenCloseTransitionStateEffects) => import('..').OpenCloseTransitionState;

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

@@ -1 +1,2 @@
+/** Value from the previous render. First render is `initialValue`, or `undefined`. */
 export declare function usePrevious<T>(value: T, initialValue?: T): T | undefined;

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

@@ -7,9 +7,8 @@ type UseProcessedOptionsParams<TID extends string | number> = {
     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).
+ * Combines pinned-option loading with grouped and ungrouped option
+ * normalization, then optionally sorts the groups.
  */
 export declare const useProcessedOptions: <TID extends string | number>({ options, pinned, searchValue, groupToString, groupSorter, }: UseProcessedOptionsParams<TID>) => {
     pinnedSections: import('./usePinnedOptions').NormalizedPinnedSection<TID>[];

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

@@ -1,20 +1,12 @@
 import { SelectFieldOption, SelectFieldPropsLazyPage, SelectFieldPropsLazyOffset, SelectFieldPropsLazyGroup, SelectFieldPropsEager } from '../../../components/SelectField/types';
 export declare const DEFAULT_PAGE_SIZE = 20;
 /**
- * Configuration for caching search results in useSelectFieldLoading.
- * When enabled, the full accumulated state (options, pagination cursor, hasMore)
- * is cached per search value, allowing instant restoration when returning to
- * a previous search.
+ * Cache policy for per-search snapshots. Stays on unless `enabled` is `false`.
  */
 export type CacheConfig = {
-    /**
-     * Whether caching is enabled. Defaults to true.
-     */
+    /** Off only when `false`. Defaults to on. */
     enabled?: boolean;
-    /**
-     * Maximum number of search values to cache before clearing.
-     * Defaults to 15.
-     */
+    /** Distinct search keys kept. Exceeding this wipes the map. Defaults to `15`. */
     maxSize?: number;
 };
 type UseSelectFieldLoadingConfigLazyPage<TID extends string | number> = Pick<SelectFieldPropsLazyPage<TID>, "lazy" | "loadOptions"> & {
@@ -31,72 +23,37 @@ type UseSelectFieldLoadingConfigLazyGroup<TID extends string | number> = Pick<Se
 type UseSelectFieldLoadingConfigEager<TID extends string | number> = Pick<SelectFieldPropsEager<TID>, "lazy" | "loadOptions"> & {
     cache?: CacheConfig;
 };
+/**
+ * Discriminated by `lazy`: omitted/`false` is eager; `"page"` needs `pageSize`;
+ * `"offset"` needs `limit`; `"group"` pages by option `group`.
+ */
 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
-     */
+    /** Replaced on `{ initial: true }`; appended on load-more. Empty until the first load. */
     options: SelectFieldOption<TID>[];
-    /**
-     * Boolean indicating initial load in progress
-     */
+    /** True only while an initial fetch is in flight. Sync eager loads skip this. */
     loading: boolean;
-    /**
-     * Boolean indicating load more in progress
-     */
+    /** True while a continuation fetch is in flight. */
     loadingMore: boolean;
-    /**
-     * Boolean indicating if more options are available
-     */
+    /** From the last lazy result; stays `false` in eager mode. */
     hasMore: boolean;
     /**
-     * Function to load options. When initial is true, replaces options and sets loading state.
-     * When initial is false or undefined, appends options and sets loadingMore state.
-     * @param searchValue - The search value to load options for
-     * @param options - Optional configuration
-     * @param options.initial - Whether this is an initial load (replaces options) or continuation (appends options)
+     * `{ initial: true }` replaces options (or restores a cache hit). Otherwise
+     * appends.
      */
     loadOptions: (searchValue: string, options?: {
         initial?: boolean;
     }) => Promise<void>;
-    /**
-     * Function to load more options (for pagination). Appends to existing options.
-     * @param searchValue - The search value to load more options for
-     */
+    /** Same as `loadOptions(searchValue, { initial: false })`. */
     loadMore: (searchValue: string) => Promise<void>;
-    /**
-     * Function to reset all state to initial values
-     */
+    /** Clears options, pagination, and busy flags. Does not call `clearCache`. */
     reset: () => void;
-    /**
-     * Function to clear the search results cache
-     */
+    /** Drops cached searches. In-memory options stay. */
     clearCache: () => void;
 };
 /**
- * Custom hook for managing SelectField option loading state and logic.
- *
- * Features:
- * - Manages option loading state (loading, loadingMore, hasMore)
- * - Supports eager loading and three lazy loading modes (page, offset, group)
- * - Handles pagination state tracking for lazy loading
- * - Provides methods to load options (initial or continuation) and load more
- * - Automatically manages option replacement vs appending based on load type
- * - Tracks pagination state (page, offset, group) for lazy loading modes
- * - Provides reset functionality to clear all state
- *
- * @param config - Configuration object containing lazy mode, loadOptions function, and pagination settings
- * @returns Object containing options, loading states, and load functions
- *
- * @example
- * const { options, loading, loadingMore, hasMore, loadOptions, loadMore } = useSelectFieldLoading({
- *   lazy: "page",
- *   loadOptions: async (searchValue, page, pageSize) => {
- *     const result = await fetchOptions(searchValue, page, pageSize);
- *     return { options: result.items, hasMore: result.hasMore };
- *   },
- *   pageSize: 10
- * });
+ * Loads SelectField options for eager or lazy (`page` / `offset` / `group`)
+ * modes. Starts empty; callers must invoke `loadOptions`.
  */
 export declare function useSelectFieldLoading<TID extends string | number>(config: UseSelectFieldLoadingConfig<TID>): UseSelectFieldLoadingReturn<TID>;
 export {};

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

@@ -18,9 +18,10 @@ export type UseSelectOrchestrationConfig = {
     }>;
 };
 /**
- * Shared orchestration hook used by Select components
- * Centralizes adaptive view resolution, loading config construction, option loading lifecycle,
- * and imperative handle setup (clearCache/invalidate).
+ * Resolves menu surface and initial-load mode, then wires option loading and
+ * an imperative `clearCache` / `invalidate` handle. `displayMenuAs: "auto"` is
+ * dialog on mobile and popover otherwise; `initialLoad: "auto"` is immediate.
+ * `invalidate` also resets `initialLoadPerformed`.
  */
 export declare function useSelectOrchestration<TID extends string | number>(config: UseSelectOrchestrationConfig): {
     displayAs: "dialog" | "popover";

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

@@ -7,9 +7,9 @@ type UseToggleSelectionParams<TID extends string | number> = {
     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.
+ * Toggles an option in a multi-select list. Adding looks up the full option in
+ * `options`, then pinned sections; ids in neither are not added. Removing
+ * matches by id only.
  */
 export declare const useToggleSelection: <TID extends string | number>({ options, pinnedSections, selectedOptions, onSelectedOptionsChange, }: UseToggleSelectionParams<TID>) => {
     handleItemClick: (option: {

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

@@ -1,15 +1,7 @@
 /**
- * Custom hook for implementing type-ahead functionality.
+ * Accumulates typed characters for list/menu keyboard matching. Starts as `""`
+ * and clears `timeout` ms after the last character (default `750`).
  *
- * Features:
- * - Accumulates typed characters with automatic timeout clearing
- * - Provides type-ahead string for keyboard navigation
- * - Automatically resets after specified timeout period
- * - Supports customizable timeout duration
- * - Uses useEffect for automatic cleanup
- * - Optimized for keyboard navigation in lists and menus
- *
- * @param timeout - Timeout duration in milliseconds before clearing the type-ahead string
- * @returns Tuple containing current type-ahead string and function to update it
+ * @returns `[query, append]` — `append` concatenates; it does not replace.
  */
 export declare const useTypeAhead: (timeout?: number) => [string, (char: string) => void];

package/dist/src/internal/testing/anvPartsContract.d.ts

@@ -1,24 +1,24 @@
 type PartsRecord = Record<string, string>;
 type PartKey<T extends PartsRecord> = Extract<keyof T, string>;
+/**
+ * Presence/absence checks against a PARTS map. `count` overrides `minCount`
+ * for the same key (`minCount` defaults to 1). Omitting `present` skips
+ * presence checks; `absent` still runs.
+ */
 export type ExpectAnvPartsOptions<T extends PartsRecord> = {
-    /** Part keys that must be present in `scope` (default: at least one match). */
     present?: PartKey<T>[];
-    /** Part keys that must not appear in `scope`. */
     absent?: PartKey<T>[];
     /**
-     * Node to query within. Defaults to `document.body` so portaled parts
-     * (menu / popover / dialog / drawer) are found without a wrapper.
+     * Query root. Defaults to `document.body` so portaled parts are found
+     * without a wrapper.
      */
     scope?: ParentNode;
-    /** Exact match count for a present key. */
     count?: Partial<Record<PartKey<T>, number>>;
-    /** Minimum match count for a present key (ignored when `count` is set). */
     minCount?: Partial<Record<PartKey<T>, number>>;
 };
 /**
- * Assert that `data-anv-part` values from a PARTS / COMMON_PART map are present
- * or absent in the DOM. Prefer this over hard-coded attribute strings so
- * renames in `parts.ts` fail the contract instead of silently drifting.
+ * Asserts `data-anv-part` values from a PARTS map. Prefer this over
+ * hard-coded attribute strings so `parts.ts` renames fail the contract.
  */
 export declare function expectAnvParts<T extends PartsRecord>(parts: T, options?: ExpectAnvPartsOptions<T>): void;
 export {};

package/dist/src/internal/testing/reactHostProps.d.ts

@@ -1,5 +1,5 @@
 /**
- * Read the props object React 18 attaches to a host DOM node.
- * Used to assert we did not pass camelCase props React 18 does not recognize.
+ * Reads the props object React 18 attaches to a host DOM node.
+ * Use to assert camelCase props React 18 does not recognize were not passed.
  */
 export declare function getReactHostProps(el: Element): Record<string, unknown>;

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

@@ -1,27 +1,25 @@
 import { ReactNode } from 'react';
 /**
- * Shared prop set for the "Add new item" affordance available on
- * SelectField, SelectMenu, MultiSelectField, and MultiSelectMenu.
- *
- * @property addItemLabel - Label rendered inside the "Add new item" button. May be a static node or a callback that receives the current search text and returns a dynamic label (e.g. `Add "${searchText}"`). When the callback returns `null` or `undefined`, the button is not rendered. When omitted but `onAddNewItem` is provided, falls back to `"Add new item"`.
- * @property onAddNewItem - Click handler for the "Add new item" button. Presence of this prop is what gates rendering the button (unless `addItemLabel` is a callback that returns `null`/`undefined` for the current search text). Receives the current search text. The menu auto-closes synchronously on click; the handler runs immediately after — typically opening a Dialog or Drawer to collect the new item's details. Consumers manage their own overlay presentation, focus return, option list updates, and selection state.
+ * Shared "Add new item" affordance. The button mounts when `onAddNewItem` is
+ * set and {@link resolveAddItemLabel} returns a node.
  */
 export type AddNewItemProps = {
+    /**
+     * Button label. A callback receives the current search text and may return
+     * `null`/`undefined` to hide the button. Omitted static labels fall back to
+     * `"Add new item"`.
+     */
     addItemLabel?: ReactNode | ((searchText: string) => ReactNode);
+    /**
+     * Called with the current search text after the host menu closes. Consumers
+     * own overlay, list, and selection updates.
+     */
     onAddNewItem?: (searchText: string) => void;
 };
-/**
- * Resolves the add-new button label for the current search text.
- *
- * - Callback labels: returns the callback result, or `null` when the callback
- *   returns `null`/`undefined` (button should be hidden).
- * - Static / omitted labels: returns the static node, or `"Add new item"` when
- *   omitted.
- */
+/** Resolves the add-new button label for the current search text. */
 export declare function resolveAddItemLabel(addItemLabel: AddNewItemProps["addItemLabel"], searchText: string): ReactNode | null;
 /**
- * Whether the add-new button should be mounted for the current search text.
- * Host menus use this so an empty footer (and its divider) is not rendered when
- * a label callback hides the button.
+ * Whether the add-new button should mount. Hosts use this so an empty footer
+ * (and its divider) is not rendered when a label callback hides the button.
  */
 export declare function shouldShowAddNewItem(onAddNewItem: AddNewItemProps["onAddNewItem"], addItemLabel: AddNewItemProps["addItemLabel"], searchText: string): boolean;

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

@@ -1,3 +1,4 @@
+/** Storybook `argTypes` that bucket layout-utility props under "Layout Props". */
 export declare const argTypesLayoutProps: {
     alignContent: {
         table: {
@@ -125,6 +126,7 @@ export declare const argTypesLayoutProps: {
         };
     };
 };
+/** Storybook `argTypes` that bucket breakpoint size props under "Responsive Sizes". */
 export declare const argTypesResponsiveSizes: {
     sm: {
         table: {

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

@@ -1,58 +1,33 @@
 import { CheckState } from '../../types';
 import { SelectFieldOption } from '../../components/SelectField/types';
 /**
- * The check state of a "Select All" / "Select Filtered" row.
- *
- * Accepts a static value (`boolean` shorthand or a full `CheckState`) or a
- * function that derives the state from the current selection. The function
- * form is resolved against the live selection (the confirmation draft when
- * confirmation is enabled, otherwise the committed value), so the row's
- * checkbox can reflect how much of the set is currently selected — e.g.
- * `checked` when everything is selected, `indeterminate` when some is, and
- * `unchecked` when none is. This is the async equivalent of the automatic
- * check-state behavior the `*Sync` variants provide.
+ * Row checkbox state, or a function of the current selection. Boolean
+ * shorthand is resolved by {@link resolveBulkActionCheckState}.
  */
 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).
+ * Static text or derived from the current selection. Omitted config labels
+ * become `"Select All"`.
  */
 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.
- *
- * Choose exactly one of `onClick` or `compute`:
- *
- * - **`onClick`** — the row fires the callback; the consumer commits the next
- *   selection themselves via `onSelectedOptionsChange`. Simple and familiar.
- *   When `confirmation` is enabled, `onClick` bypasses the menu's draft layer
- *   (the menu warns once in development).
- * - **`compute`** — the menu invokes `compute(currentDraft)` and writes the
- *   result into the draft (or commits it, when confirmation is off). `compute`
- *   may return a `Promise<SelectFieldOption[]>`; while the promise is pending
- *   the menu shows a loading state, disables all option rows, and disables
- *   Apply.
- *
- * `checkState` accepts a static value (a `boolean` shorthand or a full
- * `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.
+ * Select-All / Select-Filtered row. Exactly one of `onClick` or `compute`.
  */
 export type BulkActionConfig<TID extends string | number> = {
     label?: BulkActionLabel<TID>;
     checkState: BulkActionCheckState<TID>;
+    /** Consumer commits the next selection. */
     onClick: () => void;
     compute?: never;
 } | {
     label?: BulkActionLabel<TID>;
     checkState: BulkActionCheckState<TID>;
+    /** Next selection from the current one; may be async. */
     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`.
+ * Normalized form after `checkState`'s boolean shorthand is a `CheckState`.
  */
 export type ResolvedBulkAction<TID extends string | number = string | number> = {
     label?: string;
@@ -61,14 +36,10 @@ export type ResolvedBulkAction<TID extends string | number = string | number> =
     compute?: (current: SelectFieldOption<TID>[]) => SelectFieldOption<TID>[] | Promise<SelectFieldOption<TID>[]>;
 };
 /**
- * Resolves a `BulkActionCheckState` into a concrete `CheckState`.
- *
- * When `checkState` is a function it is invoked with the current selection.
- * The `boolean` shorthand maps `true → "checked"` and `false → "unchecked"`;
- * a `CheckState` is passed through, defaulting to `"indeterminate"`.
+ * Resolves {@link BulkActionCheckState} to a {@link CheckState}.
+ * `true` → `"checked"`, `false` → `"unchecked"`; other values pass through,
+ * defaulting to `"indeterminate"`.
  */
 export declare function resolveBulkActionCheckState<TID extends string | number>(checkState: BulkActionCheckState<TID>, current: SelectFieldOption<TID>[]): CheckState;
-/**
- * Resolves a `BulkActionLabel` into a display string.
- */
+/** Resolves {@link BulkActionLabel} to a string. */
 export declare function resolveBulkActionLabel<TID extends string | number>(label: BulkActionLabel<TID> | undefined, current: SelectFieldOption<TID>[], fallback?: string): string;

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

@@ -1,19 +1,18 @@
 /**
- * Opt-in confirmation mode for Select* and MultiSelect* components.
- *
- * When set, selection changes are held as a draft inside the open menu and
- * only commit to the controlled `value` when the user clicks Apply. Dismissing
- * the menu (Escape, click outside, toggling the trigger) discards the draft.
- *
- * `true` enables the default Apply/Cancel labels. Pass an object to customize.
+ * Opt-in Apply/Cancel confirmation. `true` uses default labels; an object
+ * customizes them. Falsy leaves confirmation off.
  */
 export type ConfirmationProp = boolean | {
+    /** Apply-button text. Defaults to `"Apply"`. */
     applyLabel?: string;
+    /** Cancel-button text. Defaults to `"Cancel"`. */
     cancelLabel?: string;
 };
+/** Enabled flag and labels after {@link resolveConfirmation}. */
 export type ResolvedConfirmation = {
     enabled: boolean;
     applyLabel: string;
     cancelLabel: string;
 };
+/** Maps a {@link ConfirmationProp} to enabled + `"Apply"` / `"Cancel"` defaults. */
 export declare const resolveConfirmation: (prop: ConfirmationProp | undefined) => ResolvedConfirmation;

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

@@ -1,19 +1,16 @@
 import { AvatarProps, ChipProps, IconProps } from '../../components';
-/**
- * Shared content shape for option rows in SelectField, MultiSelectField, and TreeSelectField.
- * @property title - Overrides the option label text when provided.
- * @property description - Secondary text displayed below the title in a subdued color.
- * @property chips - Tags displayed below the description.
- * @property avatar - Avatar displayed to the left of the text content.
- * @property icon - Icon displayed to the right of the text content.
- */
 export type OptionContent = {
+    /** Replaces the option's `label` when set. */
     title?: string;
+    /** Secondary line under the title. */
     description?: string;
+    /** Tags after the title/description block. */
     chips?: Pick<ChipProps, "label" | "color" | "textWrap">[];
+    /** Leading avatar. */
     avatar?: Pick<AvatarProps, "name" | "status" | "color" | "image">;
+    /** Trailing icon, opposite the avatar. */
     icon?: Pick<IconProps, "svg" | "color"> & {
-        /** Accessible label for the icon. When omitted, the icon is treated as decorative. */
+        /** Accessible name. When omitted, the icon is decorative. */
         label?: string;
     };
 };

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

@@ -1,8 +1,13 @@
 import { LabelProps } from '../components';
 import { AiMarkWithTooltipOrPopoverProps } from '../../types/ai-marks';
+/**
+ * Field-level `moreInfo` / `required`, plus leftover label config via
+ * `labelProps` (those two stay on the field, not nested).
+ */
 export type FieldLabelProps = Pick<LabelProps, "moreInfo" | "required"> & {
     /**
-     * Props passed to the internal label component.
+     * Extra label props except `children`, `moreInfo`, `required`, `id`, and
+     * `htmlFor`.
      */
     labelProps?: Omit<LabelProps, "children" | "moreInfo" | "required" | "id" | "htmlFor"> & AiMarkWithTooltipOrPopoverProps;
 };

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

@@ -3,20 +3,17 @@ import { AiMarkWithTooltipOrPopoverProps, CheckState, DataAttributes } from '../
 import { SelectFieldOption, SelectFieldProps } from '../../components/SelectField/types';
 import { AddNewItemProps } from './addNewItemTypes';
 import { ResolvedConfirmation } from './confirmationTypes';
-/**
- * Metadata about list sections for rendering purposes.
- * Used by SelectOptions, MultiSelectOptions, and their Menu counterparts to render section headers and dividers.
- * @property type - The type of section ("pinned" for pinned options, "group" for grouped options)
- * @property label - Section label (e.g., "Recent", "Favorites", or group name)
- * @property startIndex - Index in items where this section starts
- * @property endIndex - Index where this section ends (exclusive)
- * @property loading - Whether this section is still loading its options (pinned sections only)
- */
+/** Indexed slice of flattened select items for a pinned or group header. */
 export type SectionMeta = {
+    /** `"pinned"` vs `"group"` header. */
     type: "pinned" | "group";
+    /** Header text. */
     label: string;
+    /** Inclusive start in the flattened `items` array. */
     startIndex: number;
+    /** Exclusive end in the flattened `items` array. */
     endIndex: number;
+    /** Pinned sections may still render while empty and loading. */
     loading?: boolean;
 };
 export type SelectFieldBaseInternalProps<TID extends string | number> = {
@@ -73,13 +70,14 @@ export type SelectFieldComboboxInternalProps<TID extends string | number> = Sele
     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.
+ * Loose prop getters compatible with downshift `useCombobox` and `useSelect`.
+ * `any` is intentional: the runtime shapes match, the compile-time generics do
+ * not.
  */
 export type GetMenuPropsFn = (...args: any[]) => any;
 export type GetItemPropsFn = (...args: any[]) => any;
 export type GetLabelPropsFn = (...args: any[]) => any;
+/** Flattened list row: option, pinned/grouped copy, or bulk-action row. */
 export type SelectItem<TID extends string | number = string | number> = {
     id: string | number;
     type: "option" | "pinned-option" | "grouped-option" | "select-all" | "select-filtered";

package/dist/src/internal/utils/arrayIdsEqual.d.ts

@@ -1,9 +1,5 @@
 /**
- * Shallow set-equality of two value arrays by `id`, order-independent.
- *
- * Used as the `isEqual` comparator for `useConfirmationDraft` so that a draft
- * is considered unchanged when it holds the same set of selected items as the
- * committed value, regardless of order.
+ * Checks equal lengths and whether every ID in `b` occurs in `a`, ignoring order.
  */
 export declare function arrayIdsEqual<T extends {
     id: string | number;

package/dist/src/internal/utils/generateChromaticStickersheetProps.d.ts

@@ -1,15 +1,11 @@
+/** Maps each prop to the values included in stickersheet combinations. */
 export type OptionsObject<P extends Record<string, unknown>> = {
     [K in keyof P]: P[K][];
 };
 /**
- * Generate a list of props for a component that can be used to create a stickersheet for Chromatic.
- * This will return an array of props that can be used to create a stickersheet for Chromatic, including
- * a label that can be used to identify the variation in the stickersheet.
- *
- * @param props - The component props used to generate variations for the stickersheet.
- * @param labelFormatter - A function to format the label for the prop.
- * @param propsFormatter - A function to format the props. Return `false` to exclude a variation.
- * @returns An array of props that can be used to create a stickersheet for Chromatic.
+ * Builds the Cartesian product of prop options for a Chromatic stickersheet.
+ * Labels omit `false` and `undefined` options; a props formatter can reshape or
+ * exclude each variation.
  */
 export declare const generateChromaticStickersheetProps: <P extends Record<string, unknown>, T extends OptionsObject<P> = OptionsObject<P>>(props?: Partial<T>, labelFormatter?: (values: Record<keyof T, unknown>) => string, propsFormatter?: (values: Record<keyof T, unknown>) => Record<string, unknown> | false) => (P & {
     label: string;

package/dist/src/internal/utils/inlineMarkdownRegex.d.ts

@@ -1,5 +1 @@
-/**
- * Shared regex for parsing inline markdown constructs.
- * Matches (in order): bold-italic `***`, bold `**`, italic `*`, highlight `==`, code `` ` ``
- */
 export declare const INLINE_MARKDOWN_REGEX: RegExp;