@servicetitan/anvil2 3.13.6 → 3.14.0

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

@@ -1,44 +1,14 @@
-/**
- * Options for the useIntersectionObserver hook
- * @property {Element | Document | null} [root] - The root element for intersection calculations
- * @property {string} [rootMargin] - Margin around the root element
- * @property {number | number[]} [threshold] - Threshold values for intersection detection
- * @property {boolean} [freezeOnceVisible] - Whether to freeze once the element becomes visible
- * @property {(isIntersecting: boolean, entry: IntersectionObserverEntry) => void} [onChange] - Callback when intersection changes
- * @property {boolean} [initialIsIntersecting] - Initial intersection state
- */
 export type UseIntersectionObserverOptions = {
-    /**
-     * The root element for intersection calculations
-     */
     root?: Element | Document | null;
-    /**
-     * Margin around the root element
-     */
     rootMargin?: string;
-    /**
-     * Threshold values for intersection detection
-     */
     threshold?: number | number[];
-    /**
-     * Whether to freeze once the element becomes visible
-     */
+    /** Stops observing after the first intersecting entry. */
     freezeOnceVisible?: boolean;
-    /**
-     * Callback when intersection changes
-     */
     onChange?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
-    /**
-     * Initial intersection state
-     */
+    /** Value reported before the first observer entry. Defaults to `false`. */
     initialIsIntersecting?: boolean;
 };
-/**
- * Return type for the useIntersectionObserver hook
- * @property {(node?: Element | null) => void} ref - Function to set the element to observe
- * @property {boolean} isIntersecting - Whether the element is intersecting
- * @property {IntersectionObserverEntry} [entry] - The intersection observer entry
- */
+/** The observer result, available through tuple or named-property access. */
 export type IntersectionReturn = [
     (node?: Element | null) => void,
     boolean,
@@ -49,19 +19,6 @@ export type IntersectionReturn = [
     entry?: IntersectionObserverEntry;
 };
 /**
- * Custom hook for observing element intersection with viewport or root element.
- *
- * Features:
- * - Observes element intersection with viewport or custom root element
- * - Supports configurable threshold values and root margins
- * - Provides intersection state and detailed entry information
- * - Supports freezing observation once element becomes visible
- * - Handles browser compatibility gracefully
- * - Provides both array and object destructuring support
- * - Automatically cleans up observer on unmount
- * - Supports onChange callback for custom intersection handling
- *
- * @param options - Configuration options for the intersection observer
- * @returns Array containing ref function, intersection state, and entry, with additional object properties
+ * Reports intersection state for the element assigned through its returned ref.
  */
 export declare function useIntersectionObserver({ threshold, root, rootMargin, freezeOnceVisible, initialIsIntersecting, onChange, }?: UseIntersectionObserverOptions): IntersectionReturn;

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

@@ -2,13 +2,8 @@ type InvalidatableHandle = {
     invalidate: () => void;
 };
 /**
- * Invalidates a select field/menu when its `options` *contents* change.
- *
- * A new array (or tree) identity with the same data does not invalidate, so
- * consumers can pass inline option literals without triggering a reload.
- *
- * @param handleRef Ref to an imperative handle that exposes `invalidate`
- * @param options The current options value (flat list or tree)
+ * Invalidates a select handle only when option contents change, ignoring the
+ * initial mount and reference-only changes.
  */
 export declare function useInvalidateOnOptionsChange(handleRef: {
     current: InvalidatableHandle | null;

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

@@ -1,6 +1,2 @@
-/**
- * Custom hook to detect if an element is horizontally scrollable
- * @param element The HTML element to check for horizontal scrollability
- * @returns boolean indicating if the element is horizontally scrollable
- */
+/** Reports horizontal overflow and updates after element resizes. */
 export declare const useIsScrollable: (element: HTMLElement | null) => boolean;

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

@@ -1,52 +1,15 @@
 import { RefObject } from 'react';
 import { FocusableElement } from 'tabbable';
-/**
- * Options for the useKeyboardFocusables hook
- */
 type OptionProps = {
-    /**
-     * Disable mutation observer
-     */
     observeChange: false;
 } | {
-    /**
-     * Enable mutation observer with optional configuration
-     */
     observeChange: true;
-    /**
-     * Observe attribute changes
-     */
     attributes?: boolean;
-    /**
-     * Observe text content changes
-     */
     characterData?: boolean;
-    /**
-     * Observe child element changes
-     */
     childList?: boolean;
-    /**
-     * Observe descendant changes
-     */
     subtree?: boolean;
 };
-/**
- * Custom hook for tracking keyboard focusable elements within a container.
- *
- * Features:
- * - Tracks all keyboard focusable elements within a target container
- * - Supports both ref objects and direct element references
- * - Optional mutation observer for real-time updates
- * - Debounced updates to prevent excessive re-renders
- * - Configurable mutation observer options
- * - Manual update function for immediate refresh
- * - Uses tabbable library for accurate focusable detection
- * - Automatically cleans up mutation observer
- *
- * @param element - Target element or ref to monitor for focusable elements
- * @param options - Configuration options for mutation observer behavior
- * @returns Object containing current focusable elements and update function
- */
+/** Tracks tabbable descendants within a container as its DOM changes. */
 export declare const useKeyboardFocusables: (element: RefObject<HTMLElement> | HTMLElement | undefined, options?: OptionProps) => {
     focusables: FocusableElement[] | null;
 };

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

@@ -1,53 +1,17 @@
 import { CSSProperties } from 'react';
 import { LayoutUtilProps } from '../../../types';
-/**
- * Responsive layout configuration type
- */
 type ResponsiveLayout = {
-    /**
-     * Base layout properties
-     */
     base?: LayoutUtilProps;
-    /**
-     * Extra small breakpoint layout properties
-     */
     xs?: LayoutUtilProps;
-    /**
-     * Small breakpoint layout properties
-     */
     sm?: LayoutUtilProps;
-    /**
-     * Medium breakpoint layout properties
-     */
     md?: LayoutUtilProps;
-    /**
-     * Large breakpoint layout properties
-     */
     lg?: LayoutUtilProps;
-    /**
-     * Extra large breakpoint layout properties
-     */
     xl?: LayoutUtilProps;
-    /**
-     * Extra extra large breakpoint layout properties
-     */
     xxl?: LayoutUtilProps;
 };
 /**
- * Custom hook for managing responsive layout properties and CSS styles.
- *
- * Features:
- * - Separates layout properties from component properties
- * - Provides responsive breakpoint support for all layout properties
- * - Automatically converts gap sizes to CSS tokens
- * - Uses breakpoint cascade for responsive values
- * - Optimized with useMemo for performance
- * - Supports all CSS Grid and Flexbox properties
- * - Handles responsive size inheritance (larger breakpoints inherit from smaller ones)
- * - Returns both layout styles and filtered component props
- *
- * @param props - Object containing layout and component properties
- * @returns Object containing layout styles and filtered component props
+ * Resolves responsive layout utilities into styles and removes them from the
+ * remaining component props.
  */
 export declare function useLayoutPropsUtil<T extends ResponsiveLayout>(props: T): {
     layoutStyles?: CSSProperties;

package/dist/src/internal/hooks/useNumberField/internal/createNumberMaskOptions.d.ts

@@ -1,10 +1,7 @@
 import { MaskitoOptions } from '@maskito/core';
 import { MaskitoNumberParams } from '@maskito/kit';
 /**
- * Creates Maskito options for number input with trailing decimal and zero support.
- *
- * When `minimumFractionDigits` is 0, Maskito rejects trailing decimals ("123.")
- * and strips trailing zeros ("123.0" → "123."). This extends the base options
- * with processors to allow natural decimal input during typing.
+ * Extends Maskito's number options with in-progress decimal processors when
+ * `minimumFractionDigits` is 0.
  */
 export declare function createNumberMaskOptions(params: MaskitoNumberParams): MaskitoOptions;

package/dist/src/internal/hooks/useNumberField/internal/createTrailingZerosHandlers.d.ts

@@ -10,7 +10,6 @@ export interface TrailingZerosHandlers {
  *
  * When `minimumFractionDigits` is 0, Maskito's multi-pass validation strips
  * trailing zeros (e.g., "123.0" → "123."). This factory returns coordinated
- * processors that detect and restore trailing zeros, using closure state to
- * support multiple NumberField instances.
+ * processors that preserve the user's intermediate text until blur.
  */
 export declare function createTrailingZerosHandlers(params: Pick<MaskitoNumberParams, "minimumFractionDigits" | "maximumFractionDigits">): TrailingZerosHandlers;

package/dist/src/internal/hooks/useNumberField/internal/numberMaskUtils.d.ts

@@ -1,9 +1,3 @@
-/**
- * Utility predicates for number mask processing.
- */
-/** Returns true if the string contains one or more zeros and nothing else. */
 export declare const isAllZeros: (str: string) => boolean;
-/** Returns true if the string is empty or contains only zeros. */
 export declare const isEmptyOrAllZeros: (str: string) => boolean;
-/** Returns true if the string is a single non-zero digit (1-9). */
 export declare const isNonZeroDigit: (str: string) => boolean;

package/dist/src/internal/hooks/useNumberField/internal/useNumberFieldInputMode.d.ts

@@ -1,22 +1,7 @@
 export type InputMode = "decimal" | "numeric" | "text";
 /**
- * Custom hook that determines the optimal inputMode attribute for number fields based on platform and requirements.
- *
- * The inputMode attribute tells the device what type of software keyboard to show.
- * There are inconsistencies in what each software keyboard includes across different platforms:
- * - iPhone lacks a minus sign in both numeric and decimal keyboards
- * - Android numeric keyboard has both decimal point and minus sign
- * - iPad has different keyboard behavior than iPhone
- *
- * @param hasDecimals - Whether the number field allows decimal values
- * @param hasNegative - Whether the number field allows negative values
- * @returns The optimal inputMode attribute to use on the number field
- *
- * @example
- * const inputMode = useNumberFieldInputMode({
- *   hasDecimals: true,
- *   hasNegative: false
- * });
+ * Selects a software-keyboard hint that keeps the required decimal and minus
+ * keys available on iPhone and Android.
  */
 export declare const useNumberFieldInputMode: ({ hasDecimals, hasNegative, }: {
     hasDecimals: boolean;

package/dist/src/internal/hooks/useNumberField/internal/useNumberFieldKeys.d.ts

@@ -1,43 +1,17 @@
-/**
- * Configuration for the useNumberFieldKeys hook
- */
 export type UseNumberFieldKeysConfig = {
-    /** Function to increment the value by a specified amount */
     increment: (amount: number) => void;
-    /** Function to decrement the value by a specified amount */
     decrement: (amount: number) => void;
-    /** Function to set the value to the minimum allowed value */
     setToMin: () => void;
-    /** Function to set the value to the maximum allowed value */
     setToMax: () => void;
-    /** The step value for increment/decrement operations */
     step: number;
-    /** Multiplier for large step operations (PageUp/PageDown) */
+    /** Applied to `step` for Page Up and Page Down. */
     largeStepMultiplier: number;
-    /** When true, keyboard interactions that would mutate the value are ignored */
+    /** Ignores all handled keys when `true`. */
     readOnly?: boolean;
 };
 /**
- * Custom hook that handles keyboard interactions for number fields.
- *
- * This hook provides keyboard navigation support for number input fields:
- * - Arrow Up/Down: Increment/decrement by step value
- * - Page Up/Down: Increment/decrement by step * largeStepMultiplier
- * - Home: Set to minimum value
- * - End: Set to maximum value
- *
- * @param config - Configuration object containing increment/decrement functions and step values
- * @returns Object containing the input ref to attach to the input element
- *
- * @example
- * const { inputRef } = useNumberFieldKeys({
- *   increment: (amount) => setValue(prev => prev + amount),
- *   decrement: (amount) => setValue(prev => prev - amount),
- *   setToMin: () => setValue(minValue),
- *   setToMax: () => setValue(maxValue),
- *   step: 1,
- *   largeStepMultiplier: 10
- * });
+ * Attaches spinbutton keyboard controls: arrows step, Page Up/Down take a large
+ * step, and Home/End move to the bounds.
  */
 declare function useNumberFieldKeys(config: UseNumberFieldKeysConfig): {
     inputRef: import('react').RefObject<HTMLInputElement>;

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

@@ -1,94 +1,48 @@
-/**
- * Configuration options for the useNumberField hook
- */
 export type UseNumberFieldConfig = {
-    /**
-     * The label for the number field.
-     * Important for accessibility and button labeling.
-     */
+    /** Included in the increment and decrement buttons' accessible names. */
     label?: string;
-    /**
-     * The minimum value for the number field.
-     * @default 0
-     */
+    /** Lower bound for stepping with the buttons or keyboard. Defaults to `0`. */
     minValue?: number;
     /**
-     * The maximum value for the number field.
-     * @default 100000000000000
+     * Upper bound for stepping with the buttons or keyboard.
+     * Defaults to `100000000000000`.
      */
     maxValue?: number;
-    /**
-     * The step value for the number field.
-     * @default 1
-     */
+    /** Magnitude used for button and arrow-key changes. Zero falls back to `1`. */
     step?: number;
-    /**
-     * The controlled value for the number field.
-     */
+    /** Numeric value to format when controlling the field. */
     value?: number | null;
-    /**
-     * The default (uncontrolled) value for the number field.
-     */
+    /** Initial numeric value when the field is uncontrolled. */
     defaultValue?: number | null;
     /**
-     * The maximum number of decimal places for the number field.
-     * @default 0
+     * Limits and rounds decimal input. Raised to `minimumFractionDigits` when lower.
      */
     maximumFractionDigits?: number;
-    /**
-     * The minimum number of decimal places for the number field.
-     * @default 0
-     */
+    /** Pads the displayed value with trailing zeros. Defaults to `0`. */
     minimumFractionDigits?: number;
-    /**
-     * A callback that is called when the value changes.
-     * @param value The new numeric value or null if invalid/empty
-     */
+    /** Receives `null` for empty or unparseable input; a lone minus does not notify. */
     onChange?: (value: number | null) => void;
     /**
-     * When `true`, disables keyboard interactions that would change the value
-     * (Arrow keys, PageUp/PageDown, Home, End).
+     * Ignores step, Page Up/Down, Home, and End keys without disabling text entry
+     * or buttons.
      */
     readOnly?: boolean;
 };
-/**
- * Return value from the useNumberField hook
- */
 export type UseNumberFieldReturnValue = {
-    /** The current numeric value of the number field. */
+    /** Parsed number, or `null` while empty, a lone minus, or unparseable. */
     value: number | null;
-    /** A ref that should be attached to the input element. */
+    /** Attach to the input to enable masking and keyboard controls. */
     inputRef: React.RefObject<HTMLInputElement>;
-    /** The props to pass to the input element. */
+    /** Masked spinbutton props for the input. */
     inputProps: Pick<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "inputMode" | "aria-valuenow" | "aria-valuemin" | "aria-valuemax" | "min" | "max" | "step" | "role" | "pattern" | "type" | "autoComplete">;
-    /** The props to pass to the increment button. */
+    /** Props for a non-tabbable increment button. */
     incrementButtonProps: React.ButtonHTMLAttributes<HTMLButtonElement>;
-    /** The props to pass to the decrement button. */
+    /** Props for a non-tabbable decrement button. */
     decrementButtonProps: React.ButtonHTMLAttributes<HTMLButtonElement>;
 };
 /**
- * Custom hook that provides the functionality for number input fields with increment and decrement controls.
- *
- * This hook handles:
- * - Precise decimal arithmetic using Big.js
- * - Number formatting with thousand separators and decimal precision
- * - Input validation and value clamping
- * - Keyboard navigation (arrows, PageUp/Down, Home/End)
- * - Platform-specific input modes for mobile devices
- * - Accessibility attributes and button states
- * - Controlled and uncontrolled value management
- *
- * @param config - Configuration options for the number field
- * @returns Object containing the current value, input ref, and props for input and buttons
- *
- * @example
- * const { value, inputRef, inputProps, incrementButtonProps, decrementButtonProps } = useNumberField({
- *   label: "Quantity",
- *   minValue: 0,
- *   maxValue: 100,
- *   step: 1,
- *   onChange: (value) => console.log(value)
- * });
+ * Builds masked spinbutton and stepper-control props while preserving incomplete
+ * negative and decimal input that cannot round-trip through a numeric value.
  */
 export declare const useNumberField: (config: UseNumberFieldConfig) => {
     value: number | null;

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

@@ -1,44 +1,16 @@
-/**
- * Props for the useOnClickOutside hook
- */
 type UseOnClickOutsideProps = {
-    /**
-     * Callback fired when a click begins outside target elements (on pointerdown)
-     */
+    /** Pointerdown outside `targets`. */
     onClickOutsideBegin?: (e: PointerEvent) => void;
-    /**
-     * Callback fired when a click completes outside target elements (on pointerup),
-     * but only if the click also began outside the targets
-     */
+    /** Pointerup outside `targets`, only if that press also started outside. */
     onClickOutside?: (e: PointerEvent) => void;
-    /**
-     * Array of target elements to monitor
-     */
     targets: (HTMLElement | undefined)[];
-    /**
-     * Whether to disable the useOnClickOutside hook
-     */
     disable?: boolean;
-    /**
-     * Optional layer ID for stacking management. When provided, callbacks will only
-     * fire if this layer is the topmost layer in the stack.
-     */
+    /** When set, callbacks fire only if this layer is top of the overlay stack. */
     layerId?: string;
 };
 /**
- * Custom hook for detecting clicks outside of specified target elements.
- *
- * Features:
- * - Detects clicks outside of multiple target elements
- * - Supports both pointerdown and pointerup event handling (works for mouse and touch)
- * - Provides separate callbacks for click begin and complete actions
- * - Handles SSR environments gracefully
- * - Automatically cleans up event listeners
- * - Uses composedPath for accurate event target detection
- * - Supports optional callbacks for flexible usage
- *
- * @param props - Configuration object containing targets and optional callbacks
- * @returns void
+ * Listens on `document`. Outside-ness uses `composedPath`, so shadow-tree
+ * clicks still count as inside a target.
  */
 export declare const useOnClickOutside: ({ onClickOutsideBegin, targets, onClickOutside, disable, layerId, }: UseOnClickOutsideProps) => void;
 export {};

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

@@ -1,31 +1,10 @@
-/**
- * Possible states for open/close transitions
- */
+/** Lifecycle phases for an animated visibility change. */
 export type OpenCloseTransitionStates = "opening" | "open" | "closing" | "closed";
-/**
- * Effects configuration for open/close 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
- * @property {number | (() => number)} [durationMs] - Duration of the animation in milliseconds (or a function that returns the duration)
- */
+/** Optional side effects for each transition boundary. */
 export type OpenCloseTransitionStateEffects = {
-    /**
-     * Callback when opening animation starts
-     */
     onOpenAnimationStart?: () => void;
-    /**
-     * Callback when closing animation starts
-     */
     onCloseAnimationStart?: () => void;
-    /**
-     * Callback when opening animation completes
-     */
     onOpenAnimationComplete?: () => void;
-    /**
-     * Callback when closing animation completes
-     */
     onCloseAnimationComplete?: () => void;
 };
 export type OpenCloseTransitionState = {
@@ -42,10 +21,7 @@ export type OpenCloseTransitionStateOptions = {
     onCloseAnimationComplete?: () => void;
 };
 /**
- * Custom hook for managing open/close transition states and animations.
- *
- * @param openProp - The open prop controlling visibility
- * @param options - Additional, optional options including callbacks for animation start, complete, and initialization
- * @returns Object containing state, control functions, and utility flags
+ * Tracks opening and closing phases, completing each transition after a
+ * nonzero configured duration.
  */
 export declare const useOpenCloseTransitionStates: (openProp: boolean | undefined, options?: OpenCloseTransitionStateOptions) => OpenCloseTransitionState;

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

@@ -1,56 +1,12 @@
 import { SetStateAction, Dispatch } from 'react';
-/**
- * Props for the useOptionallyControlledState hook
- */
 type UseOptionallyControlledStateProps<T> = {
-    /**
-     * The controlled value of the state.
-     * When provided, the component becomes controlled.
-     */
     controlledValue?: T;
-    /**
-     * The default value of the state.
-     * Used when the component is uncontrolled.
-     */
     defaultValue?: T;
-    /**
-     * A function that is called when the value changes.
-     * @param value The new value
-     */
     onChange?: (value: T) => void;
 };
 /**
- * Custom hook for managing optionally controlled state.
- *
- * Features:
- * - Supports both controlled and uncontrolled state management
- * - Automatically switches between controlled and uncontrolled modes
- * - Provides consistent API regardless of control mode
- * - Handles onChange callbacks for both modes
- * - Uses useCallback for optimized setter function
- * - Supports generic types for flexible state values
- *
- * @param props - Configuration object containing controlled value, default value, and onChange callback
- * @returns Tuple containing current value and setter function
- */
-/**
- * Custom hook that manages state that can be either controlled or uncontrolled.
- *
- * This hook provides a unified interface for managing component state that can be
- * controlled externally or managed internally. It automatically detects whether
- * the component should be controlled based on the presence of a controlledValue.
- *
- * @param controlledValue - The controlled value (makes component controlled when provided)
- * @param defaultValue - The default value for uncontrolled mode
- * @param onChange - Callback function called when the value changes
- * @returns Tuple containing the current value and a setter function
- *
- * @example
- * const [value, setValue] = useOptionallyControlledState({
- *   controlledValue: props.value,
- *   defaultValue: 0,
- *   onChange: props.onChange
- * });
+ * Uses a defined controlled value when provided; otherwise stores state from
+ * the default value. Setters notify `onChange` in either mode.
  */
 export declare function useOptionallyControlledState<T>({ controlledValue, defaultValue, onChange, }: UseOptionallyControlledStateProps<T>): [
     T,

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

@@ -34,18 +34,13 @@ export type VirtualRow = {
     type: "load-more";
 };
 /**
- * Computes grouped sections from a flat items array and section metadata.
- * @param items - The flat items array
- * @param sectionsMeta - Section metadata describing pinned/group ranges
- * @returns Grouped sections for rendering
+ * Partitions a flat item list into indexed pinned, grouped, and unsectioned
+ * ranges.
  */
 export declare const useOptionsSections: (items: SelectItem[], sectionsMeta: SectionMeta[]) => Section[];
 /**
- * Flattens grouped sections into a linear list of virtual rows for virtualization,
- * and builds a mapping from downshift item index to virtual row index.
- * @param sections - The grouped sections from useOptionsSections
- * @param hasMore - Whether there are more items to load
- * @returns The flat virtual row list and a downshift-to-virtual index mapping
+ * Builds virtual rows and index metadata, marking bulk-action rows as sticky
+ * and appending a load-more row when requested.
  */
 export declare function flattenSectionsToVirtualRows(sections: Section[], hasMore: boolean): {
     virtualRows: VirtualRow[];

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

@@ -1,10 +1,5 @@
 import { SelectFieldOption, SelectFieldPinnedOptions } from '../../components/SelectField/types';
-/**
- * Normalized pinned section structure used internally.
- * @property label - Section label (e.g., "Recent", "Favorites")
- * @property options - The pinned options for this section
- * @property loading - Whether this section is still loading its options
- */
+/** A pinned section normalized for item building. */
 export type NormalizedPinnedSection<TID extends string | number> = {
     label: string;
     options: SelectFieldOption<TID>[];
@@ -14,24 +9,9 @@ type UsePinnedOptionsResult<TID extends string | number> = {
     pinnedSections: NormalizedPinnedSection<TID>[];
 };
 /**
- * Hook that normalizes and loads pinned options from various input formats.
- *
- * Handles:
- * - Labeled pinned options object
- * - Array of labeled pinned options objects
- *
- * Dynamic sections appear immediately with `loading: true` and empty options,
- * then transition to their resolved options once loaded. Results are cached
- * per section per search value so revisiting a previous search term is instant.
- *
- * Per-section configuration:
- * - `searchReactive` (default true): when false, loader is called once and the
- *   result is reused for all search values.
- * - `cacheSize` (default 15): max number of search results cached per section.
- *
- * @param pinned - The pinned options configuration from props
- * @param searchValue - Current search input value
- * @returns Normalized pinned sections with per-section loading state
+ * Normalizes static and loaded pinned sections, caching dynamic results by
+ * section and search value. Non-reactive loaders run once with an empty search;
+ * unresolved sections are returned empty with `loading: true`.
  */
 export declare function usePinnedOptions<TID extends string | number>(pinned: SelectFieldPinnedOptions<TID> | undefined, searchValue: string): UsePinnedOptionsResult<TID>;
 export {};