@uipath/apollo-wind 2.55.0 → 2.57.0

package/dist/components/ui/model-picker/primitives/PickerTrigger.d.ts

@@ -0,0 +1,73 @@
+import * as React from 'react';
+import type { DiscoveryModel } from '../types';
+import { type DeriveModelTagsContext } from '../utils';
+export interface PickerTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'id' | 'className' | 'disabled' | 'onClick' | 'placeholder'> {
+    id: string;
+    selected: DiscoveryModel | null;
+    /**
+     * Raw stored value that didn't resolve against `models`. When set,
+     * the trigger renders the id verbatim in error red with the border
+     * switched to error red — so a stale config doesn't look identical
+     * to "nothing selected". `null` for the normal case.
+     */
+    unknownValue?: string | null;
+    /**
+     * Stored value whose model has not resolved *yet* because the catalog is
+     * still loading. Rendered as plain text — unlike `unknownValue`, this is
+     * not an error state, and showing the placeholder instead would read as
+     * "your saved model is gone" every time a form opens.
+     */
+    pendingValue?: string | null;
+    placeholder?: string;
+    disabled?: boolean;
+    open: boolean;
+    invalid?: boolean;
+    /**
+     * Context forwarded to `deriveModelTags` for the selected model's
+     * chips. Carries the translator, `homeRegion`, test overrides, and
+     * `customTagsFor`.
+     */
+    tagContext?: DeriveModelTagsContext;
+    /**
+     * Variant lookup for tag kinds the design system doesn't know about.
+     * Forwarded straight to `<ModelTagChip>`.
+     */
+    tagVariants?: Record<string, string>;
+    /** Extra content rendered to the right of the model name, before the caret. */
+    extra?: React.ReactNode;
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+    /**
+     * Tag kinds to hide from the trigger's selected-model chips. Used by
+     * the compact picker to keep the trigger uncluttered.
+     */
+    hideTagKinds?: readonly string[];
+    /**
+     * ID of the popup's listbox, for `aria-controls`, so screen readers
+     * know which element the trigger opens.
+     */
+    controlsId?: string;
+    /**
+     * ID of an external error message. Forwarded as `aria-describedby`
+     * so screen readers announce the error alongside the field.
+     */
+    describedById?: string;
+    /**
+     * Whether the field is required. Forwarded as `aria-required`, which is
+     * valid on the trigger's `combobox` role; the label's asterisk is
+     * `aria-hidden`, so this is the only place it is announced.
+     */
+    required?: boolean;
+    className?: string;
+    'data-testid'?: string;
+}
+/**
+ * The picker's field control. A plain `<button>` rather than the shared
+ * `Button` so it can carry the two-line/chips content and the invalid
+ * state without fighting `Button`'s own size and gap variants; the
+ * resting chrome deliberately matches wind's `outline` field styling so
+ * the picker sits consistently alongside other form controls.
+ *
+ * Designed to be used as a Radix `<PopoverTrigger asChild>` child, so
+ * it forwards its ref and spreads no props it doesn't own.
+ */
+export declare const PickerTrigger: React.ForwardRefExoticComponent<PickerTriggerProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/ui/model-picker/primitives/PickerTrigger.js

@@ -0,0 +1,78 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { ChevronDown } from "lucide-react";
+import { forwardRef } from "react";
+import { cn } from "../../../../lib/index.js";
+import { DEFAULT_MODEL_PICKER_LABELS } from "../labels.js";
+import { ModelTagChip } from "../ModelTagChip.js";
+import { deriveModelTags } from "../utils.js";
+const PickerTrigger_PickerTrigger = /*#__PURE__*/ forwardRef(function({ id, selected, unknownValue, pendingValue, placeholder = 'Select a model', disabled, open, invalid, tagContext, tagVariants, extra, onClick, hideTagKinds, controlsId, describedById, required, className, 'data-testid': dataTestId, ...rest }, ref) {
+    const labels = tagContext?.labels ?? DEFAULT_MODEL_PICKER_LABELS;
+    const effectiveCtx = tagContext ?? {
+        labels
+    };
+    const inlineTags = selected ? deriveModelTags(selected, effectiveCtx).filter((t)=>!hideTagKinds?.includes(t.kind)) : [];
+    const primary = selected ? selected.displayName ?? selected.modelName : null;
+    const ownClick = onClick ? {
+        onClick
+    } : {};
+    return /*#__PURE__*/ jsxs("button", {
+        ...rest,
+        ...ownClick,
+        "aria-controls": open && controlsId ? controlsId : void 0,
+        "aria-describedby": describedById,
+        "aria-expanded": open,
+        "aria-haspopup": "listbox",
+        "aria-invalid": invalid ? true : void 0,
+        "aria-required": required || void 0,
+        role: "combobox",
+        className: cn('flex min-h-9 w-full cursor-pointer items-center justify-start gap-3 rounded-md border border-input bg-transparent px-3 py-1 text-left text-sm text-foreground transition-colors', 'focus:ring-2 focus:ring-ring focus:outline-none', 'focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none', 'disabled:cursor-not-allowed disabled:opacity-50', 'aria-invalid:border-error aria-invalid:focus-visible:ring-error', 'future:h-10 future:gap-4 future:rounded-xl future:border-0 future:bg-surface-overlay future:px-4 future:py-2 future:text-sm future:font-normal future:hover:bg-surface-hover future:focus-visible:ring-offset-2 future:focus-visible:ring-offset-background future:aria-invalid:ring-1 future:aria-invalid:ring-error/40', className),
+        "data-slot": "model-picker-trigger",
+        "data-testid": dataTestId,
+        disabled: disabled,
+        id: id,
+        ref: ref,
+        type: "button",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "flex min-w-0 flex-1 flex-nowrap items-center gap-1.5",
+                children: selected ? /*#__PURE__*/ jsxs(Fragment, {
+                    children: [
+                        /*#__PURE__*/ jsx("span", {
+                            className: "max-w-full truncate text-foreground",
+                            children: primary
+                        }),
+                        inlineTags.map((t)=>/*#__PURE__*/ jsx("span", {
+                                className: "flex shrink-0 items-center",
+                                children: /*#__PURE__*/ jsx(ModelTagChip, {
+                                    disableTooltip: true,
+                                    tag: t,
+                                    variants: tagVariants
+                                })
+                            }, `${t.kind}-${t.label}`))
+                    ]
+                }) : pendingValue ? /*#__PURE__*/ jsx("span", {
+                    className: "max-w-full truncate text-foreground",
+                    children: pendingValue
+                }) : unknownValue ? /*#__PURE__*/ jsx("span", {
+                    className: "max-w-full truncate text-error",
+                    title: labels.unknownValueTooltip(unknownValue),
+                    children: unknownValue
+                }) : /*#__PURE__*/ jsx("span", {
+                    className: "text-foreground-subtle",
+                    children: placeholder
+                })
+            }),
+            extra && /*#__PURE__*/ jsx("span", {
+                className: "flex shrink-0 items-center",
+                onClick: (e)=>e.stopPropagation(),
+                children: extra
+            }),
+            /*#__PURE__*/ jsx(ChevronDown, {
+                "aria-hidden": true,
+                className: cn('size-[18px] shrink-0 text-foreground-muted transition-transform duration-150', open && 'rotate-180')
+            })
+        ]
+    });
+});
+export { PickerTrigger_PickerTrigger as PickerTrigger };

package/dist/components/ui/model-picker/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/model-picker/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The model shape the picker renders. It follows the LLM Gateway
+ * `ModelDiscoveryResponse` DTO field-for-field so a host can hand Discovery
+ * rows straight through, but the picker performs no request itself — how
+ * the rows are fetched is the host's business.
+ *
+ * Kept intentionally permissive (string unions, optional fields) so the
+ * picker survives backend additions without a coordinated release.
+ */
+export type ModelVendor = 'OpenAi' | 'AzureOpenAi' | 'AnthropicClaude' | 'AwsBedrock' | 'VertexAi' | 'Custom' | string;
+export type ModelSubscriptionType = 'UiPathOwned' | 'BYOMReplacedLikeForLike' | 'BYOMReplacedAlternative' | 'BYOMAdded' | string;
+export type ModelGeography = 'EU' | 'CA' | 'US' | 'SI' | 'JA' | 'AU' | 'IN' | 'UK' | 'CH' | 'UAE' | 'SK' | 'GLOBAL' | string;
+export type ModelType = 'RequestResponse' | 'Realtime' | string;
+export interface DeprecationDetails {
+    usageEndDate?: string;
+    replacedBy?: string;
+}
+export interface ByomDetails {
+    availableOperationCodes?: string[];
+    integrationServiceConnectionId?: string;
+    defaultModel?: string;
+    customFieldMappings?: Record<string, string> | null;
+    /**
+     * Id of the `ByoProductLlmConfiguration` this model belongs to — the
+     * `:id` route segment of the AI Trust Layer LLM-configurations edit
+     * page. Served by Discovery as `byoConfigurationId` (UiPath/Arima#2659);
+     * when absent, the picker's edit affordance falls back to the
+     * configurations list page.
+     */
+    byoConfigurationId?: string;
+}
+/** Token costs in cents per million tokens (the gateway's unit). */
+export interface ModelFlatCosts {
+    inputTokenCost?: number;
+    outputTokenCost?: number;
+    cacheReadInputTokenCost?: number;
+    cacheWriteInputTokenCost?: number;
+}
+export interface ModelTieredCost extends ModelFlatCosts {
+    minimumTokens?: number;
+    maximumTokens?: number;
+}
+export interface ModelCostDetails {
+    /** `Flat` | `Tiered` */
+    pricingType?: string;
+    flatCosts?: ModelFlatCosts;
+    tieredCosts?: ModelTieredCost[];
+}
+export interface ModelDetails {
+    maxOutputTokens?: number;
+    contextWindowTokens?: number;
+    costDetails?: ModelCostDetails;
+    shouldUseMaxCompletionTokens?: boolean;
+    shouldSkipParallelToolCalls?: boolean;
+    shouldSkipTemperature?: boolean;
+    shouldSkipTopP?: boolean;
+    shouldUseResponseApi?: boolean;
+}
+export interface RoutingDetails {
+    geography?: ModelGeography;
+    model?: string;
+}
+export interface DiscoveryModel {
+    modelId: string;
+    modelName: string;
+    /**
+     * Human-friendly display name (e.g. "Claude Sonnet 4.6"). Authored
+     * centrally in the product's Model Hub configuration and merged into
+     * the Discovery response server-side, exactly like `isRecommended`.
+     * `undefined` means the backend has not rolled the field out yet; the
+     * picker then renders the raw `modelName`. There is deliberately no
+     * per-product rename prop.
+     */
+    displayName?: string;
+    effectiveModel?: string | null;
+    vendor: ModelVendor;
+    modelFamily?: string;
+    apiFlavor?: string;
+    modelSubscriptionType?: ModelSubscriptionType;
+    /**
+     * Whether the product team has promoted this model. Authored
+     * centrally in the product's Model Hub configuration and merged into
+     * the Discovery response server-side — products should NOT fetch the
+     * config themselves. `undefined` means the backend hasn't rolled the
+     * field out yet; the picker then falls back to a local heuristic
+     * (`UiPathOwned && !preview && !deprecating`).
+     */
+    isRecommended?: boolean;
+    /**
+     * AITL governance verdict: the requesting org's policy blocks this
+     * model. The picker never renders blocked models — mirroring how the
+     * platform's BFFs drop them from their catalogs.
+     */
+    isBlockedByPolicy?: boolean;
+    isPreview?: boolean;
+    /**
+     * Interaction shape of the model (`RequestResponse` | `Realtime`).
+     * The picker renders every modality it is given; a product that offers
+     * text generation only passes `filter={isTextGenerationModel}`.
+     */
+    modelType?: ModelType;
+    deprecationDetails?: DeprecationDetails | null;
+    byomDetails?: ByomDetails | null;
+    modelDetails?: ModelDetails;
+    routingDetails?: RoutingDetails | null;
+    /**
+     * Optional connection metadata. Discovery doesn't surface this directly today
+     * but BYO callers can hydrate it from `/api/byom` for richer rendering.
+     */
+    byoConnectionLabel?: string;
+}
+/**
+ * Tags rendered as chips next to a model. Derived locally from the DTO
+ * (`deriveModelTags`) — the API does not return chip strings.
+ *
+ * Open-ended on purpose: products can mint their own kinds via
+ * `customTagsFor` (e.g. `'multimodal'`, `'on-prem'`). Built-in kinds
+ * get an Apollo MUI chip variant out of the box; unknown kinds fall
+ * back to the neutral gray `mini` chip unless overridden via
+ * `ModelPickerProps.customTagVariants` or `ModelTag.variant`.
+ */
+export type ModelTagKind = 'recommended' | 'preview' | 'deprecating' | 'substituted' | 'custom' | 'out-of-region' | 'thinking' | 'cost-basic' | 'cost-standard' | 'cost-premium' | string;
+/**
+ * Categorical cost tier. By default the picker stamps the matching pool
+ * badge (`cost-basic` / `cost-standard` / `cost-premium`) on any model
+ * that carries cost data, classified by `defaultCostTier`. A host that
+ * wants different bins, or no cost chips, passes `badgesFor` — it
+ * replaces the default entirely (return `[]` to suppress).
+ */
+export type CostTier = 'basic' | 'standard' | 'premium';
+export interface ModelTag {
+    kind: ModelTagKind;
+    label: string;
+    /** Optional tooltip shown on hover. */
+    tooltip?: string;
+    /**
+     * Apollo MUI chip variant class to render this tag with. Built-in
+     * kinds resolve to a default variant automatically (e.g.
+     * `recommended` → `success-mini`). Use this for product-specific
+     * kinds, or to override the default on a built-in kind for a single
+     * tag. Falls back to `'mini'` (neutral gray) when omitted.
+     */
+    variant?: string;
+}
+/**
+ * One section in the picker dropdown. The picker groups models by
+ * subscription type by default; consumers can override via `groupBy`.
+ */
+export interface ModelGroup {
+    key: string;
+    label: string;
+    hint?: string;
+    models: DiscoveryModel[];
+}

package/dist/components/ui/model-picker/useModelPickerState.cjs

@@ -0,0 +1,250 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useModelPickerState: ()=>useModelPickerState
+});
+const external_react_namespaceObject = require("react");
+const OptionList_cjs_namespaceObject = require("./primitives/OptionList.cjs");
+const external_utils_cjs_namespaceObject = require("./utils.cjs");
+function useModelPickerState(opts) {
+    const { models, value, valueConnectionId, onChange, groupBy: initialGroupBy = "subscription", collapsibleGroups = true, recommendedModelIds, previewModelIds, filter, initiallyCollapsedGroups, labels } = opts;
+    const reactId = (0, external_react_namespaceObject.useId)().replace(/[^A-Za-z0-9_-]/g, '');
+    const id = `apollo-model-picker-${reactId}`;
+    const triggerRef = (0, external_react_namespaceObject.useRef)(null);
+    const searchRef = (0, external_react_namespaceObject.useRef)(null);
+    const [open, setOpen] = (0, external_react_namespaceObject.useState)(false);
+    const [query, setQuery] = (0, external_react_namespaceObject.useState)('');
+    const [activeIndex, setActiveIndex] = (0, external_react_namespaceObject.useState)(0);
+    const [groupBy, setGroupBy] = (0, external_react_namespaceObject.useState)(initialGroupBy);
+    const lastInitialGroupBy = (0, external_react_namespaceObject.useRef)(initialGroupBy);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (lastInitialGroupBy.current === initialGroupBy) return;
+        lastInitialGroupBy.current = initialGroupBy;
+        setGroupBy(initialGroupBy);
+    }, [
+        initialGroupBy
+    ]);
+    const [collapsedSet, setCollapsedSet] = (0, external_react_namespaceObject.useState)(()=>new Set(initiallyCollapsedGroups ?? []));
+    const visibleModels = (0, external_react_namespaceObject.useMemo)(()=>filter ? models.filter(filter) : models, [
+        models,
+        filter
+    ]);
+    const annotated = (0, external_react_namespaceObject.useMemo)(()=>{
+        const groups = (0, external_utils_cjs_namespaceObject.groupModels)(visibleModels, groupBy, {
+            recommendedModelIds,
+            previewModelIds,
+            labels
+        });
+        return groups.flatMap((g)=>g.models.map((m)=>({
+                    ...m,
+                    groupKey: g.key,
+                    groupLabel: g.label
+                })));
+    }, [
+        visibleModels,
+        groupBy,
+        recommendedModelIds,
+        previewModelIds,
+        labels
+    ]);
+    const filtered = (0, external_react_namespaceObject.useMemo)(()=>(0, external_utils_cjs_namespaceObject.filterModels)(annotated, query), [
+        annotated,
+        query
+    ]);
+    const groupCounts = (0, external_react_namespaceObject.useMemo)(()=>{
+        const out = {};
+        for (const m of annotated)out[m.groupKey] = (out[m.groupKey] ?? 0) + 1;
+        return out;
+    }, [
+        annotated
+    ]);
+    const matchesValue = (0, external_react_namespaceObject.useCallback)((m)=>{
+        if (valueConnectionId) {
+            const connId = m.byomDetails?.integrationServiceConnectionId;
+            if (connId !== valueConnectionId) return false;
+        }
+        return m.modelId === value || m.modelName === value;
+    }, [
+        value,
+        valueConnectionId
+    ]);
+    const pickMatch = (0, external_react_namespaceObject.useCallback)((list)=>{
+        const hits = list.filter(matchesValue);
+        if (0 === hits.length) return null;
+        if (valueConnectionId) return hits[0] ?? null;
+        return hits.find((m)=>!(0, external_utils_cjs_namespaceObject.isByoModel)(m)) ?? hits[0] ?? null;
+    }, [
+        matchesValue,
+        valueConnectionId
+    ]);
+    const selected = (0, external_react_namespaceObject.useMemo)(()=>pickMatch(annotated) ?? pickMatch(models), [
+        annotated,
+        models,
+        pickMatch
+    ]);
+    const unknownValue = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!value) return null;
+        if (selected) return null;
+        if (0 === models.length) return null;
+        return value;
+    }, [
+        models,
+        selected,
+        value
+    ]);
+    const canCollapse = collapsibleGroups && 'flat' !== groupBy && !query.trim();
+    const collapsedGroups = (0, external_react_namespaceObject.useMemo)(()=>canCollapse ? collapsedSet : new Set(), [
+        canCollapse,
+        collapsedSet
+    ]);
+    const toggleGroup = (0, external_react_namespaceObject.useCallback)((groupKey)=>{
+        setCollapsedSet((prev)=>{
+            const next = new Set(prev);
+            if (next.has(groupKey)) next.delete(groupKey);
+            else next.add(groupKey);
+            return next;
+        });
+    }, []);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (open) {
+            const sel = filtered.findIndex(matchesValue);
+            setActiveIndex(sel >= 0 ? sel : 0);
+            requestAnimationFrame(()=>searchRef.current?.focus());
+        } else setQuery('');
+    }, [
+        open
+    ]);
+    const isHiddenAt = (0, external_react_namespaceObject.useCallback)((i)=>{
+        const g = filtered[i]?.groupKey;
+        return void 0 !== g && (0, OptionList_cjs_namespaceObject.isCollapsibleGroup)(g) && collapsedGroups.has(g);
+    }, [
+        filtered,
+        collapsedGroups
+    ]);
+    const isCollapsedStop = (0, external_react_namespaceObject.useCallback)((i)=>isHiddenAt(i) && (0 === i || filtered[i - 1]?.groupKey !== filtered[i]?.groupKey), [
+        filtered,
+        isHiddenAt
+    ]);
+    const nearestStop = (0, external_react_namespaceObject.useCallback)((from, dir)=>{
+        for(let i = from; i >= 0 && i < filtered.length; i += dir)if (!isHiddenAt(i) || isCollapsedStop(i)) return i;
+        return -1;
+    }, [
+        filtered.length,
+        isHiddenAt,
+        isCollapsedStop
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (activeIndex >= filtered.length) return void setActiveIndex(0);
+        if (!isHiddenAt(activeIndex) || isCollapsedStop(activeIndex)) return;
+        let i = activeIndex;
+        while(i > 0 && filtered[i - 1]?.groupKey === filtered[i]?.groupKey)i -= 1;
+        setActiveIndex(i);
+    }, [
+        filtered,
+        activeIndex,
+        isHiddenAt,
+        isCollapsedStop
+    ]);
+    const activeVisible = filtered.length > 0 && !isHiddenAt(activeIndex);
+    const choose = (0, external_react_namespaceObject.useCallback)((m)=>{
+        onChange?.(m);
+        setOpen(false);
+        triggerRef.current?.focus();
+    }, [
+        onChange
+    ]);
+    const onSearchKeyDown = (0, external_react_namespaceObject.useCallback)((e)=>{
+        if ('ArrowDown' === e.key) {
+            e.preventDefault();
+            setActiveIndex((i)=>{
+                const next = nearestStop(i + 1, 1);
+                return -1 === next ? i : next;
+            });
+        } else if ('ArrowUp' === e.key) {
+            e.preventDefault();
+            setActiveIndex((i)=>{
+                const prev = nearestStop(i - 1, -1);
+                return -1 === prev ? i : prev;
+            });
+        } else if ('Enter' === e.key) {
+            e.preventDefault();
+            const m = filtered[activeIndex];
+            if (m && !isHiddenAt(activeIndex)) choose(m);
+        } else if ('ArrowLeft' === e.key || 'ArrowRight' === e.key) {
+            const groupKey = filtered[activeIndex]?.groupKey;
+            if (!groupKey || !(0, OptionList_cjs_namespaceObject.isCollapsibleGroup)(groupKey) || !canCollapse) return;
+            const collapsed = collapsedGroups.has(groupKey);
+            if ('ArrowLeft' === e.key ? !collapsed : collapsed) {
+                e.preventDefault();
+                toggleGroup(groupKey);
+            }
+        } else if ('Escape' === e.key) {
+            e.preventDefault();
+            setOpen(false);
+            triggerRef.current?.focus();
+        }
+    }, [
+        filtered,
+        activeIndex,
+        choose,
+        collapsedGroups,
+        canCollapse,
+        toggleGroup,
+        nearestStop,
+        isHiddenAt
+    ]);
+    return {
+        open,
+        setOpen,
+        query,
+        setQuery,
+        groupBy,
+        setGroupBy,
+        visibleModels,
+        annotated,
+        filtered,
+        groupCounts,
+        collapsedGroups,
+        toggleGroup,
+        selected,
+        unknownValue,
+        activeIndex,
+        setActiveIndex,
+        onSearchKeyDown,
+        choose,
+        id,
+        triggerRef,
+        searchRef,
+        activeVisible
+    };
+}
+exports.useModelPickerState = __webpack_exports__.useModelPickerState;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useModelPickerState"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});