@databricks/design-system 2.0.0 → 2.0.2

package/dist/index.js

@@ -1,10 +1,10 @@
-import { p as primitiveColors, d as DesignSystemEventProvider, e as useDesignSystemContext, f as useDesignSystemTheme, I as InfoFillIcon, C as CheckCircleFillIcon, g as WarningFillIcon, h as DangerFillIcon, i as DesignSystemEventProviderAnalyticsEventTypes, j as useDesignSystemEventComponentCallbacks, k as DesignSystemEventProviderComponentTypes, l as DesignSystemEventProviderComponentSubTypeMap, m as useNotifyOnFirstView, n as useStableUuidV4, B as Button, T as Typography, o as ChevronDownIcon, q as ChevronRightIcon, r as DesignSystemAntDConfigProvider, s as CloseSmallIcon, t as addDebugOutlineIfEnabled, v as Modal, w as getAnimationCss, x as token, S as ShapeTokens, y as getDarkModePortalStyles, L as LegacyTooltip, z as LegacyInfoCircleOutlined, A as useModalContext, R as Root$1, E as Trigger, G as InfoSmallIcon, H as Content, J as Arrow, K as SparkleDoubleIcon, O as OverflowPopover, N as LoadingState, P as visuallyHidden, Q as genSkeletonAnimatedColor, U as getOffsets, V as DesignSystemEventSuppressInteractionProviderContext, X as DesignSystemEventSuppressInteractionTrueContextValue, Y as tableStyles, Z as repeatingElementsStyles, _ as tableClassNames, $ as hideIconButtonRowStyles, a0 as hideIconButtonActionCellClassName, a1 as safex, a2 as useDialogComboboxContext, a3 as PlusIcon, a4 as importantify, a5 as getComboboxOptionItemWrapperStyles, a6 as getFooterStyles, a7 as Tooltip, a8 as useDialogComboboxOptionListContext, a9 as generateUuidV4, aa as getContentOptions, ab as findHighlightedOption, ac as highlightOption, ad as Input, ae as SearchIcon, af as EmptyResults, ag as findClosestOptionSibling, ah as DialogComboboxOptionListCheckboxItem, ai as DialogComboboxOptionListSelectItem, aj as DialogComboboxOptionListContextProvider, ak as LoadingSpinner, al as DialogComboboxOptionList, am as useUniqueId, an as useDuboisThemeClass, ao as TypeaheadComboboxContextProvider, ap as useTypeaheadComboboxContext, aq as getComboboxContentWrapperStyles, ar as ClearSelectionButton, as as TypeaheadComboboxSelectedItem, at as CountBadge, au as getValidationStateColor, av as SectionHeader, aw as useComboboxState, ax as useMultipleSelectionState, ay as Radio, az as Checkbox, aA as DialogCombobox, aB as DialogComboboxTrigger, aC as DialogComboboxContent, aD as Select, aE as SelectTrigger, aF as SelectContent, aG as SelectOption, aH as LegacySelect, aI as WarningIcon, aJ as CheckCircleIcon, aK as DangerIcon, aL as Hint, aM as Title$1, aN as CloseIcon, aO as RestoreAntDDefaultClsPrefix, aP as AccessibleContainer, aQ as DU_BOIS_ENABLE_ANIMATION_CLASSNAME, aR as CircleOffIcon, aS as CircleOutlineIcon, aT as CircleIcon, aU as shimExports, aV as SortAscendingIcon, aW as SortDescendingIcon, aX as SortUnsortedIcon, aY as MinusSquareIcon, aZ as PlusSquareIcon } from './WizardStepContentWrapper-Dvdj_FRA.js';
-export { a_ as AccessDeniedGraphic, a$ as Accordion, b0 as AccordionPanel, b1 as AlignCenterIcon, b2 as AlignJustifyIcon, b3 as AlignLeftIcon, b4 as AlignRightIcon, b5 as AlignVerticalBottomIcon, b6 as AlignVerticalCenterIcon, b7 as AlignVerticalTopIcon, b8 as AppIcon, b9 as ApplyDesignSystemContextOverrides, ba as ApplyDesignSystemFlags, bb as ArrowDownDotIcon, bc as ArrowDownFillIcon, bd as ArrowDownIcon, be as ArrowInIcon, bf as ArrowInTableIcon, bg as ArrowLeftIcon, bh as ArrowOutTableIcon, bi as ArrowOverIcon, bj as ArrowRightIcon, bk as ArrowUpDotIcon, bl as ArrowUpFillIcon, bm as ArrowUpIcon, bn as ArrowsCollapseIcon, bo as ArrowsConnectIcon, bp as ArrowsExpandIcon, bq as ArrowsUpDownIcon, br as AssistantIcon, bs as AtIcon, bt as Auth0Graphic, bu as Auth0GraphicLarge, bv as AzHorizontalIcon, bw as AzVerticalIcon, bx as BANNER_MAX_HEIGHT, by as BANNER_MIN_HEIGHT, bz as BackupIcon, bA as BadgeCodeIcon, bB as BadgeCodeOffIcon, bC as Banner, bD as BarChartIcon, bE as BarGroupedIcon, bF as BarStackedIcon, bG as BarStackedPercentageIcon, bH as BarsAscendingHorizontalIcon, bI as BarsAscendingVerticalIcon, bJ as BarsDescendingHorizontalIcon, bK as BarsDescendingVerticalIcon, bL as BeakerIcon, bM as BinaryIcon, bN as BlockQuoteIcon, bO as BoldIcon, bP as BookIcon, bQ as BookmarkFillIcon, bR as BookmarkIcon, bS as BooksIcon, bT as BracketsCheckIcon, bU as BracketsCurlyIcon, bV as BracketsErrorIcon, bW as BracketsSquareIcon, bX as BracketsXIcon, bY as BranchCheckIcon, bZ as BranchIcon, b_ as BranchResetIcon, b$ as BriefcaseFillIcon, c0 as BriefcaseIcon, c1 as BrushIcon, c2 as BugIcon, c3 as CalendarClockIcon, c4 as CalendarEventIcon, c5 as CalendarIcon, c6 as CalendarRangeIcon, c7 as CalendarSyncIcon, c8 as CameraIcon, c9 as CapitalizeIcon, ca as CaretDownSquareIcon, cb as CaretUpSquareIcon, cc as CatalogCloudIcon, cd as CatalogGearIcon, ce as CatalogHomeIcon, cf as CatalogIcon, cg as CatalogOffIcon, ch as CatalogSharedIcon, ci as CatalogUserHomeIcon, cj as CellsSquareIcon, ck as CertifiedFillIcon, cl as CertifiedFillSmallIcon, cm as CertifiedIcon, cn as ChainIcon, co as ChartLineIcon, cp as CheckCircleBadgeIcon, cq as CheckCircleSmallIcon, cr as CheckIcon, cs as CheckLineIcon, ct as CheckSmallIcon, cu as CheckboxIcon, cv as ChecklistIcon, cw as ChevronDoubleDownIcon, cx as ChevronDoubleLeftIcon, cy as ChevronDoubleLeftOffIcon, cz as ChevronDoubleRightIcon, cA as ChevronDoubleRightOffIcon, cB as ChevronDoubleUpIcon, cC as ChevronLeftIcon, cD as ChevronUpIcon, cE as ChipIcon, cF as CircleOffLargeIcon, cG as CircleOutlineLargeIcon, cH as ClipboardIcon, cI as ClockIcon, cJ as ClockKeyIcon, cK as ClockOffIcon, cL as CloudCheckIcon, cM as CloudDatabaseIcon, cN as CloudDownloadIcon, cO as CloudIcon, cP as CloudKeyIcon, cQ as CloudModelIcon, cR as CloudOffIcon, cS as CloudUploadIcon, cT as CodeIcon, cU as ColorFillIcon, cV as ColorVars, cW as ColumnIcon, cX as ColumnSplitIcon, cY as ColumnTagIcon, cZ as ColumnsIcon, c_ as CommandIcon, c$ as CommandPaletteIcon, d0 as CompassIcon, d1 as ComponentFinderContext, d2 as ConnectIcon, d3 as Content, d4 as ContextMenu, d5 as CopyIcon, d6 as CreditCardIcon, d7 as CursorClickIcon, d8 as CursorIcon, d9 as CursorPagination, da as CursorTypeIcon, db as CustomAppIcon, dc as DagHorizontalIcon, dd as DagIcon, de as DagVerticalIcon, df as DangerModal, dg as DangerSmallIcon, dh as DashIcon, di as DashboardCodeIcon, dj as DashboardIcon, dk as DataIcon, dl as DataMaskiingGraphic, dm as DatabaseClockIcon, dn as DatabaseIcon, dp as DatabaseImportIcon, dq as DatePicker, dr as DecimalIcon, ds as DeprecatedIcon, dt as DeprecatedSmallIcon, du as DesignSystemContext, dv as DesignSystemEventProviderComponentSubTypes, dw as DesignSystemProvider, dx as DesignSystemThemeContext, dy as DesignSystemThemeProvider, dz as DialogComboboxCountBadge, dA as DialogComboboxCustomButtonTriggerWrapper, dB as DialogComboboxSectionHeader, D as DocumentationSidebar, dC as DollarIcon, dD as DomainCirclesThree, dE as DomainsIcon, dF as DotsCircleIcon, dG as DownloadIcon, dH as DragIcon, dI as Drawer, dJ as DropdownMenu, dK as Empty, dL as EmptyDashboardGraphic, dM as ErdIcon, dN as ExpandLessIcon, dO as ExpandMoreIcon, F as FIXED_VERTICAL_STEPPER_WIDTH, dP as FaceFrownIcon, dQ as FaceNeutralIcon, dR as FaceSmileIcon, dS as FileCodeIcon, dT as FileCubeIcon, dU as FileDocumentIcon, dV as FileIcon, dW as FileImageIcon, dX as FileLockIcon, dY as FileModelIcon, dZ as FileNewIcon, d_ as FilePipelineIcon, d$ as FilterFillIcon, e0 as FilterIcon, e1 as FlagPointerIcon, e2 as FloatIcon, e3 as FlowIcon, e4 as FolderBranchFillIcon, e5 as FolderBranchIcon, e6 as FolderCloudFilledIcon, e7 as FolderCloudIcon, e8 as FolderCubeIcon, e9 as FolderCubeOutlineIcon, ea as FolderFillIcon, eb as FolderHomeIcon, ec as FolderIcon, ed as FolderNewIcon, ee as FolderNodeIcon, ef as FolderOpenBranchIcon, eg as FolderOpenCloudIcon, eh as FolderOpenCubeIcon, ei as FolderOpenIcon, ej as FolderOpenPipelineIcon, ek as FolderOutlinePipelineIcon, el as FolderSolidPipelineIcon, em as FontIcon, en as ForkHorizontalIcon, eo as ForkIcon, ep as Form, eq as FormContextResetBoundary, er as FullscreenExitIcon, es as FullscreenIcon, et as FunctionIcon, eu as FunctionInputIcon, ev as GavelIcon, ew as GearFillIcon, ex as GearIcon, ey as GenieCodeIcon, ez as GenieDeepResearchIcon, eA as GiftIcon, eB as GitCommitIcon, eC as GitMergeIcon, eD as GitRebaseIcon, eE as GlobeIcon, eF as Graphic, eG as GridDashIcon, eH as GridIcon, eI as GroupIcon, eJ as H1Icon, eK as H2Icon, eL as H3Icon, eM as H4Icon, eN as H5Icon, eO as H6Icon, eP as HashIcon, eQ as HistoryIcon, eR as HomeIcon, eS as Icon, eT as ImageIcon, eU as IndentDecreaseIcon, eV as IndentIncreaseIcon, eW as InfinityIcon, eX as InfoBookIcon, eY as InfoIcon, eZ as InfoTooltip, e_ as IngestionIcon, e$ as ItalicIcon, f0 as JoinOperatorIcon, f1 as KeyIcon, f2 as KeyboardIcon, f3 as LakebaseCatalogIcon, f4 as LakebaseIcon, f5 as LakeflowDesignerIcon, f6 as LayerGraphIcon, f7 as LayerIcon, f8 as Layout, f9 as LeafIcon, fa as LegacyAppstoreOutlined, fb as LegacyArrowUpOutlined, fc as LegacyBookOutlined, fd as LegacyBugOutlined, fe as LegacyCheckCircleFilled, ff as LegacyCheckCircleOutlined, fg as LegacyClockCircleFilled, fh as LegacyClockCircleOutlined, fi as LegacyCloseCircleFilled, fj as LegacyCloseOutlined, fk as LegacyCodeOutlined, fl as LegacyCommentOutlined, fm as LegacyCopyOutlined, fn as LegacyDatabaseOutlined, fo as LegacyDeleteOutlined, fp as LegacyDownOutlined, fq as LegacyEditOutlined, fr as LegacyEllipsisOutlined, fs as LegacyExclamationCircleOutlined, ft as LegacyEyeOutlined, fu as LegacyFileOutlined, fv as LegacyFileTextOutlined, fw as LegacyFilterOutlined, fx as LegacyFlagOutlined, fy as LegacyFolderOpenOutlined, fz as LegacyFolderOutlined, fA as LegacyForm, fB as LegacyFormDubois, fC as LegacyFullscreenOutlined, fD as LegacyGithubOutlined, fE as LegacyHourglassOutlined, fF as LegacyLinkOutlined, fG as LegacyLoadingOutlined, fH as LegacyNotificationOutlined, fI as LegacyOptGroup, fJ as LegacyOption, fK as LegacyPauseCircleFilled, fL as LegacyPlayCircleOutlined, fM as LegacyPlusOutlined, fN as LegacyQuestionCircleOutlined, fO as LegacyReloadOutlined, fP as LegacyRightOutlined, fQ as LegacyRocketOutlined, fR as LegacySearchOutlined, fS as LegacySelectOptGroup, fT as LegacySelectOption, fU as LegacySendOutlined, fV as LegacySettingOutlined, fW as LegacySlackOutlined, fX as LegacySwapOutlined, fY as LegacySyncOutlined, fZ as LegacyTable, f_ as LegacyUpOutlined, f$ as LegacyVideoCameraOutlined, g0 as LetterFormatIcon, g1 as LettersIcon, g2 as LettersNumbersIcon, g3 as LibrariesIcon, g4 as LifesaverIcon, g5 as LightbulbIcon, g6 as LightningCircleFillIcon, g7 as LightningIcon, g8 as LinearLineIcon, g9 as LinkIcon, ga as LinkOffIcon, gb as ListBorderIcon, gc as ListClearIcon, gd as ListIcon, ge as ListNumberIcon, gf as Listbox, gg as LoadingIcon, gh as LoadingStateContext, gi as LockFillIcon, gj as LockIcon, gk as LockShareIcon, gl as LockUnlockedIcon, gm as LoopIcon, gn as LowercaseIcon, M as MAX_VERTICAL_WIZARD_CONTENT_WIDTH, go as MailIcon, gp as MapIcon, gq as MarkdownIcon, gr as McpIcon, gs as MeasureIcon, gt as MegaphoneIcon, gu as MenuIcon, gv as MinusCircleFillIcon, gw as MinusCircleIcon, gx as MinusCircleSmallIcon, gy as MissingBranchGraphic, gz as MissingGraphic, gA as ModelsIcon, gB as MonotoneLineIcon, gC as MonthPickerGrid, gD as MoonIcon, gE as Nav, gF as NavButton, gG as NavigationMenu, gH as NeonProjectIcon, gI as NewChatIcon, gJ as NewTabIcon, gK as NewWindowIcon, gL as NoCaseIcon, gM as NoIcon, gN as NotebookIcon, gO as NotebookPipelineIcon, gP as NotificationIcon, gQ as NotificationOffIcon, gR as NumberFormatIcon, gS as NumbersIcon, gT as OfficeIcon, gU as OntologyIcon, gV as OutageGraphic, gW as Overflow, gX as OverflowHorizontalIcon, gY as OverflowIcon, gZ as PageBottomIcon, g_ as PageFirstIcon, g$ as PageIcon, h0 as PageLastIcon, h1 as PageTopIcon, h2 as Pagination, h3 as Panel, h4 as PanelBody, h5 as PanelDockedIcon, h6 as PanelFloatingIcon, h7 as PanelHeader, h8 as PanelHeaderButtons, h9 as PanelHeaderTitle, ha as PaperclipIcon, hb as PassFailChecklistIcon, hc as PauseIcon, hd as PencilFillIcon, he as PencilIcon, hf as PencilSparkleIcon, hg as PieChartIcon, hh as PillControl, hi as PinCancelIcon, hj as PinFillIcon, hk as PinIcon, hl as PipelineCodeIcon, hm as PipelineCubeIcon, hn as PipelineIcon, ho as PivotOperatorIcon, hp as PlayCircleFillIcon, hq as PlayCircleIcon, hr as PlayDoubleIcon, hs as PlayIcon, ht as PlayMultipleIcon, hu as PlugIcon, hv as PlusCircleFillIcon, hw as PlusCircleIcon, hx as PlusCircleSmallIcon, hy as PlusMinusSquareIcon, hz as Popover, hA as PositionBottomIcon, hB as PositionLeftIcon, hC as PositionRightIcon, hD as PositionTopIcon, hE as PreviewCard, hF as Progress, hG as PullRequestIcon, hH as PuzzleIcon, hI as QueryEditorIcon, hJ as QueryIcon, hK as QuestionMarkFillIcon, hL as QuestionMarkIcon, hM as RadioIcon, hN as RadioTile, hO as RangePicker, hP as ReaderModeIcon, hQ as RedoIcon, hR as RefreshIcon, hS as RefreshPlayIcon, hT as RefreshXIcon, hU as ReplyIcon, hV as ResizeIcon, hW as RhfForm, hX as RichTextIcon, hY as RobotIcon, hZ as RocketIcon, h_ as RowsIcon, h$ as RunIcon, i0 as RunningIcon, i1 as SMALL_BUTTON_HEIGHT, i2 as SaveClockIcon, i3 as SaveIcon, i4 as SchemaIcon, i5 as SchoolIcon, i6 as SearchDataIcon, i7 as SegmentedControlButton, i8 as SegmentedControlGroup, i9 as SelectContext, ia as SelectContextProvider, ib as SelectOptionGroup, ic as SendIcon, id as ShareIcon, ie as ShareNodesIcon, ig as ShieldCheckIcon, ih as ShieldIcon, ii as ShieldOffIcon, ij as ShortcutIcon, ik as Sidebar, il as SidebarAutoIcon, im as SidebarClosedIcon, io as SidebarCollapseIcon, ip as SidebarExpandIcon, iq as SidebarIcon, ir as SidebarOpenIcon, is as SidebarSyncIcon, it as SimpleSelect, iu as SimpleSelectOption, iv as SimpleSelectOptionGroup, iw as SlashSquareIcon, ix as Slider, iy as SlidersIcon, iz as SnippetIcon, iA as SortCustomHorizontalIcon, iB as SortCustomVerticalIcon, iC as SortHorizontalAscendingIcon, iD as SortHorizontalDescendingIcon, iE as SortLetterHorizontalAscendingIcon, iF as SortLetterHorizontalDescendingIcon, iG as SortLetterUnsortedIcon, iH as SortLetterVerticalAscendingIcon, iI as SortLetterVerticalDescendingIcon, iJ as Spacer, iK as SparkleDoubleFillIcon, iL as SparkleFillIcon, iM as SparkleIcon, iN as SparkleRectangleIcon, iO as SpeechBubbleIcon, iP as SpeechBubblePlusIcon, iQ as SpeechBubbleQuestionMarkFillIcon, iR as SpeechBubbleQuestionMarkIcon, iS as SpeechBubbleStarIcon, iT as SpeedometerIcon, iU as Spinner, iV as SplitButton, iW as SqlIcon, iX as StarFillIcon, iY as StarIcon, iZ as StepAfterLineIcon, i_ as StepBeforeLineIcon, i$ as Stepper, j0 as StopCircleFillIcon, j1 as StopCircleIcon, j2 as StopIcon, j3 as StoredProcedureIcon, j4 as StorefrontIcon, j5 as StreamIcon, j6 as StrikeThroughIcon, j7 as SunIcon, j8 as SyncIcon, j9 as SyncSmallIcon, ja as SyncToFileIcon, jb as TableAsteriskIcon, jc as TableClockIcon, jd as TableCombineIcon, je as TableGlassesIcon, jf as TableGlobeIcon, jg as TableIcon, jh as TableLightningIcon, ji as TableMeasureIcon, jj as TableModelIcon, jk as TableReportIcon, jl as TableStreamIcon, jm as TableVectorIcon, jn as TableViewIcon, jo as Tabs, jp as Tag, jq as TagColumnIcon, jr as TagIcon, js as TagTableIcon, jt as TargetIcon, ju as TerminalIcon, jv as TextBoxIcon, jw as TextColorIcon, jx as TextIcon, jy as TextJustifyIcon, jz as TextUnderlineIcon, jA as ThreeDotsIcon, jB as ThumbsDownFilledIcon, jC as ThumbsDownIcon, jD as ThumbsUpFilledIcon, jE as ThumbsUpIcon, jF as ToggleButton, jG as TokenIcon, jH as Toolbar, jI as TrashIcon, jJ as Tree, jK as TreeIcon, jL as TrendingFillIcon, jM as TrendingIcon, jN as TriangleIcon, jO as TypeaheadComboboxCheckboxItem, jP as TypeaheadComboboxFooter, jQ as TypeaheadComboboxMenuItem, jR as TypeaheadComboboxMultiSelectStateChangeTypes, jS as TypeaheadComboboxStateChangeTypes, jT as UnderlineIcon, jU as UndoIcon, jV as UploadIcon, jW as UppercaseIcon, jX as UsageOverageGraphic, jY as UsageSpikeGraphic, jZ as UsbIcon, j_ as UserBadgeIcon, j$ as UserCircleIcon, k0 as UserGroupFillIcon, k1 as UserGroupIcon, k2 as UserIcon, k3 as UserKeyIconIcon, k4 as UserShieldIcon, k5 as UserSparkleIcon, k6 as UserTeamIcon, k7 as VisibleFillIcon, k8 as VisibleIcon, k9 as VisibleOffIcon, ka as WithDesignSystemThemeHoc, W as Wizard, a as WizardControlled, b as WizardModal, c as WizardStepContentWrapper, kb as WorkflowCodeIcon, kc as WorkflowCubeIcon, kd as WorkflowsIcon, ke as WorkspacesIcon, kf as WrenchIcon, kg as WrenchSparkleIcon, kh as XCircleFillIcon, ki as XCircleIcon, kj as YearPickerGrid, kk as ZaHorizontalIcon, kl as ZaVerticalIcon, km as ZeroOpsIcon, kn as ZeroOpsOutlineIcon, ko as ZoomInIcon, kp as ZoomMarqueeSelection, kq as ZoomOutIcon, kr as ZoomToFitIcon, ks as __INTERNAL_DO_NOT_USE__FormItem, kt as __INTERNAL_DO_NOT_USE__Group, ku as __INTERNAL_DO_NOT_USE__HorizontalGroup, kv as __INTERNAL_DO_NOT_USE__VerticalGroup, kw as __INTERNAL_DO_NOT_USE__wrapLegacyFormRules, kx as augmentWithDataComponentProps, ky as dialogComboboxLookAheadKeyDown, kz as getBottomOnlyShadowScrollStyles, kA as getButtonEmotionStyles, kB as getComboboxOptionLabelStyles, kC as getDatePickerQuickActionBasic, kD as getDialogComboboxOptionLabelWidth, kE as getHorizontalTabShadowStyles, kF as getInputStyles, kG as getKeyboardNavigationFunctions, kH as getMemoizedButtonEmotionStyles, kI as getPaginationEmotionStyles, kJ as getPanelContainmentStyle, kK as getRadioStyles, kL as getRangeQuickActionsBasic, kM as getShadowScrollStyles, kN as getTypographyColor, kO as getVirtualListScrollbarStyles, kP as getVirtualListScrollbarThumbColor, kQ as getVirtualizedComboboxMenuItemStyles, kR as getWrapperStyle, kS as highlightFirstNonDisabledOption, kT as isOptionDisabled, kU as resetTabIndexToFocusedElement, kV as setImplicitContextGetter, kW as skipHideIconButtonActionClassName, kX as themeMemoKey, kY as useAntDConfigProviderContext, kZ as useCallbackOnEnter, k_ as useComponentFinderContext, k$ as useDesignSystemEventSuppressInteractionContext, l0 as useFormContext, l1 as useRadioGroupContext, l2 as useRadixModalContext, u as useWizardCurrentStep } from './WizardStepContentWrapper-Dvdj_FRA.js';
+import { p as primitiveColors, d as DesignSystemEventProvider, e as useDesignSystemContext, f as useDesignSystemTheme, I as InfoFillIcon, C as CheckCircleFillIcon, g as WarningFillIcon, h as DangerFillIcon, i as DesignSystemEventProviderAnalyticsEventTypes, j as useDesignSystemEventComponentCallbacks, k as DesignSystemEventProviderComponentTypes, l as DesignSystemEventProviderComponentSubTypeMap, m as useNotifyOnFirstView, n as useStableUuidV4, B as Button, T as Typography, o as ChevronDownIcon, q as ChevronRightIcon, r as DesignSystemAntDConfigProvider, s as CloseSmallIcon, t as addDebugOutlineIfEnabled, v as Modal, w as getAnimationCss, x as token, S as ShapeTokens, y as getDarkModePortalStyles, z as useModalContext, R as Root$1, A as Trigger, E as InfoSmallIcon, G as Content, H as Arrow, J as SparkleDoubleIcon, O as OverflowPopover, L as LoadingState, K as visuallyHidden, N as genSkeletonAnimatedColor, P as getOffsets, Q as DesignSystemEventSuppressInteractionProviderContext, U as DesignSystemEventSuppressInteractionTrueContextValue, V as tableStyles, X as repeatingElementsStyles, Y as tableClassNames, Z as hideIconButtonRowStyles, _ as hideIconButtonActionCellClassName, $ as safex, a0 as TitleSkeleton, a1 as useDialogComboboxContext, a2 as PlusIcon, a3 as importantify, a4 as getComboboxOptionItemWrapperStyles, a5 as getFooterStyles, a6 as Tooltip, a7 as useDialogComboboxOptionListContext, a8 as generateUuidV4, a9 as getContentOptions, aa as findHighlightedOption, ab as highlightOption, ac as Input, ad as SearchIcon, ae as EmptyResults, af as findClosestOptionSibling, ag as DialogComboboxOptionListCheckboxItem, ah as DialogComboboxOptionListSelectItem, ai as DialogComboboxOptionListContextProvider, aj as LoadingSpinner, ak as DialogComboboxOptionList, al as useUniqueId, am as useDuboisThemeClass, an as TypeaheadComboboxContextProvider, ao as useTypeaheadComboboxContext, ap as getComboboxContentWrapperStyles, aq as ClearSelectionButton, ar as TypeaheadComboboxSelectedItem, as as CountBadge, at as getValidationStateColor, au as SectionHeader, av as useComboboxState$1, aw as useMultipleSelectionState$1, ax as Radio, ay as Checkbox, az as DialogCombobox, aA as DialogComboboxTrigger, aB as DialogComboboxContent, aC as Select, aD as SelectTrigger, aE as SelectContent, aF as SelectOption, aG as LegacySelect, aH as WarningIcon, aI as CheckCircleIcon, aJ as DangerIcon, aK as Hint, aL as Title$1, aM as CloseIcon, aN as RestoreAntDDefaultClsPrefix, aO as AccessibleContainer, aP as DU_BOIS_ENABLE_ANIMATION_CLASSNAME, aQ as CircleOffIcon, aR as CircleOutlineIcon, aS as CircleIcon, aT as shimExports, aU as SortAscendingIcon, aV as SortDescendingIcon, aW as SortUnsortedIcon, aX as MinusSquareIcon, aY as PlusSquareIcon, aZ as TypeaheadComboboxReactAriaContextProvider, a_ as useTypeaheadComboboxReactAriaContext, a$ as useRadixModalContext, b0 as useIsomorphicLayoutEffect, b1 as useScrollOptionIntoView, b2 as InfoTooltip, b3 as getInfoIconStyles, b4 as HintRow, b5 as getCheckboxStyles, b6 as getMenuItemStyles, b7 as TypeaheadComboboxSelectedItem$1, b8 as CountBadge$1, b9 as TypeaheadComboboxMenuItem } from './WizardStepContentWrapper-DnwQIMN1.js';
+export { ba as AccessDeniedGraphic, bb as Accordion, bc as AccordionPanel, bd as AlignCenterIcon, be as AlignJustifyIcon, bf as AlignLeftIcon, bg as AlignRightIcon, bh as AlignVerticalBottomIcon, bi as AlignVerticalCenterIcon, bj as AlignVerticalTopIcon, bk as AppIcon, bl as ApplyDesignSystemContextOverrides, bm as ApplyDesignSystemFlags, bn as ArrowDownDotIcon, bo as ArrowDownFillIcon, bp as ArrowDownIcon, bq as ArrowInIcon, br as ArrowInTableIcon, bs as ArrowLeftIcon, bt as ArrowOutTableIcon, bu as ArrowOverIcon, bv as ArrowRightIcon, bw as ArrowUpDotIcon, bx as ArrowUpFillIcon, by as ArrowUpIcon, bz as ArrowsCollapseIcon, bA as ArrowsConnectIcon, bB as ArrowsExpandIcon, bC as ArrowsUpDownIcon, bD as AssistantIcon, bE as AtIcon, bF as Auth0Graphic, bG as Auth0GraphicLarge, bH as AzHorizontalIcon, bI as AzVerticalIcon, bJ as BANNER_MAX_HEIGHT, bK as BANNER_MIN_HEIGHT, bL as BackupIcon, bM as BadgeCodeIcon, bN as BadgeCodeOffIcon, bO as Banner, bP as BarChartIcon, bQ as BarGroupedIcon, bR as BarStackedIcon, bS as BarStackedPercentageIcon, bT as BarsAscendingHorizontalIcon, bU as BarsAscendingVerticalIcon, bV as BarsDescendingHorizontalIcon, bW as BarsDescendingVerticalIcon, bX as BeakerIcon, bY as BinaryIcon, bZ as BlockQuoteIcon, b_ as BoldIcon, b$ as BookIcon, c0 as BookmarkFillIcon, c1 as BookmarkIcon, c2 as BooksIcon, c3 as BracketsCheckIcon, c4 as BracketsCurlyIcon, c5 as BracketsErrorIcon, c6 as BracketsSquareIcon, c7 as BracketsXIcon, c8 as BranchCheckIcon, c9 as BranchIcon, ca as BranchResetIcon, cb as BriefcaseFillIcon, cc as BriefcaseIcon, cd as BrushIcon, ce as BugIcon, cf as CalendarClockIcon, cg as CalendarEventIcon, ch as CalendarIcon, ci as CalendarRangeIcon, cj as CalendarSyncIcon, ck as CameraIcon, cl as CapitalizeIcon, cm as CaretDownSquareIcon, cn as CaretUpSquareIcon, co as CatalogCloudIcon, cp as CatalogGearIcon, cq as CatalogHomeIcon, cr as CatalogIcon, cs as CatalogOffIcon, ct as CatalogSharedIcon, cu as CatalogUserHomeIcon, cv as CellsSquareIcon, cw as CertifiedFillIcon, cx as CertifiedFillSmallIcon, cy as CertifiedIcon, cz as ChainIcon, cA as ChartLineIcon, cB as CheckCircleBadgeIcon, cC as CheckCircleSmallIcon, cD as CheckIcon, cE as CheckLineIcon, cF as CheckSmallIcon, cG as CheckboxIcon, cH as ChecklistIcon, cI as ChevronDoubleDownIcon, cJ as ChevronDoubleLeftIcon, cK as ChevronDoubleLeftOffIcon, cL as ChevronDoubleRightIcon, cM as ChevronDoubleRightOffIcon, cN as ChevronDoubleUpIcon, cO as ChevronLeftIcon, cP as ChevronUpIcon, cQ as ChipIcon, cR as CircleOffLargeIcon, cS as CircleOutlineLargeIcon, cT as ClipboardIcon, cU as ClockIcon, cV as ClockKeyIcon, cW as ClockOffIcon, cX as CloudCheckIcon, cY as CloudDatabaseIcon, cZ as CloudDownloadIcon, c_ as CloudIcon, c$ as CloudKeyIcon, d0 as CloudModelIcon, d1 as CloudOffIcon, d2 as CloudUploadIcon, d3 as CodeIcon, d4 as ColorFillIcon, d5 as ColorVars, d6 as ColumnIcon, d7 as ColumnSplitIcon, d8 as ColumnTagIcon, d9 as ColumnsIcon, da as CommandIcon, db as CommandPaletteIcon, dc as CompassIcon, dd as ComponentFinderContext, de as ConnectIcon, df as Content, dg as ContextMenu, dh as CopyIcon, di as CreditCardIcon, dj as CursorClickIcon, dk as CursorIcon, dl as CursorPagination, dm as CursorTypeIcon, dn as CustomAppIcon, dp as DagHorizontalIcon, dq as DagIcon, dr as DagVerticalIcon, ds as DangerModal, dt as DangerSmallIcon, du as DashIcon, dv as DashboardCodeIcon, dw as DashboardIcon, dx as DataIcon, dy as DataMaskiingGraphic, dz as DatabaseClockIcon, dA as DatabaseIcon, dB as DatabaseImportIcon, dC as DatePicker, dD as DecimalIcon, dE as DeprecatedIcon, dF as DeprecatedSmallIcon, dG as DesignSystemContext, dH as DesignSystemEventProviderComponentSubTypes, dI as DesignSystemProvider, dJ as DesignSystemThemeContext, dK as DesignSystemThemeProvider, dL as DialogComboboxCountBadge, dM as DialogComboboxCustomButtonTriggerWrapper, dN as DialogComboboxSectionHeader, D as DocumentationSidebar, dO as DollarIcon, dP as DomainCirclesThree, dQ as DomainsIcon, dR as DotsCircleIcon, dS as DownloadIcon, dT as DragIcon, dU as Drawer, dV as DropdownMenu, dW as Empty, dX as EmptyDashboardGraphic, dY as ErdIcon, dZ as ExpandLessIcon, d_ as ExpandMoreIcon, F as FIXED_VERTICAL_STEPPER_WIDTH, d$ as FaceFrownIcon, e0 as FaceNeutralIcon, e1 as FaceSmileIcon, e2 as FileCodeIcon, e3 as FileCubeIcon, e4 as FileDocumentIcon, e5 as FileIcon, e6 as FileImageIcon, e7 as FileLockIcon, e8 as FileModelIcon, e9 as FileNewIcon, ea as FilePipelineIcon, eb as FilterFillIcon, ec as FilterIcon, ed as FlagPointerIcon, ee as FloatIcon, ef as FlowIcon, eg as FlowsIcon, eh as FolderBranchFillIcon, ei as FolderBranchIcon, ej as FolderCloudFilledIcon, ek as FolderCloudIcon, el as FolderCubeIcon, em as FolderCubeOutlineIcon, en as FolderFillIcon, eo as FolderHomeIcon, ep as FolderIcon, eq as FolderNewIcon, er as FolderNodeIcon, es as FolderOpenBranchIcon, et as FolderOpenCloudIcon, eu as FolderOpenCubeIcon, ev as FolderOpenIcon, ew as FolderOpenPipelineIcon, ex as FolderOutlinePipelineIcon, ey as FolderSolidPipelineIcon, ez as FontIcon, eA as ForkHorizontalIcon, eB as ForkIcon, eC as Form, eD as FormContextResetBoundary, eE as FullscreenExitIcon, eF as FullscreenIcon, eG as FunctionIcon, eH as FunctionInputIcon, eI as GavelIcon, eJ as GearFillIcon, eK as GearIcon, eL as GenieCodeIcon, eM as GenieDeepResearchIcon, eN as GiftIcon, eO as GitCommitIcon, eP as GitMergeIcon, eQ as GitRebaseIcon, eR as GlobeIcon, eS as Graphic, eT as GridDashIcon, eU as GridIcon, eV as GroupIcon, eW as H1Icon, eX as H2Icon, eY as H3Icon, eZ as H4Icon, e_ as H5Icon, e$ as H6Icon, f0 as HashIcon, f1 as HistoryIcon, f2 as HomeIcon, f3 as Icon, f4 as ImageIcon, f5 as IndentDecreaseIcon, f6 as IndentIncreaseIcon, f7 as InfinityIcon, f8 as InfoBookIcon, f9 as InfoIcon, fa as IngestionIcon, fb as ItalicIcon, fc as JoinOperatorIcon, fd as KeyIcon, fe as KeyboardIcon, ff as LakebaseCatalogIcon, fg as LakebaseIcon, fh as LakeflowDesignerIcon, fi as LakewatchAlertIcon, fj as LakewatchDatasourceIcon, fk as LakewatchDetectionRuleIcon, fl as LakewatchParserIcon, fm as LayerGraphIcon, fn as LayerIcon, fo as Layout, fp as LeafIcon, fq as LegacyAppstoreOutlined, fr as LegacyArrowUpOutlined, fs as LegacyBookOutlined, ft as LegacyBugOutlined, fu as LegacyCheckCircleFilled, fv as LegacyCheckCircleOutlined, fw as LegacyClockCircleFilled, fx as LegacyClockCircleOutlined, fy as LegacyCloseCircleFilled, fz as LegacyCloseOutlined, fA as LegacyCodeOutlined, fB as LegacyCommentOutlined, fC as LegacyCopyOutlined, fD as LegacyDatabaseOutlined, fE as LegacyDeleteOutlined, fF as LegacyDownOutlined, fG as LegacyEditOutlined, fH as LegacyEllipsisOutlined, fI as LegacyExclamationCircleOutlined, fJ as LegacyEyeOutlined, fK as LegacyFileOutlined, fL as LegacyFileTextOutlined, fM as LegacyFilterOutlined, fN as LegacyFlagOutlined, fO as LegacyFolderOpenOutlined, fP as LegacyFolderOutlined, fQ as LegacyForm, fR as LegacyFormDubois, fS as LegacyFullscreenOutlined, fT as LegacyGithubOutlined, fU as LegacyHourglassOutlined, fV as LegacyInfoCircleOutlined, fW as LegacyLinkOutlined, fX as LegacyLoadingOutlined, fY as LegacyNotificationOutlined, fZ as LegacyOptGroup, f_ as LegacyOption, f$ as LegacyPauseCircleFilled, g0 as LegacyPlayCircleOutlined, g1 as LegacyPlusOutlined, g2 as LegacyQuestionCircleOutlined, g3 as LegacyReloadOutlined, g4 as LegacyRightOutlined, g5 as LegacyRocketOutlined, g6 as LegacySearchOutlined, g7 as LegacySelectOptGroup, g8 as LegacySelectOption, g9 as LegacySendOutlined, ga as LegacySettingOutlined, gb as LegacySlackOutlined, gc as LegacySwapOutlined, gd as LegacySyncOutlined, ge as LegacyTable, gf as LegacyTooltip, gg as LegacyUpOutlined, gh as LegacyVideoCameraOutlined, gi as LetterFormatIcon, gj as LettersIcon, gk as LettersNumbersIcon, gl as LibrariesIcon, gm as LifesaverIcon, gn as LightbulbIcon, go as LightningCircleFillIcon, gp as LightningIcon, gq as LinearLineIcon, gr as LinkIcon, gs as LinkOffIcon, gt as ListBorderIcon, gu as ListClearIcon, gv as ListIcon, gw as ListNumberIcon, gx as Listbox, gy as LoadingIcon, gz as LoadingStateContext, gA as LockFillIcon, gB as LockIcon, gC as LockShareIcon, gD as LockUnlockedIcon, gE as LoopIcon, gF as LowercaseIcon, M as MAX_VERTICAL_WIZARD_CONTENT_WIDTH, gG as MailIcon, gH as MapIcon, gI as MarkdownIcon, gJ as McpIcon, gK as MeasureIcon, gL as MegaphoneIcon, gM as MenuIcon, gN as MinusCircleFillIcon, gO as MinusCircleIcon, gP as MinusCircleSmallIcon, gQ as MissingBranchGraphic, gR as MissingGraphic, gS as ModelsIcon, gT as MonotoneLineIcon, gU as MonthPickerGrid, gV as MoonIcon, gW as Nav, gX as NavButton, gY as NavigationMenu, gZ as NeonProjectIcon, g_ as NewChatIcon, g$ as NewTabIcon, h0 as NewWindowIcon, h1 as NoCaseIcon, h2 as NoIcon, h3 as NotebookIcon, h4 as NotebookPipelineIcon, h5 as NotificationIcon, h6 as NotificationOffIcon, h7 as NumberFormatIcon, h8 as NumbersIcon, h9 as OfficeIcon, ha as OntologyIcon, hb as OutageGraphic, hc as Overflow, hd as OverflowHorizontalIcon, he as OverflowIcon, hf as PageBottomIcon, hg as PageFirstIcon, hh as PageIcon, hi as PageLastIcon, hj as PageTopIcon, hk as Pagination, hl as Panel, hm as PanelBody, hn as PanelDockedIcon, ho as PanelFloatingIcon, hp as PanelHeader, hq as PanelHeaderButtons, hr as PanelHeaderTitle, hs as PaperclipIcon, ht as PassFailChecklistIcon, hu as PauseIcon, hv as PencilFillIcon, hw as PencilIcon, hx as PencilSparkleIcon, hy as PieChartIcon, hz as PillControl, hA as PinCancelIcon, hB as PinFillIcon, hC as PinIcon, hD as PipelineCodeIcon, hE as PipelineCubeIcon, hF as PipelineIcon, hG as PivotOperatorIcon, hH as PlayCircleFillIcon, hI as PlayCircleIcon, hJ as PlayDoubleIcon, hK as PlayIcon, hL as PlayMultipleIcon, hM as PlugIcon, hN as PlusCircleFillIcon, hO as PlusCircleIcon, hP as PlusCircleSmallIcon, hQ as PlusMinusSquareIcon, hR as Popover, hS as PositionBottomIcon, hT as PositionLeftIcon, hU as PositionRightIcon, hV as PositionTopIcon, hW as PreviewCard, hX as Progress, hY as PullRequestIcon, hZ as PuzzleIcon, h_ as QueryEditorIcon, h$ as QueryIcon, i0 as QuestionMarkFillIcon, i1 as QuestionMarkIcon, i2 as RadioIcon, i3 as RadioTile, i4 as RangePicker, i5 as ReaderModeIcon, i6 as RedoIcon, i7 as RefreshIcon, i8 as RefreshPlayIcon, i9 as RefreshXIcon, ia as ReplyIcon, ib as ResizeIcon, ic as RhfForm, id as RichTextIcon, ie as RobotIcon, ig as RocketIcon, ih as RowsIcon, ii as RunIcon, ij as RunningIcon, ik as SMALL_BUTTON_HEIGHT, il as SaveClockIcon, im as SaveIcon, io as SchemaIcon, ip as SchoolIcon, iq as SearchDataIcon, ir as SegmentedControlButton, is as SegmentedControlGroup, it as SelectContext, iu as SelectContextProvider, iv as SelectOptionGroup, iw as SendIcon, ix as ShareIcon, iy as ShareNodesIcon, iz as ShieldCheckIcon, iA as ShieldIcon, iB as ShieldOffIcon, iC as ShortcutIcon, iD as Sidebar, iE as SidebarAutoIcon, iF as SidebarClosedIcon, iG as SidebarCollapseIcon, iH as SidebarExpandIcon, iI as SidebarIcon, iJ as SidebarOpenIcon, iK as SidebarSyncIcon, iL as SimpleSelect, iM as SimpleSelectOption, iN as SimpleSelectOptionGroup, iO as SlashSquareIcon, iP as Slider, iQ as SlidersIcon, iR as SnippetIcon, iS as SortCustomHorizontalIcon, iT as SortCustomVerticalIcon, iU as SortHorizontalAscendingIcon, iV as SortHorizontalDescendingIcon, iW as SortLetterHorizontalAscendingIcon, iX as SortLetterHorizontalDescendingIcon, iY as SortLetterUnsortedIcon, iZ as SortLetterVerticalAscendingIcon, i_ as SortLetterVerticalDescendingIcon, i$ as Spacer, j0 as SparkleDoubleFillIcon, j1 as SparkleFillIcon, j2 as SparkleIcon, j3 as SparkleRectangleIcon, j4 as SpeechBubbleIcon, j5 as SpeechBubblePlusIcon, j6 as SpeechBubbleQuestionMarkFillIcon, j7 as SpeechBubbleQuestionMarkIcon, j8 as SpeechBubbleStarIcon, j9 as SpeedometerIcon, ja as Spinner, jb as SplitButton, jc as SqlIcon, jd as StarFillIcon, je as StarIcon, jf as StepAfterLineIcon, jg as StepBeforeLineIcon, jh as Stepper, ji as StopCircleFillIcon, jj as StopCircleIcon, jk as StopIcon, jl as StoredProcedureIcon, jm as StorefrontIcon, jn as StreamIcon, jo as StrikeThroughIcon, jp as SunIcon, jq as SyncIcon, jr as SyncSmallIcon, js as SyncToFileIcon, jt as TableAsteriskIcon, ju as TableClockIcon, jv as TableCombineIcon, jw as TableGlassesIcon, jx as TableGlobeIcon, jy as TableIcon, jz as TableLightningIcon, jA as TableMeasureIcon, jB as TableModelIcon, jC as TableReportIcon, jD as TableStreamIcon, jE as TableVectorIcon, jF as TableViewIcon, jG as Tabs, jH as Tag, jI as TagColumnIcon, jJ as TagIcon, jK as TagTableIcon, jL as TargetIcon, jM as TerminalIcon, jN as TextBoxIcon, jO as TextColorIcon, jP as TextIcon, jQ as TextJustifyIcon, jR as TextUnderlineIcon, jS as ThreeDotsIcon, jT as ThumbsDownFilledIcon, jU as ThumbsDownIcon, jV as ThumbsUpFilledIcon, jW as ThumbsUpIcon, jX as ToggleButton, jY as TokenIcon, jZ as Toolbar, j_ as TrashIcon, j$ as Tree, k0 as TreeIcon, k1 as TrendingFillIcon, k2 as TrendingIcon, k3 as TriangleIcon, k4 as TypeaheadComboboxCheckboxItem, k5 as TypeaheadComboboxFooter, k6 as TypeaheadComboboxMenuItem, k7 as TypeaheadComboboxMultiSelectStateChangeTypes, k8 as TypeaheadComboboxStateChangeTypes, k9 as UnderlineIcon, ka as UndoIcon, kb as UploadIcon, kc as UppercaseIcon, kd as UsageOverageGraphic, ke as UsageSpikeGraphic, kf as UsbIcon, kg as UserBadgeIcon, kh as UserCircleIcon, ki as UserGroupFillIcon, kj as UserGroupIcon, kk as UserIcon, kl as UserKeyIconIcon, km as UserShieldIcon, kn as UserSparkleIcon, ko as UserTeamIcon, kp as VisibleFillIcon, kq as VisibleIcon, kr as VisibleOffIcon, ks as WithDesignSystemThemeHoc, W as Wizard, a as WizardControlled, b as WizardModal, c as WizardStepContentWrapper, kt as WorkflowCodeIcon, ku as WorkflowCubeIcon, kv as WorkflowsIcon, kw as WorkspacesIcon, kx as WrenchIcon, ky as WrenchSparkleIcon, kz as XCircleFillIcon, kA as XCircleIcon, kB as YearPickerGrid, kC as ZaHorizontalIcon, kD as ZaVerticalIcon, kE as ZeroOpsIcon, kF as ZeroOpsOutlineIcon, kG as ZoomInIcon, kH as ZoomMarqueeSelection, kI as ZoomOutIcon, kJ as ZoomToFitIcon, kK as __INTERNAL_DO_NOT_USE__FormItem, kL as __INTERNAL_DO_NOT_USE__Group, kM as __INTERNAL_DO_NOT_USE__HorizontalGroup, kN as __INTERNAL_DO_NOT_USE__VerticalGroup, kO as __INTERNAL_DO_NOT_USE__wrapLegacyFormRules, kP as augmentWithDataComponentProps, kQ as dialogComboboxLookAheadKeyDown, kR as getBottomOnlyShadowScrollStyles, kS as getButtonEmotionStyles, kT as getComboboxOptionLabelStyles, kU as getDatePickerQuickActionBasic, kV as getDialogComboboxOptionLabelWidth, kW as getHorizontalTabShadowStyles, kX as getInputStyles, kY as getKeyboardNavigationFunctions, kZ as getMemoizedButtonEmotionStyles, k_ as getPaginationEmotionStyles, k$ as getPanelContainmentStyle, l0 as getRadioStyles, l1 as getRangeQuickActionsBasic, l2 as getShadowScrollStyles, l3 as getTypographyColor, l4 as getVirtualListScrollbarStyles, l5 as getVirtualListScrollbarThumbColor, l6 as getVirtualizedComboboxMenuItemStyles, l7 as getWrapperStyle, l8 as highlightFirstNonDisabledOption, l9 as isOptionDisabled, la as resetTabIndexToFocusedElement, lb as setImplicitContextGetter, lc as skipHideIconButtonActionClassName, ld as themeMemoKey, le as useAntDConfigProviderContext, lf as useCallbackOnEnter, lg as useComponentFinderContext, lh as useDesignSystemEventSuppressInteractionContext, li as useFormContext, lj as useRadioGroupContext, u as useWizardCurrentStep } from './WizardStepContentWrapper-DnwQIMN1.js';
 import { jsx, jsxs, Fragment } from '@emotion/react/jsx-runtime';
 import { css, Global, createElement, ClassNames, keyframes } from '@emotion/react';
 import { Alert as Alert$1, AutoComplete as AutoComplete$1, Breadcrumb as Breadcrumb$1, DatePicker, Dropdown as Dropdown$1, Switch as Switch$1, Col as Col$1, Row as Row$1, Space as Space$1, notification, Popover, Skeleton, Menu as Menu$1, Steps as Steps$1 } from 'antd';
 import classnames from 'classnames';
-import React__default, { useState, useRef, useEffect, useCallback, useMemo, forwardRef, useImperativeHandle, createContext, useContext, Children, Fragment as Fragment$1, useLayoutEffect, useReducer } from 'react';
+import React__default, { useState, useRef, useEffect, useCallback, useMemo, forwardRef, useImperativeHandle, createContext, useContext, Children, Fragment as Fragment$1, useLayoutEffect, useReducer, isValidElement } from 'react';
 import '@ant-design/icons';
 import { useMergeRefs, useFloating, autoUpdate, offset, flip, shift } from '@floating-ui/react';
 import isUndefined from 'lodash/isUndefined';
@@ -17,6 +17,15 @@ import { computePosition, flip as flip$1, size } from '@floating-ui/dom';
 import { createPortal } from 'react-dom';
 import * as RadixHoverCard from '@radix-ui/react-hover-card';
 import * as Toast from '@radix-ui/react-toast';
+import { useComboBox } from '@react-aria/combobox';
+import { useListBox, useOption } from '@react-aria/listbox';
+import { useOverlay, useOverlayPosition, Overlay, DismissButton } from '@react-aria/overlays';
+import { mergeRefs, mergeProps } from '@react-aria/utils';
+import { createFocusManager } from '@react-aria/focus';
+import { useButton } from '@react-aria/button';
+import { useComboBoxState } from '@react-stately/combobox';
+import { useFilter } from '@react-aria/i18n';
+import { Item } from '@react-stately/collections';
 import 'date-fns';
 import '@radix-ui/react-popover';
 import '@radix-ui/react-dropdown-menu';
@@ -133,7 +142,8 @@ const consumerDarkColorList = {
     textValidationDanger: primitiveColors.red500,
     textValidationSuccess: primitiveColors.green500,
     textValidationWarning: primitiveColors.yellow500,
-    tooltipBackgroundTooltip: primitiveColors.grey100
+    tooltipBackgroundTooltip: primitiveColors.grey100,
+    tooltipTextTooltip: primitiveColors.grey800
 };
 
 // THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.
@@ -218,7 +228,8 @@ const consumerLightColorList = {
     textValidationDanger: primitiveColors.red600,
     textValidationSuccess: primitiveColors.green600,
     textValidationWarning: primitiveColors.yellow600,
-    tooltipBackgroundTooltip: primitiveColors.neutral800
+    tooltipBackgroundTooltip: primitiveColors.neutral800,
+    tooltipTextTooltip: primitiveColors.white
 };
 
 /**
@@ -892,35 +903,6 @@ function SvgUserIcon(props) {
     });
 }
 
-/**
- * `LegacyInfoTooltip` is deprecated in favor of the new `InfoTooltip` component
- * @deprecated
- */ const LegacyInfoTooltip = ({ title, tooltipProps, iconTitle, isKeyboardFocusable = true, ...iconProps })=>{
-    const { theme } = useDesignSystemTheme();
-    return /*#__PURE__*/ jsx(LegacyTooltip, {
-        useAsLabel: true,
-        title: title,
-        ...tooltipProps,
-        children: /*#__PURE__*/ jsx("span", {
-            ...addDebugOutlineIfEnabled(),
-            style: {
-                display: 'inline-flex'
-            },
-            children: /*#__PURE__*/ jsx(LegacyInfoCircleOutlined, {
-                tabIndex: isKeyboardFocusable ? 0 : -1,
-                "aria-hidden": "false",
-                "aria-label": iconTitle,
-                alt: iconTitle,
-                css: {
-                    fontSize: theme.typography.fontSizeSm,
-                    color: theme.colors.textSecondary
-                },
-                ...iconProps
-            })
-        })
-    });
-};
-
 const InfoPopover = ({ children, popoverProps, iconTitle, iconProps, isKeyboardFocusable = true, ariaLabel = 'More details' })=>{
     const { theme } = useDesignSystemTheme();
     const { isInsideModal } = useModalContext();
@@ -1433,52 +1415,6 @@ const ParagraphSkeleton = ({ label, seed = '', frameRate = 60, style, loading =
     });
 };
 
-const titleContainerStyles = /*#__PURE__*/ css({
-    cursor: 'progress',
-    width: '100%',
-    height: 28,
-    display: 'flex',
-    justifyContent: 'flex-start',
-    alignItems: 'center'
-});
-const titleFillStyles = /*#__PURE__*/ css({
-    borderRadius: 'var(--border-radius)',
-    height: 12,
-    width: '100%'
-});
-const TitleSkeleton = ({ label, seed = '', frameRate = 60, style, loading = true, loadingDescription = 'TitleSkeleton', ...restProps })=>{
-    const { theme } = useDesignSystemTheme();
-    const offsetWidth = getOffsets(seed)[0];
-    return /*#__PURE__*/ jsxs("div", {
-        ...addDebugOutlineIfEnabled(),
-        css: titleContainerStyles,
-        style: {
-            ...style,
-            ['--border-radius']: `${theme.general.borderRadiusBase}px`
-        },
-        ...restProps,
-        children: [
-            loading && /*#__PURE__*/ jsx(LoadingState, {
-                description: loadingDescription
-            }),
-            /*#__PURE__*/ jsx("span", {
-                css: visuallyHidden,
-                children: label
-            }),
-            /*#__PURE__*/ jsx("div", {
-                "aria-hidden": true,
-                css: [
-                    titleFillStyles,
-                    genSkeletonAnimatedColor(theme, frameRate),
-                    {
-                        width: `calc(100% - ${offsetWidth}px)`
-                    }
-                ]
-            })
-        ]
-    });
-};
-
 const TableContext = /*#__PURE__*/ createContext({
     size: 'default',
     grid: false
@@ -3138,29 +3074,20 @@ children, dangerouslySetAntdProps, onClick, ...restProps }, ref) {
     } : {
         defaultChecked
     };
-    const switchControl = /*#__PURE__*/ jsxs("label", {
+    const switchControl = /*#__PURE__*/ jsx("label", {
         ...addDebugOutlineIfEnabled(),
         className: rootClassName,
-        children: [
-            /*#__PURE__*/ jsx("input", {
-                ref: mergedRef,
-                type: "checkbox",
-                role: "switch",
-                id: uniqueId,
-                ...checkedStateProps,
-                onChange: handleChange,
-                disabled: disabled,
-                ...restProps,
-                ...eventContext.dataComponentProps
-            }),
-            /*#__PURE__*/ jsx("span", {
-                className: "ds-switch-track",
-                "aria-hidden": "true",
-                children: /*#__PURE__*/ jsx("span", {
-                    className: "ds-switch-thumb"
-                })
-            })
-        ]
+        children: /*#__PURE__*/ jsx("input", {
+            ref: mergedRef,
+            type: "checkbox",
+            role: "switch",
+            id: uniqueId,
+            ...checkedStateProps,
+            onChange: handleChange,
+            disabled: disabled,
+            ...restProps,
+            ...eventContext.dataComponentProps
+        })
     });
     if (!label) {
         return switchControl;
@@ -3212,11 +3139,11 @@ const Switch = /*#__PURE__*/ forwardRef(function Switch(props, ref) {
     });
 });
 
-const ROOT_CSS = {
+const ROOT_CSS$1 = {
     display: 'inline-block',
     width: '100%'
 };
-const TypeaheadComboboxRoot = /*#__PURE__*/ forwardRef(({ comboboxState, multiSelect = false, floatingStrategy = 'absolute', children, ...props }, ref)=>{
+const TypeaheadComboboxRoot$1 = /*#__PURE__*/ forwardRef(({ comboboxState, multiSelect = false, floatingStrategy = 'absolute', children, ...props }, ref)=>{
     const { classNamePrefix } = useDesignSystemTheme();
     const { refs, floatingStyles } = useFloating({
         whileElementsMounted: autoUpdate,
@@ -3255,7 +3182,7 @@ const TypeaheadComboboxRoot = /*#__PURE__*/ forwardRef(({ comboboxState, multiSe
                 suppressRefError: true
             }),
             className: `${classNamePrefix}-typeahead-combobox`,
-            css: ROOT_CSS,
+            css: ROOT_CSS$1,
             ...props,
             ref: mergedRef,
             "data-component-type": DesignSystemEventProviderComponentTypes.TypeaheadCombobox,
@@ -3274,7 +3201,7 @@ const TYPEAHEAD_COMBOBOX_MENU_STYLES = /*#__PURE__*/ css({
     alignItems: 'flex-start',
     position: 'absolute'
 });
-const TypeaheadComboboxMenu = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
+const TypeaheadComboboxMenu$1 = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
 ({ comboboxState, loading, emptyText, width, minWidth = 240, maxWidth, minHeight, maxHeight, listWrapperHeight, virtualizerRef, children, matchTriggerWidth, ...restProps }, ref)=>{
     const { getMenuProps, isOpen } = comboboxState;
     const { ref: downshiftRef, ...downshiftProps } = getMenuProps({}, {
@@ -3402,7 +3329,7 @@ const TypeaheadComboboxMenu = /*#__PURE__*/ forwardRef(// eslint-disable-next-li
     }), getPopupContainer ? getPopupContainer() : document.body);
 });
 
-const getToggleButtonStyles = (theme, disabled)=>{
+const getToggleButtonStyles$1 = (theme, disabled)=>{
     return /*#__PURE__*/ css({
         cursor: 'pointer',
         userSelect: 'none',
@@ -3419,7 +3346,7 @@ const getToggleButtonStyles = (theme, disabled)=>{
         }
     });
 };
-const TypeaheadComboboxToggleButton = /*#__PURE__*/ React__default.forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
+const TypeaheadComboboxToggleButton$1 = /*#__PURE__*/ React__default.forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
 ({ disabled, ...restProps }, ref)=>{
     const { theme } = useDesignSystemTheme();
     const { onClick } = restProps;
@@ -3431,34 +3358,35 @@ const TypeaheadComboboxToggleButton = /*#__PURE__*/ React__default.forwardRef(//
         type: "button",
         "aria-label": "toggle menu",
         ref: ref,
-        css: getToggleButtonStyles(theme, disabled),
+        css: getToggleButtonStyles$1(theme, disabled),
         ...restProps,
         onClick: handleClick,
         children: /*#__PURE__*/ jsx(ChevronDownIcon, {})
     });
 });
 
-const TypeaheadComboboxControls = ({ getDownshiftToggleButtonProps, showClearSelectionButton, showComboboxToggleButton = true, handleClear, disabled, loading = false, inline = false, className })=>{
+/** Height of the non-inline controls block, for callers that position it themselves. */ const TYPEAHEAD_COMBOBOX_CONTROLS_HEIGHT = 16;
+const TypeaheadComboboxControls$1 = ({ getDownshiftToggleButtonProps, showClearSelectionButton, showComboboxToggleButton = true, handleClear, disabled, loading = false, inline = false, className })=>{
     return /*#__PURE__*/ jsxs("div", {
         className: className,
-        css: inline ? {
+        css: {
+            // Centers the 12px clear icon against the 16px toggle button.
             display: 'flex',
             alignItems: 'center',
-            cursor: disabled ? 'not-allowed' : undefined
-        } : {
-            height: 16,
-            zIndex: 1,
-            cursor: disabled ? 'not-allowed' : undefined
+            cursor: disabled ? 'not-allowed' : undefined,
+            ...inline ? {} : {
+                height: TYPEAHEAD_COMBOBOX_CONTROLS_HEIGHT,
+                zIndex: 1
+            }
         },
         children: [
             showClearSelectionButton && /*#__PURE__*/ jsx(ClearSelectionButton, {
                 onClick: handleClear,
                 css: {
-                    pointerEvents: 'all',
-                    verticalAlign: 'text-top'
+                    pointerEvents: 'all'
                 }
             }),
-            loading ? /*#__PURE__*/ jsx(LoadingSpinner, {}) : showComboboxToggleButton && /*#__PURE__*/ jsx(TypeaheadComboboxToggleButton, {
+            loading ? /*#__PURE__*/ jsx(LoadingSpinner, {}) : showComboboxToggleButton && /*#__PURE__*/ jsx(TypeaheadComboboxToggleButton$1, {
                 ...getDownshiftToggleButtonProps(),
                 disabled: disabled
             })
@@ -3466,7 +3394,7 @@ const TypeaheadComboboxControls = ({ getDownshiftToggleButtonProps, showClearSel
     });
 };
 
-const getInputStyles$1 = (theme)=>/*#__PURE__*/ css({
+const getInputStyles$3 = (theme)=>/*#__PURE__*/ css({
         width: '100%',
         minWidth: 72,
         textOverflow: 'ellipsis',
@@ -3481,7 +3409,7 @@ const getInputStyles$1 = (theme)=>/*#__PURE__*/ css({
             backgroundColor: 'transparent'
         }
     });
-const TypeaheadComboboxInput = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
+const TypeaheadComboboxInput$1 = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
 ({ comboboxState, allowClear = true, showComboboxToggleButton = true, formOnChange, onClick, clearInputValueOnFocus = false, size, loading = false, suffix, ...restProps }, ref)=>{
     const { isInsideTypeaheadCombobox, floatingUiRefs, setInputWidth, inputWidth } = useTypeaheadComboboxContext();
     if (!isInsideTypeaheadCombobox) {
@@ -3561,7 +3489,7 @@ const TypeaheadComboboxInput = /*#__PURE__*/ forwardRef(// eslint-disable-next-l
             "aria-controls": comboboxState.isOpen ? downshiftProps['aria-controls'] : undefined,
             onClick: handleClick,
             size: size,
-            css: getInputStyles$1(theme),
+            css: getInputStyles$3(theme),
             ...restProps,
             suffix: /*#__PURE__*/ jsxs("div", {
                 css: /*#__PURE__*/ css({
@@ -3571,7 +3499,7 @@ const TypeaheadComboboxInput = /*#__PURE__*/ forwardRef(// eslint-disable-next-l
                 }),
                 children: [
                     suffix,
-                    /*#__PURE__*/ jsx(TypeaheadComboboxControls, {
+                    /*#__PURE__*/ jsx(TypeaheadComboboxControls$1, {
                         getDownshiftToggleButtonProps: getToggleButtonProps,
                         showClearSelectionButton: allowClear && Boolean(inputValue) && !restProps.disabled,
                         showComboboxToggleButton: showComboboxToggleButton,
@@ -3586,7 +3514,7 @@ const TypeaheadComboboxInput = /*#__PURE__*/ forwardRef(// eslint-disable-next-l
     });
 });
 
-const getContainerStyles = (theme, validationState, width, disabled)=>{
+const getContainerStyles$1 = (theme, validationState, width, disabled)=>{
     const validationColor = getValidationStateColor(theme, validationState);
     return /*#__PURE__*/ css({
         cursor: 'text',
@@ -3643,12 +3571,21 @@ const getContainerStyles = (theme, validationState, width, disabled)=>{
         }
     });
 };
+// One tag row (20px line height + 2px margins) plus vertical padding on both sides and the
+// container's 1px borders: 36px by default, 32px at `size="middle"`.
+const TAG_ROW_HEIGHT = 24;
+const DEFAULT_VERTICAL_PADDING = 5;
+const MIDDLE_VERTICAL_PADDING = 3;
+const getVerticalPadding = (size)=>size === 'middle' ? MIDDLE_VERTICAL_PADDING : DEFAULT_VERTICAL_PADDING;
+// Centers the shorter controls block on the tag row it floats beside.
+const CONTROLS_ROW_OFFSET = (TAG_ROW_HEIGHT - TYPEAHEAD_COMBOBOX_CONTROLS_HEIGHT) / 2;
 // Overflow lives on this inner wrapper so the floated, sticky controls
 // (rendered as the first child) stay pinned to the top-right of the visible
 // scroll viewport while the tag list scrolls.
-const getScrollContainerStyles = (maxHeight)=>{
+const getScrollContainerStyles$1 = (maxHeight, size)=>{
+    const verticalPadding = getVerticalPadding(size);
     return /*#__PURE__*/ css({
-        padding: '5px 7px 5px 12px',
+        padding: `${verticalPadding}px 7px ${verticalPadding}px 12px`,
         overflowY: 'auto',
         overflowX: 'hidden',
         ...maxHeight ? {
@@ -3656,7 +3593,7 @@ const getScrollContainerStyles = (maxHeight)=>{
         } : {}
     });
 };
-const getContentWrapperStyles = ()=>{
+const getContentWrapperStyles$1 = ()=>{
     return /*#__PURE__*/ css({
         display: 'flex',
         flex: 'auto',
@@ -3665,7 +3602,7 @@ const getContentWrapperStyles = ()=>{
         position: 'relative'
     });
 };
-const getInputWrapperStyles = ()=>{
+const getInputWrapperStyles$1 = ()=>{
     return /*#__PURE__*/ css({
         display: 'inline-flex',
         position: 'relative',
@@ -3679,7 +3616,7 @@ const getInputWrapperStyles = ()=>{
         minWidth: 40
     });
 };
-const getInputStyles = (theme)=>{
+const getInputStyles$2 = (theme)=>{
     return /*#__PURE__*/ css({
         lineHeight: 20,
         height: 24,
@@ -3699,8 +3636,9 @@ const getInputStyles = (theme)=>{
         }
     });
 };
-const TypeaheadComboboxMultiSelectInput = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
-({ comboboxState, multipleSelectionState, selectedItems, setSelectedItems, getSelectedItemLabel, allowClear = true, showTagAfterValueCount = 20, width, maxHeight, placeholder, validationState, showComboboxToggleButton, disableTooltip = false, ...restProps }, ref)=>{
+const TypeaheadComboboxMultiSelectInput$1 = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
+({ comboboxState, multipleSelectionState, selectedItems, setSelectedItems, getSelectedItemLabel, allowClear = true, showTagAfterValueCount = 20, width, maxHeight, placeholder, validationState, showComboboxToggleButton, disableTooltip = false, // Kept out of `restProps`: on an `input`, `size` is a character count.
+size, ...restProps }, ref)=>{
     const { isInsideTypeaheadCombobox } = useTypeaheadComboboxContext();
     if (!isInsideTypeaheadCombobox) {
         throw new Error('`TypeaheadComboboxMultiSelectInput` must be used within `TypeaheadCombobox`');
@@ -3872,29 +3810,30 @@ const TypeaheadComboboxMultiSelectInput = /*#__PURE__*/ forwardRef(// eslint-dis
         ...addDebugOutlineIfEnabled(),
         onClick: handleClick,
         ref: mergedContainerRef,
-        css: getContainerStyles(theme, validationState, width, restProps.disabled),
+        css: getContainerStyles$1(theme, validationState, width, restProps.disabled),
         tabIndex: restProps.disabled ? -1 : 0,
         children: /*#__PURE__*/ jsxs("div", {
             ref: scrollContainerRef,
-            css: getScrollContainerStyles(maxHeight),
+            css: getScrollContainerStyles$1(maxHeight, size),
             children: [
-                /*#__PURE__*/ jsx(TypeaheadComboboxControls, {
+                /*#__PURE__*/ jsx(TypeaheadComboboxControls$1, {
                     getDownshiftToggleButtonProps: getToggleButtonProps,
                     showComboboxToggleButton: showComboboxToggleButton,
                     showClearSelectionButton: allowClear && (Boolean(inputValue) || selectedItems && selectedItems.length > 0) && !restProps.disabled,
                     handleClear: handleClear,
                     disabled: restProps.disabled,
-                    // top offset = theme.spacing.sm (8) - scroll container padding-top (5) so the
-                    // controls sit at y=8 from the outer container, matching the pre-split layout.
+                    // `top` equals the flow position, so scrolling the tag list leaves the controls in
+                    // place on the first row.
                     css: /*#__PURE__*/ css({
                         position: 'sticky',
-                        top: 3,
+                        top: getVerticalPadding(size) + CONTROLS_ROW_OFFSET,
+                        marginTop: CONTROLS_ROW_OFFSET,
                         float: 'right'
                     })
                 }),
                 /*#__PURE__*/ jsxs("div", {
                     ref: itemsRef,
-                    css: getContentWrapperStyles(),
+                    css: getContentWrapperStyles$1(),
                     children: [
                         selectedItemsToRender?.map((selectedItemForRender, index)=>/*#__PURE__*/ jsx(TypeaheadComboboxSelectedItem, {
                                 label: getSelectedItemLabel(selectedItemForRender),
@@ -3912,14 +3851,14 @@ const TypeaheadComboboxMultiSelectInput = /*#__PURE__*/ forwardRef(// eslint-dis
                             disabled: restProps.disabled
                         }),
                         /*#__PURE__*/ jsxs("div", {
-                            css: getInputWrapperStyles(),
+                            css: getInputWrapperStyles$1(),
                             "data-slot": "input",
                             children: [
                                 /*#__PURE__*/ jsx("input", {
                                     ...downshiftProps,
                                     ref: mergedInputRef,
                                     css: [
-                                        getInputStyles(theme),
+                                        getInputStyles$2(theme),
                                         {
                                             width: inputWidth
                                         }
@@ -3959,7 +3898,7 @@ const TypeaheadComboboxMultiSelectInput = /*#__PURE__*/ forwardRef(// eslint-dis
     return content;
 });
 
-const TypeaheadComboboxSectionHeader = ({ children, ...props })=>{
+const TypeaheadComboboxSectionHeader$1 = ({ children, ...props })=>{
     const { isInsideTypeaheadCombobox } = useTypeaheadComboboxContext();
     if (!isInsideTypeaheadCombobox) {
         throw new Error('`TypeaheadComboboxSectionHeader` must be used within `TypeaheadComboboxMenu`');
@@ -3970,7 +3909,7 @@ const TypeaheadComboboxSectionHeader = ({ children, ...props })=>{
     });
 };
 
-const TypeaheadComboboxSeparator = (props)=>{
+const TypeaheadComboboxSeparator$1 = (props)=>{
     const { isInsideTypeaheadCombobox } = useTypeaheadComboboxContext();
     if (!isInsideTypeaheadCombobox) {
         throw new Error('`TypeaheadComboboxSeparator` must be used within `TypeaheadComboboxMenu`');
@@ -3980,7 +3919,7 @@ const TypeaheadComboboxSeparator = (props)=>{
     });
 };
 
-const TypeaheadComboboxAddButton = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
+const TypeaheadComboboxAddButton$1 = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
 ({ children, ...restProps }, forwardedRef)=>{
     const { theme } = useDesignSystemTheme();
     const { isInsideTypeaheadCombobox, componentId } = useTypeaheadComboboxContext();
@@ -4256,7 +4195,7 @@ function RHFControlledTypeaheadCombobox({ name, control, rules, allItems, itemTo
         rules
     });
     const [items, setItems] = useState(allItems);
-    const comboboxState = useComboboxState({
+    const comboboxState = useComboboxState$1({
         allItems,
         items,
         setItems,
@@ -4286,18 +4225,18 @@ function RHFControlledTypeaheadCombobox({ name, control, rules, allItems, itemTo
         comboboxState.inputValue,
         onInputChange
     ]);
-    return /*#__PURE__*/ jsxs(TypeaheadComboboxRoot, {
+    return /*#__PURE__*/ jsxs(TypeaheadComboboxRoot$1, {
         ...props,
         comboboxState: comboboxState,
         children: [
-            /*#__PURE__*/ jsx(TypeaheadComboboxInput, {
+            /*#__PURE__*/ jsx(TypeaheadComboboxInput$1, {
                 ...inputProps,
                 validationState: validationState,
                 formOnChange: field.onChange,
                 comboboxState: comboboxState,
                 ref: field.ref
             }),
-            /*#__PURE__*/ jsx(TypeaheadComboboxMenu, {
+            /*#__PURE__*/ jsx(TypeaheadComboboxMenu$1, {
                 ...menuProps,
                 comboboxState: comboboxState,
                 children: children({
@@ -4330,7 +4269,7 @@ function RHFControlledMultiSelectTypeaheadCombobox({ name, control, rules, allIt
         field.onChange(item);
         setSelectedItems(item);
     };
-    const comboboxState = useComboboxState({
+    const comboboxState = useComboboxState$1({
         allItems,
         items,
         setInputValue,
@@ -4346,7 +4285,7 @@ function RHFControlledMultiSelectTypeaheadCombobox({ name, control, rules, allIt
         analyticsEvents,
         valueHasNoPii
     });
-    const multipleSelectionState = useMultipleSelectionState(selectedItems, handleItemUpdate, comboboxState);
+    const multipleSelectionState = useMultipleSelectionState$1(selectedItems, handleItemUpdate, comboboxState);
     const lastEmmitedInputValue = useRef(inputProps?.value);
     useEffect(()=>{
         if (onInputChange && lastEmmitedInputValue.current !== comboboxState.inputValue) {
@@ -4357,11 +4296,11 @@ function RHFControlledMultiSelectTypeaheadCombobox({ name, control, rules, allIt
         comboboxState.inputValue,
         onInputChange
     ]);
-    return /*#__PURE__*/ jsxs(TypeaheadComboboxRoot, {
+    return /*#__PURE__*/ jsxs(TypeaheadComboboxRoot$1, {
         ...props,
         comboboxState: comboboxState,
         children: [
-            /*#__PURE__*/ jsx(TypeaheadComboboxMultiSelectInput, {
+            /*#__PURE__*/ jsx(TypeaheadComboboxMultiSelectInput$1, {
                 ...inputProps,
                 multipleSelectionState: multipleSelectionState,
                 selectedItems: selectedItems,
@@ -4371,7 +4310,7 @@ function RHFControlledMultiSelectTypeaheadCombobox({ name, control, rules, allIt
                 validationState: validationState,
                 ref: field.ref
             }),
-            /*#__PURE__*/ jsx(TypeaheadComboboxMenu, {
+            /*#__PURE__*/ jsx(TypeaheadComboboxMenu$1, {
                 ...menuProps,
                 comboboxState: comboboxState,
                 children: children({
@@ -4544,10 +4483,9 @@ const FormUI = {
     HorizontalFormRow
 };
 
-const Col = ({ dangerouslySetAntdProps, ...props })=>/*#__PURE__*/ jsx(DesignSystemAntDConfigProvider, {
+const Col = (props)=>/*#__PURE__*/ jsx(DesignSystemAntDConfigProvider, {
         children: /*#__PURE__*/ jsx(Col$1, {
-            ...props,
-            ...dangerouslySetAntdProps
+            ...props
         })
     });
 
@@ -6420,11 +6358,1727 @@ const TreeGrid = ({ data, columns, renderCell, renderRow, renderTable, renderHea
     });
 };
 
+const ROOT_CSS = {
+    display: 'inline-block',
+    width: '100%',
+    position: 'relative'
+};
+// `any` matches the original Root's pattern: ComboBoxState is invariant in T, so we can't widen
+// ComboboxStateValue<T> at this generic boundary. Typed consumer code still routes through
+// useComboboxState.
+const TypeaheadComboboxRoot = /*#__PURE__*/ forwardRef(function TypeaheadComboboxRoot({ comboboxState, children, footerFocusable = true, ...props }, ref) {
+    const { classNamePrefix } = useDesignSystemTheme();
+    const inputRef = useRef(null);
+    const listBoxRef = useRef(null);
+    const popoverRef = useRef(null);
+    const buttonRef = useRef(null);
+    const triggerRef = useRef(null);
+    const footerRef = useRef(null);
+    const { state, itemsByKey, getKeyForItem, itemToString, removeByKey, clearSelection, onInputBlur } = comboboxState;
+    const { inputProps: ariaInputProps, listBoxProps, buttonProps } = useComboBox({
+        inputRef,
+        listBoxRef,
+        popoverRef,
+        buttonRef,
+        // Arrowing past the last option wraps to the first (and vice versa), matching the original
+        // downshift TypeaheadCombobox, whose `useCombobox` defaults to `circularNavigation: true`.
+        // react-aria's `useSelectableCollection` defaults `shouldFocusWrap` to false, so without this
+        // keyboard focus stops dead at the list boundary.
+        shouldFocusWrap: true,
+        'aria-label': props['aria-label']
+    }, state);
+    // Compose the consumer's formOnBlur onto react-aria's own input onBlur (which drives the
+    // commit-on-blur), rather than clobbering it. useComboBox owns the value re-sync; we only add
+    // the form notification on a genuine blur.
+    const inputProps = useMemo(()=>({
+            ...ariaInputProps,
+            onBlur: (e)=>{
+                ariaInputProps.onBlur?.(e);
+                // Only notify the form on a *real* blur — focus leaving the whole widget. Committing a
+                // selection (and Tab-to-footer when footerFocusable) transiently blurs the input to a node
+                // still inside the trigger/popover and refocuses; treating that as a blur would fire
+                // formOnBlur mid-interaction, diverging from RHF touched/validation semantics. Skip when
+                // focus lands on a node still inside the combobox.
+                const next = e.relatedTarget;
+                if (next instanceof Node && (triggerRef.current?.contains(next) || popoverRef.current?.contains(next))) {
+                    return;
+                }
+                onInputBlur();
+            }
+        }), [
+        ariaInputProps,
+        onInputBlur,
+        triggerRef,
+        popoverRef
+    ]);
+    const { elementRef: viewRef } = useNotifyOnFirstView({
+        onView: comboboxState.onView,
+        value: comboboxState.firstOnViewValue
+    });
+    const mergedRef = useCallback((node)=>{
+        if (typeof ref === 'function') ref(node);
+        else if (ref) ref.current = node;
+        viewRef.current = node;
+        triggerRef.current = node;
+    }, [
+        ref,
+        viewRef
+    ]);
+    const contextValue = useMemo(()=>({
+            componentId: comboboxState.componentId,
+            multiSelect: comboboxState.multiSelect,
+            isInsideTypeaheadCombobox: true,
+            comboBoxState: state,
+            inputProps,
+            listBoxProps,
+            buttonProps,
+            inputRef,
+            listBoxRef,
+            popoverRef,
+            buttonRef,
+            triggerRef,
+            footerFocusable,
+            footerRef,
+            itemsByKey,
+            getKeyForItem,
+            itemToString,
+            removeByKey,
+            clearSelection
+        }), [
+        comboboxState.componentId,
+        comboboxState.multiSelect,
+        state,
+        inputProps,
+        listBoxProps,
+        buttonProps,
+        footerFocusable,
+        itemsByKey,
+        getKeyForItem,
+        itemToString,
+        removeByKey,
+        clearSelection
+    ]);
+    return /*#__PURE__*/ jsx(TypeaheadComboboxReactAriaContextProvider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx("div", {
+            className: `${classNamePrefix}-typeahead-combobox-react-aria`,
+            css: ROOT_CSS,
+            ...props,
+            ref: mergedRef,
+            "data-component-type": DesignSystemEventProviderComponentTypes.TypeaheadCombobox,
+            // eslint-disable-next-line @databricks/no-dynamic-property-value -- Valid case, as combostate componentId is checked in the hook exempt:b9d30633-6d2c-4215-8451-f32826273087
+            "data-component-id": comboboxState.componentId,
+            children: children
+        })
+    });
+});
+
+// PROTOTYPE helper (DUBOIS-455, "Option A"): move DOM focus between the combobox input and the
+// footer's focusable controls. Only used when `footerFocusable` is set on the Root.
+//
+// Backed by react-aria's `createFocusManager` rather than a hand-rolled `querySelector`. The manager
+// walks the footer with `getFocusableTreeWalker`, whose node filter runs through `isFocusable` — so
+// it skips `display:none` / `visibility:hidden` / ancestor-hidden / `inert` / closed-`<details>`
+// controls that a raw CSS selector would wrongly match (and then `.focus()` as a no-op, stranding
+// focus). It also gives ordered `focusNext` / `focusPrevious`, so a footer with more than one control
+// navigates correctly instead of always landing on the first one.
+/**
+ * Focus the first tabbable control in `container`. Returns true only if focus actually moved onto a
+ * control inside `container` — react-aria skips non-visible/inert nodes and `.focus()` on them is a
+ * no-op, so we confirm against the resulting element rather than assuming a query match succeeded.
+ */ function focusFirstFocusable(container) {
+    if (!container) {
+        return false;
+    }
+    const focused = createFocusManager({
+        current: container
+    }).focusFirst({
+        tabbable: true
+    });
+    return focused != null && container.contains(focused);
+}
+/**
+ * Step focus to the adjacent tabbable control within `container`, starting from the currently focused
+ * element. Returns true if focus moved to another control in `container`; false when there is none in
+ * that direction (Shift+Tab from the first control, or forward Tab from the last) — the caller's cue
+ * to return focus to the input instead of letting it escape the popover.
+ */ function focusAdjacentFocusable(container, direction) {
+    if (!container) {
+        return false;
+    }
+    const active = document.activeElement;
+    if (!(active instanceof HTMLElement) || !container.contains(active)) {
+        return false;
+    }
+    const manager = createFocusManager({
+        current: container
+    });
+    const focused = direction === 'next' ? manager.focusNext({
+        from: active,
+        tabbable: true
+    }) : manager.focusPrevious({
+        from: active,
+        tabbable: true
+    });
+    return focused != null && container.contains(focused);
+}
+
+// Menu identifies the footer by component type (`child.type === TypeaheadComboboxFooter`), so no
+// marker prop is needed — `defaultProps` on a function component is removed in React 19.
+const TypeaheadComboboxFooter = ({ children, onKeyDown, ...restProps })=>{
+    const { theme } = useDesignSystemTheme();
+    const { isInsideTypeaheadCombobox, footerFocusable, footerRef, inputRef, comboBoxState } = useTypeaheadComboboxReactAriaContext();
+    if (!isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxFooter` must be used within `TypeaheadComboboxMenu`');
+    }
+    // PROTOTYPE (DUBOIS-455, "Option A"): the return leg. When footerFocusable and focus is inside the
+    // footer, Tab / Shift+Tab step between the footer's controls, and Escape (or stepping off either
+    // end) sends DOM focus back to the input so the user can resume typing. The menu stays open on the
+    // return leg — the Menu gates useOverlay's close-on-blur for focus moving to the input.
+    const setFooterRef = useCallback((node)=>{
+        if (footerFocusable) {
+            footerRef.current = node;
+        }
+    }, [
+        footerFocusable,
+        footerRef
+    ]);
+    const returnFocusToInput = (e, close)=>{
+        e.preventDefault();
+        e.stopPropagation();
+        inputRef.current?.focus();
+        if (close) {
+            comboBoxState?.close();
+        }
+    };
+    const handleKeyDown = (e)=>{
+        onKeyDown?.(e);
+        if (!footerFocusable) {
+            return;
+        }
+        if (e.key === 'Escape') {
+            returnFocusToInput(e, true);
+            return;
+        }
+        if (e.key === 'Tab') {
+            // Step to the adjacent footer control; if there is none in that direction (Shift+Tab from the
+            // first control, forward Tab from the last), return to the input instead of letting focus
+            // escape the popover. A single-control footer returns on the first Tab either way.
+            const moved = focusAdjacentFocusable(footerRef.current, e.shiftKey ? 'previous' : 'next');
+            if (moved) {
+                e.preventDefault();
+                e.stopPropagation();
+            } else {
+                returnFocusToInput(e, false);
+            }
+        }
+    };
+    return /*#__PURE__*/ jsx("div", {
+        ...restProps,
+        ref: setFooterRef,
+        onKeyDown: handleKeyDown,
+        css: getFooterStyles(theme),
+        children: children
+    });
+};
+
+const MENU_STYLES = /*#__PURE__*/ css({
+    padding: 0,
+    margin: 0,
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'flex-start',
+    listStyle: 'none',
+    outline: 'none'
+});
+const TypeaheadComboboxMenu = /*#__PURE__*/ forwardRef(function TypeaheadComboboxMenu(props, _ref) {
+    const ctx = useTypeaheadComboboxReactAriaContext();
+    if (!ctx.isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxMenu` must be used within `TypeaheadComboboxRoot`');
+    }
+    if (!ctx.comboBoxState || !ctx.comboBoxState.isOpen) return null;
+    return /*#__PURE__*/ jsx(TypeaheadComboboxMenuContents, {
+        ...props,
+        state: ctx.comboBoxState,
+        rawListBoxProps: ctx.listBoxProps,
+        listBoxRef: ctx.listBoxRef,
+        popoverRef: ctx.popoverRef,
+        triggerRef: ctx.triggerRef,
+        triggerWidth: ctx.triggerWidth,
+        inputRef: ctx.inputRef,
+        footerFocusable: ctx.footerFocusable
+    });
+});
+const TypeaheadComboboxMenuContents = ({ loading, emptyText, width, minWidth = 240, maxWidth, minHeight, maxHeight, listWrapperHeight, virtualizerRef, children, matchTriggerWidth, state, rawListBoxProps, listBoxRef, popoverRef, triggerRef, triggerWidth, inputRef, footerFocusable, ...restProps })=>{
+    const { theme } = useDesignSystemTheme();
+    const { getPopupContainer } = useDesignSystemContext();
+    const { isInsideRadixModal } = useRadixModalContext();
+    // useOverlayPosition already caps to the viewport; only forward numeric maxHeight to tighten further.
+    const popoverMaxHeight = typeof maxHeight === 'number' ? maxHeight : undefined;
+    // We compose useOverlay + useOverlayPosition directly instead of usePopover because usePopover
+    // hard-wires `onClose` into the position hook (usePopover.ts), which makes react-aria close the
+    // menu on *any* scroll whose target contains the trigger (useCloseOnScroll) — including page
+    // scroll. The original floating-ui combobox repositioned on scroll instead of closing. Passing
+    // `onClose: null` to useOverlayPosition preserves that reposition-don't-close behavior. Dismissal
+    // still happens via blur/outside-click (useComboBox + shouldCloseOnBlur) and Escape (useOverlay).
+    const { overlayProps: dismissProps } = useOverlay({
+        isOpen: state.isOpen,
+        onClose: state.close,
+        shouldCloseOnBlur: true,
+        // Dismiss on outside press. With isDismissable:false, useOverlay wires NO interact-outside
+        // handler and dismissal rides entirely on onBlurWithin — which deliberately does NOT close
+        // when the blur's relatedTarget is null (focus falling to <body>). Clicking empty page area,
+        // or clicking through the count-badge Tooltip that wraps the trigger, produces exactly that
+        // null-relatedTarget blur, so the menu got stuck open (only the chevron, which toggles
+        // directly, could close it). isDismissable:true activates useInteractOutside, which closes on
+        // any outside pointer-down regardless of focus. This is independent of the scroll behavior:
+        // useOverlayPosition still gets onClose:null below, so scrolling repositions, never closes.
+        isDismissable: true,
+        // PROTOTYPE (DUBOIS-455, "Option A"): when the footer is focusable, moving focus from the
+        // footer BACK to the input leaves the popover and would trip useOverlay's close-on-blur —
+        // closing the menu and wiping the typed filter. Gate that: don't treat the input as "outside".
+        // (No-op when footerFocusable is false, so default behavior is unchanged.)
+        ...footerFocusable ? {
+            shouldCloseOnInteractOutside: (element)=>!inputRef.current?.contains(element)
+        } : {}
+    }, popoverRef);
+    const { overlayProps: positionProps } = useOverlayPosition({
+        targetRef: triggerRef,
+        overlayRef: popoverRef,
+        isOpen: state.isOpen,
+        placement: 'bottom start',
+        offset: 4,
+        maxHeight: popoverMaxHeight,
+        onClose: null
+    });
+    const popoverProps = {
+        ...dismissProps,
+        ...positionProps
+    };
+    // PROTOTYPE (DUBOIS-455, "Option A"): because the Menu runs with <Overlay disableFocusManagement>
+    // (no FocusScope), react-aria does NOT restore focus on close. If the menu closes (Escape, select,
+    // outside-click) while focus is on the footer, focus would strand on <body> — a WCAG 2.4.3 gap. On
+    // unmount (menu close), if focus is still inside the popover, hand it back to the input.
+    //
+    // MUST be a layout effect, not a passive useEffect: a passive cleanup runs AFTER the commit that
+    // detaches the popover, and removing the focused footer button drops focus to <body> first — so the
+    // `popover.contains(document.activeElement)` guard would already be false and the handoff would never
+    // fire. A layout-effect cleanup runs before detachment, while focus is still on the footer.
+    useIsomorphicLayoutEffect(()=>{
+        if (!footerFocusable) {
+            return;
+        }
+        // Capture both nodes here rather than reading .current in the cleanup: by teardown the refs may
+        // already have been detached, so the cleanup would see null and skip the focus handoff.
+        const popover = popoverRef.current;
+        const input = inputRef.current;
+        return ()=>{
+            if (popover && popover.contains(document.activeElement)) {
+                input?.focus();
+            }
+        };
+    }, [
+        footerFocusable,
+        popoverRef,
+        inputRef
+    ]);
+    const isVirtualized = virtualizerRef !== undefined;
+    const { listBoxProps } = useListBox({
+        ...rawListBoxProps,
+        isVirtualized
+    }, state, listBoxRef);
+    // mergeRefs fans the listbox node out to both refs; memoized so it isn't detached/reattached
+    // on every render.
+    const setListBoxRef = useMemo(()=>mergeRefs(listBoxRef, virtualizerRef), [
+        listBoxRef,
+        virtualizerRef
+    ]);
+    const hasFragmentWrapper = children && !Array.isArray(children) && /*#__PURE__*/ isValidElement(children) && children.type === Fragment$1;
+    const filterableChildren = hasFragmentWrapper ? children.props.children : children;
+    const [menuItemChildren, footer] = Children.toArray(filterableChildren).reduce((acc, child)=>{
+        const isFooter = /*#__PURE__*/ isValidElement(child) && child.type === TypeaheadComboboxFooter;
+        if (isFooter) acc[1].push(child);
+        else acc[0].push(child);
+        return acc;
+    }, [
+        [],
+        []
+    ]);
+    const hasResults = menuItemChildren.length > 0;
+    const close = ()=>state.close();
+    // Inside a focus-trapped Radix modal, portal the menu into the modal's Dialog.Content
+    // (role="document" — the FocusScope boundary) instead of document.body. Otherwise focusing a
+    // footer control (footerFocusable) lands focus outside the trap and Radix immediately refocuses
+    // the input. We target the role="document" node specifically, NOT the inner .modal-content div
+    // (which is centered with a `transform`, and a transformed ancestor would become the containing
+    // block for the menu's position: fixed and clip it). triggerRef sits inside the modal body, so
+    // closest() resolves the content node once the trigger is mounted (always true when the menu is open).
+    const modalContentNode = isInsideRadixModal && triggerRef.current ? triggerRef.current.closest('[role="document"]') : null;
+    const portalContainer = modalContentNode ?? (getPopupContainer ? getPopupContainer() : undefined);
+    return(// disableFocusManagement: the combobox input owns focus throughout (options are virtually
+    // focused via aria-activedescendant), so the Overlay's default FocusScope must not move or
+    // restore focus into the popover.
+    /*#__PURE__*/ jsx(Overlay, {
+        portalContainer: portalContainer,
+        disableFocusManagement: true,
+        children: /*#__PURE__*/ jsxs("div", {
+            ref: popoverRef,
+            ...popoverProps,
+            // Chrome (border, background, radius, shadow) + sizing live on the popover container so they
+            // wrap the option list AND the footer/spinner. `overflow: hidden` + a flex column make the
+            // <ul> the only scroll area, so the footer stays pinned below it inside the same container.
+            css: [
+                getComboboxContentWrapperStyles(theme, {
+                    maxHeight,
+                    maxWidth,
+                    minHeight,
+                    minWidth,
+                    width
+                }),
+                {
+                    display: 'flex',
+                    flexDirection: 'column',
+                    overflow: 'hidden'
+                }
+            ],
+            style: {
+                ...popoverProps.style,
+                // react-aria hard-codes zIndex: 100000 on the overlay, which sits *above* Du Bois
+                // tooltips (zIndexBase + 70) — burying both the multi-select tooltip and in-menu
+                // InfoTooltips. Bring the menu into the Du Bois band (matching Popover, zIndexBase + 30):
+                // still above modals (zIndexBase) and page content, but below tooltips as designed.
+                zIndex: theme.options.zIndexBase + 30,
+                ...matchTriggerWidth && triggerWidth ? {
+                    width: triggerWidth
+                } : {}
+            },
+            children: [
+                /*#__PURE__*/ jsx(DismissButton, {
+                    onDismiss: close
+                }),
+                loading && /*#__PURE__*/ jsx(LoadingSpinner, {
+                    "aria-label": "Loading",
+                    alt: "Loading spinner"
+                }),
+                /*#__PURE__*/ jsx("ul", {
+                    ...addDebugOutlineIfEnabled(),
+                    "aria-busy": loading,
+                    ...listBoxProps,
+                    ref: setListBoxRef,
+                    // Inner scroll area only — chrome/sizing moved to the container above. `position: relative`
+                    // makes the <ul> the containing block for the absolutely-positioned virtualized rows AND
+                    // the offsetParent that useScrollOptionIntoView's offsetTop/scrollTop math depends on —
+                    // both break together if it is removed. MENU_STYLES keeps `padding: 0`: the virtual rows'
+                    // translateY offsets are measured from the <ul>'s padding-box origin, so adding padding
+                    // here would shift every row.
+                    css: [
+                        MENU_STYLES,
+                        {
+                            position: 'relative',
+                            flex: '1 1 auto',
+                            minHeight: 0,
+                            overflowY: 'auto',
+                            width: '100%'
+                        }
+                    ],
+                    ...restProps,
+                    children: !loading && (hasResults ? /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            menuItemChildren,
+                            listWrapperHeight ? // role="none" removes this spacer from the accessibility tree so the listbox still
+                            // owns only options. Keep it attribute-free: do NOT add any aria-* attribute, no id
+                            // (especially one targeted by aria-activedescendant), no tabindex, and keep it
+                            // non-focusable — per WAI-ARIA 1.2 §5.4, any of those makes the browser ignore
+                            // role="none" and expose this node as a spurious owned child of the listbox.
+                            // flexShrink: 0 stops the flex column from compressing the scroll-height carrier.
+                            /*#__PURE__*/ jsx("li", {
+                                role: "none",
+                                style: {
+                                    height: listWrapperHeight,
+                                    flexShrink: 0
+                                }
+                            }) : null
+                        ]
+                    }) : /*#__PURE__*/ jsx(EmptyResults, {
+                        emptyText: emptyText
+                    }))
+                }),
+                !loading && footer,
+                /*#__PURE__*/ jsx(DismissButton, {
+                    onDismiss: close
+                })
+            ]
+        })
+    }));
+};
+
+const TypeaheadComboboxCheckboxItemInner = ({ item, selectedItems, selectedMatcher, textOverflowMode = 'multiline', isDisabled, disabledReason, hintContent, children, ...restProps }, forwardedRef)=>{
+    const ctx = useTypeaheadComboboxReactAriaContext();
+    if (!ctx.isInsideTypeaheadCombobox || !ctx.comboBoxState) {
+        throw new Error('`TypeaheadComboboxCheckboxItem` must be used within an open `TypeaheadComboboxRoot`');
+    }
+    const { comboBoxState: state, getKeyForItem } = ctx;
+    const { theme } = useDesignSystemTheme();
+    const itemRef = useRef(null);
+    const setRef = useCallback((node)=>{
+        itemRef.current = node;
+        if (typeof forwardedRef === 'function') forwardedRef(node);
+        else if (forwardedRef) forwardedRef.current = node;
+    }, [
+        forwardedRef
+    ]);
+    const key = getKeyForItem(item);
+    const { optionProps, isFocused } = useOption({
+        key,
+        'aria-label': typeof children === 'string' ? children : undefined
+    }, state, itemRef);
+    const isSelected = selectedMatcher && selectedItems ? selectedItems.some((selectedItem)=>selectedMatcher(selectedItem, item)) : state.selectionManager.isSelected(key);
+    useScrollOptionIntoView(itemRef, isFocused, state.isOpen);
+    return /*#__PURE__*/ jsx("li", {
+        ...optionProps,
+        ref: setRef,
+        css: [
+            getComboboxOptionItemWrapperStyles(theme),
+            getMenuItemStyles(theme, isFocused, isDisabled)
+        ],
+        ...restProps,
+        children: /*#__PURE__*/ jsx(Checkbox, {
+            componentId: "design_system.typeahead_combobox_react_aria.checkbox_item",
+            disabled: isDisabled,
+            isChecked: isSelected,
+            css: getCheckboxStyles(theme, textOverflowMode),
+            tabIndex: -1,
+            onClick: (e)=>e.stopPropagation(),
+            children: /*#__PURE__*/ jsxs("label", {
+                children: [
+                    isDisabled && disabledReason ? /*#__PURE__*/ jsxs("div", {
+                        css: {
+                            display: 'flex'
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx("div", {
+                                children: children
+                            }),
+                            /*#__PURE__*/ jsx("div", {
+                                css: getInfoIconStyles(theme),
+                                children: /*#__PURE__*/ jsx(InfoTooltip, {
+                                    componentId: "typeahead-combobox-react-aria-checkbox-item-disabled-reason-info-tooltip",
+                                    content: disabledReason
+                                })
+                            })
+                        ]
+                    }) : children,
+                    /*#__PURE__*/ jsx(HintRow, {
+                        disabled: isDisabled,
+                        children: hintContent
+                    })
+                ]
+            })
+        })
+    });
+};
+const TypeaheadComboboxCheckboxItem = /*#__PURE__*/ forwardRef(TypeaheadComboboxCheckboxItemInner);
+
+const getToggleButtonStyles = (theme, disabled)=>/*#__PURE__*/ css({
+        cursor: 'pointer',
+        userSelect: 'none',
+        color: theme.colors.textSecondary,
+        backgroundColor: 'transparent',
+        border: 'none',
+        padding: 0,
+        marginLeft: theme.spacing.xs,
+        height: 16,
+        width: 16,
+        ...disabled && {
+            pointerEvents: 'none',
+            color: theme.colors.actionDisabledText
+        }
+    });
+const TypeaheadComboboxToggleButton = ({ disabled })=>{
+    const { theme } = useDesignSystemTheme();
+    const { buttonProps: ariaButtonProps, buttonRef } = useTypeaheadComboboxReactAriaContext();
+    const { buttonProps } = useButton({
+        ...ariaButtonProps,
+        isDisabled: disabled
+    }, buttonRef);
+    return /*#__PURE__*/ jsx("button", {
+        type: "button",
+        "aria-label": "toggle menu",
+        ref: (el)=>{
+            buttonRef.current = el;
+        },
+        css: getToggleButtonStyles(theme, disabled),
+        ...buttonProps,
+        children: /*#__PURE__*/ jsx(ChevronDownIcon, {})
+    });
+};
+
+const TypeaheadComboboxControls = ({ showClearSelectionButton, showComboboxToggleButton = true, handleClear, disabled, loading = false, inline = false, className })=>{
+    return /*#__PURE__*/ jsxs("div", {
+        className: className,
+        css: inline ? {
+            display: 'flex',
+            alignItems: 'center',
+            cursor: disabled ? 'not-allowed' : undefined
+        } : {
+            height: 16,
+            zIndex: 1,
+            cursor: disabled ? 'not-allowed' : undefined
+        },
+        children: [
+            showClearSelectionButton && /*#__PURE__*/ jsx(ClearSelectionButton, {
+                onClick: handleClear,
+                css: {
+                    pointerEvents: 'all',
+                    verticalAlign: 'text-top'
+                }
+            }),
+            loading ? /*#__PURE__*/ jsx(LoadingSpinner, {}) : showComboboxToggleButton && /*#__PURE__*/ jsx(TypeaheadComboboxToggleButton, {
+                disabled: disabled
+            })
+        ]
+    });
+};
+
+const getInputStyles$1 = (theme)=>/*#__PURE__*/ css({
+        width: '100%',
+        minWidth: 72,
+        textOverflow: 'ellipsis',
+        borderRadius: theme.borders.borderRadiusSm,
+        borderColor: theme.colors.actionDefaultBorderDefault,
+        '&:disabled': {
+            borderColor: theme.colors.actionDisabledBorder,
+            backgroundColor: theme.colors.actionDisabledBackground,
+            color: theme.colors.actionDisabledText
+        },
+        '&:not(:disabled)': {
+            backgroundColor: 'transparent'
+        }
+    });
+const TypeaheadComboboxInput = /*#__PURE__*/ forwardRef(function TypeaheadComboboxInput({ allowClear = true, showComboboxToggleButton = true, onClick, size, loading = false, suffix, ...restProps }, ref) {
+    const ctx = useTypeaheadComboboxReactAriaContext();
+    if (!ctx.isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxInput` must be used within `TypeaheadComboboxRoot`');
+    }
+    const { inputProps, inputRef, comboBoxState: state, setTriggerWidth, triggerRef, componentId, clearSelection, footerFocusable, footerRef } = ctx;
+    const { theme } = useDesignSystemTheme();
+    // Measure trigger so `matchTriggerWidth` on Menu can size to it. Must be a passive effect, not
+    // useLayoutEffect: triggerRef points at the Root <div> (an ancestor), whose ref is attached
+    // only after this child's layout effects run — reading it in useLayoutEffect sees null and
+    // never sets triggerWidth (the menu then falls back to its min width).
+    useEffect(()=>{
+        const node = triggerRef.current;
+        if (!node) return;
+        const width = node.getBoundingClientRect().width;
+        setTriggerWidth(width);
+    }, [
+        triggerRef,
+        setTriggerWidth
+    ]);
+    const handleClear = ()=>{
+        // clearSelection() already notifies the form via the hook-level formOnChange(null).
+        clearSelection();
+    };
+    const handleClick = (e)=>{
+        onClick?.(e);
+        // Open-only: toggling on every click would flicker on repeat clicks. Toggle button + outside-click close.
+        if (state && !state.isOpen) state.open();
+    };
+    // PROTOTYPE (DUBOIS-455, "Option A"): when footerFocusable, forward-Tab moves DOM focus into the
+    // footer instead of committing. Must run in the CAPTURE phase — useComboBox binds Tab to
+    // commit()->closeMenu() in the bubble phase, and that would close the menu (unmounting the footer)
+    // before our handler ran. stopPropagation prevents react-aria's bubble handler from also firing;
+    // preventDefault stops the browser's native tab. Shift+Tab is left alone (handled in the footer).
+    //
+    // react-aria coupling (RE-VERIFY ON UPGRADE): this works only because react-aria exposes its Tab
+    // handler as a React `onKeyDown` prop on this same input (useComboBox inputProps, bubble phase),
+    // which a capture-phase handler preempts and stopPropagation() can suppress. If a future react-aria
+    // version moved that handling to a native/document listener, stopPropagation() would no longer stop
+    // it and Tab would close the menu again. react-aria is version-pinned in this repo, so an upgrade
+    // must re-verify this — the "Tab moves focus to the footer, menu stays open" regression test in
+    // tests/TypeaheadComboboxReactAriaFooterFocus.test.tsx guards it.
+    const handleKeyDownCapture = (e)=>{
+        if (!footerFocusable || e.key !== 'Tab' || e.shiftKey || !state?.isOpen) {
+            return;
+        }
+        const moved = focusFirstFocusable(footerRef.current);
+        if (moved) {
+            e.preventDefault();
+            e.stopPropagation();
+            // Clear virtual focus so the (now-unfocused) input doesn't keep a stale aria-activedescendant
+            // pointing at an option while real focus sits on the footer button.
+            state.selectionManager.setFocusedKey(null);
+        }
+    };
+    return /*#__PURE__*/ jsx("div", {
+        className: restProps.className,
+        ...addDebugOutlineIfEnabled(),
+        children: /*#__PURE__*/ jsx(Input, {
+            // eslint-disable-next-line @databricks/no-dynamic-property-value -- Valid case, as combostate componentId is checked in the hook exempt:97883162-7cd4-4bdc-a433-170eb108a4e3
+            componentId: componentId ? `${componentId}.input` : 'design_system.typeahead_combobox_react_aria.input',
+            ref: (antdInput)=>{
+                // useComboBox needs the underlying HTMLInputElement, exposed by AntD v4 as `.input`.
+                const node = antdInput?.input ?? null;
+                inputRef.current = node;
+                // Also forward to the consumer's ref (e.g. RHF `field.ref` for focus-on-validation-error).
+                // Parity with TypeaheadComboboxMultiSelectInput, whose input already forwards; this ref was
+                // previously dropped.
+                if (typeof ref === 'function') ref(node);
+                else if (ref) ref.current = node;
+            },
+            ...mergeProps(inputProps, restProps),
+            onClick: handleClick,
+            onKeyDownCapture: handleKeyDownCapture,
+            size: size,
+            css: getInputStyles$1(theme),
+            suffix: /*#__PURE__*/ jsxs("div", {
+                css: /*#__PURE__*/ css({
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: theme.spacing.xs
+                }),
+                children: [
+                    suffix,
+                    /*#__PURE__*/ jsx(TypeaheadComboboxControls, {
+                        showClearSelectionButton: allowClear && Boolean(state?.inputValue) && !restProps.disabled,
+                        showComboboxToggleButton: showComboboxToggleButton,
+                        handleClear: handleClear,
+                        disabled: restProps.disabled,
+                        loading: loading,
+                        inline: true
+                    })
+                ]
+            })
+        })
+    });
+});
+
+const getContainerStyles = (theme, validationState, width, disabled)=>{
+    const validationColor = getValidationStateColor(theme, validationState);
+    return /*#__PURE__*/ css({
+        cursor: 'text',
+        display: 'inline-block',
+        verticalAlign: 'top',
+        border: `1px solid ${theme.colors.actionDefaultBorderDefault}`,
+        borderRadius: theme.general.borderRadiusBase,
+        minHeight: 32,
+        height: 'auto',
+        minWidth: 0,
+        ...width ? {
+            width
+        } : {},
+        position: 'relative',
+        '&:hover': {
+            border: `1px solid ${theme.colors.actionPrimaryBackgroundHover}`
+        },
+        '&:focus-within': {
+            outlineColor: theme.colors.actionDefaultBorderFocus,
+            outlineWidth: 2,
+            outlineOffset: -2,
+            outlineStyle: 'solid',
+            boxShadow: 'none',
+            borderColor: 'transparent'
+        },
+        '&&': {
+            ...validationState && {
+                borderColor: validationColor
+            },
+            '&:hover': {
+                borderColor: validationState ? validationColor : theme.colors.actionPrimaryBackgroundHover
+            },
+            ...disabled && {
+                borderColor: theme.colors.actionDisabledBorder,
+                backgroundColor: theme.colors.actionDisabledBackground,
+                cursor: 'not-allowed',
+                outline: 'none',
+                '&:hover': {
+                    border: `1px solid ${theme.colors.actionDisabledBorder}`
+                },
+                '&:focus-within': {
+                    outline: 'none',
+                    borderColor: theme.colors.actionDisabledBorder
+                }
+            }
+        }
+    });
+};
+const getScrollContainerStyles = (maxHeight)=>/*#__PURE__*/ css({
+        padding: '5px 7px 5px 12px',
+        overflowY: 'auto',
+        overflowX: 'hidden',
+        ...maxHeight ? {
+            maxHeight
+        } : {}
+    });
+const getContentWrapperStyles = ()=>/*#__PURE__*/ css({
+        display: 'flex',
+        flex: 'auto',
+        flexWrap: 'wrap',
+        maxWidth: '100%',
+        position: 'relative'
+    });
+const getInputWrapperStyles = ()=>/*#__PURE__*/ css({
+        display: 'inline-flex',
+        position: 'relative',
+        maxWidth: '100%',
+        alignSelf: 'auto',
+        flex: '1 1 auto',
+        minWidth: 40
+    });
+const getInputStyles = (theme)=>/*#__PURE__*/ css({
+        lineHeight: 20,
+        height: 24,
+        margin: 0,
+        padding: 0,
+        appearance: 'none',
+        cursor: 'auto',
+        width: '100%',
+        backgroundColor: 'transparent',
+        color: theme.colors.textPrimary,
+        '&, &:hover, &:focus-visible': {
+            border: 'none',
+            outline: 'none'
+        },
+        '&::placeholder': {
+            color: theme.colors.textPlaceholder
+        }
+    });
+const TypeaheadComboboxMultiSelectInputInner = ({ selectedItems, // Destructured to keep it out of `restProps` (which is spread onto the <input>); the selection
+// reset is routed through the context's clearSelection, so this setter isn't used directly here.
+setSelectedItems: _setSelectedItems, getSelectedItemLabel, allowClear = true, showTagAfterValueCount = 20, width, maxHeight, placeholder, validationState, showComboboxToggleButton, disableTooltip = false, loading, ...restProps }, ref)=>{
+    const ctx = useTypeaheadComboboxReactAriaContext();
+    if (!ctx.isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxMultiSelectInput` must be used within `TypeaheadComboboxRoot`');
+    }
+    const { inputProps, inputRef, comboBoxState: state, setTriggerWidth, triggerRef, clearSelection, removeByKey, getKeyForItem, footerFocusable, footerRef } = ctx;
+    const { theme } = useDesignSystemTheme();
+    const containerRef = useRef(null);
+    const scrollContainerRef = useRef(null);
+    const itemsRef = useRef(null);
+    const measureRef = useRef(null);
+    const [inputWidth, setInputWidth] = useState(0);
+    const setContainerRef = useCallback((node)=>{
+        containerRef.current = node;
+        triggerRef.current = node;
+    }, [
+        triggerRef
+    ]);
+    const setInputElRef = useCallback((node)=>{
+        inputRef.current = node;
+        if (typeof ref === 'function') ref(node);
+        else if (ref) ref.current = node;
+    }, [
+        inputRef,
+        ref
+    ]);
+    const isResponsive = showTagAfterValueCount === 'responsive';
+    const fixedTagCount = typeof showTagAfterValueCount === 'number' ? showTagAfterValueCount : 20;
+    const [responsiveVisibleCount, setResponsiveVisibleCount] = useState(null);
+    const selectedItemsToRender = isResponsive ? responsiveVisibleCount === null ? selectedItems : selectedItems.slice(0, responsiveVisibleCount) : selectedItems.slice(0, fixedTagCount);
+    const shouldShowCountBadge = selectedItems.length > selectedItemsToRender.length;
+    const countBadgeStartAt = selectedItemsToRender.length;
+    const [showTooltip, setShowTooltip] = useState(shouldShowCountBadge);
+    const handleClick = ()=>{
+        if (restProps.disabled) return;
+        inputRef.current?.focus();
+        // Open-only on click (see TypeaheadComboboxInput for rationale).
+        if (state && !state.isOpen) state.open();
+    };
+    const handleClear = ()=>{
+        if (!state) return;
+        // Clear the typed search text, then route the selection reset through the hook's clearSelection
+        // so the onValueChange('[]') analytics event fires — the single-select input clears the same way.
+        // (clearSelection resets selectedItems in multi-select mode but does not touch the input value.)
+        state.setInputValue('');
+        clearSelection();
+    };
+    // Backspace on an empty input removes the last selected item, matching the original downshift
+    // TypeaheadCombobox (whose `useMultipleSelection` handled DropdownKeyDownBackspace). react-aria's
+    // multi-select is managed by us, so it does not wire this. Routed through `removeByKey` so the
+    // same `onValueChange` analytics event fires as tag-click / clear-button removal. Guarded on an
+    // empty input so it never interferes with normal text editing (the caret has nothing to delete).
+    const handleKeyDown = (e)=>{
+        // Read the input value from state, not the DOM node: react-aria controls the input via
+        // `state.inputValue`, so that is the authoritative "is the field empty" source at event time.
+        if (e.key !== 'Backspace' || (state?.inputValue ?? '') !== '' || selectedItems.length === 0 || restProps.disabled) {
+            return;
+        }
+        removeByKey(getKeyForItem(selectedItems[selectedItems.length - 1]));
+    };
+    // PROTOTYPE (DUBOIS-455, "Option A"): mirror TypeaheadComboboxInput's capture-phase Tab handler for
+    // multi-select. Without it, react-aria's bubble-phase Tab->commit fires and toggles (selects/
+    // deselects) the highlighted option instead of moving focus to the footer — and with the
+    // first-option highlight always on, an option is always highlighted, so Tab always toggled it.
+    // Capture phase + stopPropagation suppresses that commit; preventDefault stops the native tab; and
+    // clearing the focused key drops the stale aria-activedescendant while focus sits on the footer.
+    const handleKeyDownCapture = (e)=>{
+        if (!footerFocusable || e.key !== 'Tab' || e.shiftKey || !state?.isOpen) {
+            return;
+        }
+        const moved = focusFirstFocusable(footerRef.current);
+        if (moved) {
+            e.preventDefault();
+            e.stopPropagation();
+            state.selectionManager.setFocusedKey(null);
+        }
+    };
+    const currentInputValue = state?.inputValue ?? '';
+    useLayoutEffect(()=>{
+        if (measureRef.current) setInputWidth(measureRef.current.scrollWidth);
+    }, [
+        currentInputValue,
+        placeholder
+    ]);
+    useLayoutEffect(()=>{
+        if (!isResponsive) return;
+        setResponsiveVisibleCount(null);
+    }, [
+        isResponsive,
+        selectedItems,
+        inputWidth
+    ]);
+    useLayoutEffect(()=>{
+        if (!isResponsive) return;
+        const container = containerRef.current;
+        if (!container || typeof ResizeObserver === 'undefined') return;
+        const observer = new ResizeObserver(()=>setResponsiveVisibleCount(null));
+        observer.observe(container);
+        return ()=>observer.disconnect();
+    }, [
+        isResponsive
+    ]);
+    useLayoutEffect(()=>{
+        if (!isResponsive) return;
+        const itemsEl = itemsRef.current;
+        if (!itemsEl) return;
+        const tagEls = itemsEl.querySelectorAll('[data-slot="tag"]');
+        if (tagEls.length === 0) {
+            setResponsiveVisibleCount(0);
+            return;
+        }
+        const firstTop = tagEls[0].offsetTop;
+        const onFirstLine = (el)=>el != null && Math.abs(el.offsetTop - firstTop) <= 2;
+        let firstLineTagCount = 0;
+        for(let i = 0; i < tagEls.length; i++){
+            if (onFirstLine(tagEls[i])) firstLineTagCount++;
+            else break;
+        }
+        const inputWrapperEl = itemsEl.querySelector('[data-slot="input"]');
+        const inputWrapped = inputWrapperEl != null && !onFirstLine(inputWrapperEl);
+        let nextCount;
+        if (firstLineTagCount < tagEls.length) {
+            nextCount = firstLineTagCount;
+        } else if (tagEls.length === selectedItems.length) {
+            nextCount = inputWrapped ? Math.max(0, tagEls.length - 1) : selectedItems.length;
+        } else if (inputWrapped) {
+            nextCount = Math.max(0, tagEls.length - 1);
+        } else {
+            nextCount = tagEls.length;
+        }
+        setResponsiveVisibleCount(nextCount);
+    }, [
+        isResponsive,
+        selectedItems,
+        responsiveVisibleCount
+    ]);
+    // Measure trigger so the menu can match its width. useLayoutEffect so it is set before paint.
+    useLayoutEffect(()=>{
+        const node = containerRef.current;
+        if (!node) return;
+        setTriggerWidth(node.getBoundingClientRect().width);
+    }, [
+        setTriggerWidth
+    ]);
+    // When adding tags overflows the (maxHeight-capped) scroll container, the input — which sits at
+    // the end of the flow — scrolls below the fold and takes the cursor with it. Scroll the container
+    // to the bottom so the input stays visible. Scoped to the container's own scrollTop (not
+    // scrollIntoView, which would also scroll the page/menu). Only on growth, so removing a tag
+    // doesn't yank the view.
+    const prevSelectedCount = useRef(selectedItems.length);
+    useLayoutEffect(()=>{
+        const grew = selectedItems.length > prevSelectedCount.current;
+        prevSelectedCount.current = selectedItems.length;
+        const container = scrollContainerRef.current;
+        if (!grew || !container) return;
+        container.scrollTop = container.scrollHeight;
+    }, [
+        selectedItems
+    ]);
+    useEffect(()=>{
+        let isPartiallyHidden = false;
+        if (itemsRef.current && scrollContainerRef.current) {
+            isPartiallyHidden = itemsRef.current.clientHeight > scrollContainerRef.current.clientHeight;
+        }
+        setShowTooltip(!disableTooltip && (shouldShowCountBadge || isPartiallyHidden));
+    }, [
+        shouldShowCountBadge,
+        disableTooltip
+    ]);
+    const content = /*#__PURE__*/ jsx("div", {
+        ...addDebugOutlineIfEnabled(),
+        onClick: handleClick,
+        ref: setContainerRef,
+        css: getContainerStyles(theme, validationState, width, restProps.disabled),
+        children: /*#__PURE__*/ jsxs("div", {
+            ref: scrollContainerRef,
+            css: getScrollContainerStyles(maxHeight),
+            children: [
+                /*#__PURE__*/ jsx(TypeaheadComboboxControls, {
+                    showComboboxToggleButton: showComboboxToggleButton,
+                    showClearSelectionButton: allowClear && (Boolean(currentInputValue) || selectedItems.length > 0) && !restProps.disabled,
+                    handleClear: handleClear,
+                    disabled: restProps.disabled,
+                    loading: loading,
+                    css: /*#__PURE__*/ css({
+                        position: 'sticky',
+                        top: 3,
+                        float: 'right'
+                    })
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    ref: itemsRef,
+                    css: getContentWrapperStyles(),
+                    children: [
+                        selectedItemsToRender.map((selectedItem, index)=>/*#__PURE__*/ jsx(TypeaheadComboboxSelectedItem$1, {
+                                label: getSelectedItemLabel(selectedItem),
+                                item: selectedItem,
+                                disabled: restProps.disabled,
+                                "data-slot": "tag"
+                            }, `selected-item-${index}`)),
+                        shouldShowCountBadge && /*#__PURE__*/ jsx(CountBadge$1, {
+                            countStartAt: countBadgeStartAt,
+                            totalCount: selectedItems.length,
+                            disabled: restProps.disabled
+                        }),
+                        /*#__PURE__*/ jsxs("div", {
+                            css: getInputWrapperStyles(),
+                            "data-slot": "input",
+                            children: [
+                                /*#__PURE__*/ jsx("input", {
+                                    ...mergeProps(inputProps, restProps, {
+                                        onKeyDown: handleKeyDown
+                                    }),
+                                    onKeyDownCapture: handleKeyDownCapture,
+                                    ref: setInputElRef,
+                                    css: [
+                                        getInputStyles(theme),
+                                        {
+                                            width: inputWidth
+                                        }
+                                    ],
+                                    placeholder: selectedItems.length ? undefined : placeholder
+                                }),
+                                /*#__PURE__*/ jsxs("span", {
+                                    ref: measureRef,
+                                    "aria-hidden": true,
+                                    css: /*#__PURE__*/ css({
+                                        visibility: 'hidden',
+                                        whiteSpace: 'pre',
+                                        position: 'absolute'
+                                    }),
+                                    children: [
+                                        currentInputValue || placeholder,
+                                        "\xa0"
+                                    ]
+                                })
+                            ]
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+    if (showTooltip && selectedItems.length > 0) {
+        return /*#__PURE__*/ jsx(Tooltip, {
+            componentId: "typeahead-combobox-react-aria-multi-select-input-tooltip",
+            side: "right",
+            content: selectedItems.map((item)=>getSelectedItemLabel(item)).join(', '),
+            children: content
+        });
+    }
+    return content;
+};
+const TypeaheadComboboxMultiSelectInput = /*#__PURE__*/ forwardRef(TypeaheadComboboxMultiSelectInputInner);
+
+const TypeaheadComboboxSectionHeader = ({ children, ...props })=>{
+    const { isInsideTypeaheadCombobox } = useTypeaheadComboboxReactAriaContext();
+    if (!isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxSectionHeader` must be used within `TypeaheadComboboxMenu`');
+    }
+    // role="presentation" keeps the header out of the listbox's owned children (which must be only
+    // options) now that menu children render as direct children of the <ul role="listbox">. The
+    // header text stays exposed as static content. A consumer-supplied role still wins via {...props}.
+    return /*#__PURE__*/ jsx(SectionHeader, {
+        role: "presentation",
+        ...props,
+        children: children
+    });
+};
+
+const TypeaheadComboboxSeparator = (props)=>{
+    const { isInsideTypeaheadCombobox } = useTypeaheadComboboxReactAriaContext();
+    if (!isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxSeparator` must be used within `TypeaheadComboboxMenu`');
+    }
+    // role="presentation" keeps the decorative separator out of the listbox's owned children (which
+    // must be only options) now that menu children render as direct children of the <ul role="listbox">.
+    return /*#__PURE__*/ jsx(Separator, {
+        role: "presentation",
+        ...props
+    });
+};
+
+const TypeaheadComboboxAddButton = /*#__PURE__*/ forwardRef(function TypeaheadComboboxAddButton({ children, componentId: componentIdProp, ...restProps }, forwardedRef) {
+    const { theme } = useDesignSystemTheme();
+    const { isInsideTypeaheadCombobox, componentId } = useTypeaheadComboboxReactAriaContext();
+    if (!isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxAddButton` must be used within `TypeaheadComboboxRoot`');
+    }
+    return /*#__PURE__*/ jsx(Button, {
+        ...restProps,
+        // eslint-disable-next-line @databricks/no-dynamic-property-value -- Validated in the Root for the context exempt:ae0b57c6-871d-4375-a3ea-2574d7a3899e
+        componentId: componentIdProp ?? `${componentId}.add_option`,
+        type: "tertiary",
+        onClick: (event)=>{
+            event.stopPropagation();
+            restProps.onClick?.(event);
+        },
+        onMouseUp: (event)=>{
+            event.stopPropagation();
+            restProps.onMouseUp?.(event);
+        },
+        className: "combobox-footer-add-button",
+        css: /*#__PURE__*/ css({
+            ...getComboboxOptionItemWrapperStyles(theme),
+            .../*#__PURE__*/ css(importantify({
+                width: '100%',
+                padding: 0,
+                display: 'flex',
+                alignItems: 'center',
+                borderRadius: 0,
+                // Keep the row-highlight background on focus, but do NOT suppress the outline: the DS
+                // Button renders its `:focus-visible` ring (2px actionDefaultBorderFocus, offset -2px),
+                // which is the keyboard focus indicator. The old `outline: 'none'` here dated from when
+                // the footer button was mouse-only (never keyboard-focusable); now that focus can land
+                // on it (footerFocusable), suppressing the ring is a WCAG 2.4.7 failure.
+                '&:focus': {
+                    background: theme.colors.actionTertiaryBackgroundHover
+                }
+            }))
+        }),
+        icon: /*#__PURE__*/ jsx(PlusIcon, {}),
+        ref: forwardedRef,
+        children: children
+    });
+});
+
+/** JSON-encode a list of items by their display strings (the multi-select analytics value shape). */ const mapItemsToString$1 = (items, itemToString)=>{
+    return JSON.stringify(items.map(itemToString));
+};
+/**
+ * Item ↔ key/string mapping for the TypeaheadCombobox: resolves each item's display string and
+ * key, wraps items for react-aria's collection, and builds the key/text lookup maps. Warns in dev
+ * when two items collapse to the same key.
+ */ function useComboboxItems({ allItems, itemToString: itemToStringProp, getKey: getKeyProp }) {
+    const itemToString = useCallback((item)=>{
+        if (item === null || item === undefined) return '';
+        return itemToStringProp ? itemToStringProp(item) : String(item);
+    }, [
+        itemToStringProp
+    ]);
+    // Normalize keys to strings. react-aria's collection key comes from the `<Item key>` we render,
+    // which React coerces to a string, so `state.selectedKey` (and the keys `useOption` looks up) are
+    // always strings. A numeric `getKey` would otherwise leave `itemsByKey` / `disabledKeys` /
+    // controlled `value` keyed by the raw number, so every string-vs-number comparison against the
+    // collection would miss — breaking selection, option focus, and removal for numeric-id consumers.
+    const getKey = useCallback((item)=>{
+        if (getKeyProp) return String(getKeyProp(item));
+        return itemToString(item);
+    }, [
+        getKeyProp,
+        itemToString
+    ]);
+    const wrappedItems = useMemo(()=>allItems.map((value)=>({
+                id: getKey(value),
+                value
+            })), [
+        allItems,
+        getKey
+    ]);
+    const itemsByKey = useMemo(()=>{
+        const map = new Map();
+        for (const w of wrappedItems){
+            if (process.env.NODE_ENV !== 'production' && map.has(w.id)) {
+                // eslint-disable-next-line no-console
+                console.error(`[TypeaheadCombobox] Duplicate item key "${String(w.id)}". Items must map to unique keys; ` + 'pass a `getKey` that returns a unique value (the default falls back to `itemToString`, which ' + 'is colliding here). Items that share a key are dropped from selection and removal.');
+            }
+            map.set(w.id, w.value);
+        }
+        return map;
+    }, [
+        wrappedItems
+    ]);
+    // textValue → all items with that display string, for the custom-matcher path (runs per item per
+    // keystroke). Grouping (rather than first-wins) keeps distinct items that share a label matchable
+    // on their own non-label fields — otherwise every duplicate after the first is filtered against
+    // the first item's data.
+    const itemsByTextValue = useMemo(()=>{
+        const map = new Map();
+        for (const w of wrappedItems){
+            const key = itemToString(w.value);
+            const group = map.get(key);
+            if (group) group.push(w.value);
+            else map.set(key, [
+                w.value
+            ]);
+        }
+        return map;
+    }, [
+        wrappedItems,
+        itemToString
+    ]);
+    return {
+        itemToString,
+        getKey,
+        wrappedItems,
+        itemsByKey,
+        itemsByTextValue
+    };
+}
+
+/**
+ * Assembles the `ComboBoxStateOptions` passed to react-aria's `useComboBoxState`: the filter, the
+ * disabled-keys set, the controlled/uncontrolled selection value, the initial (uncontrolled) input
+ * text, and the selection/input/open change handlers (including analytics + multi-select
+ * input-reset). Kept separate from `useComboboxState` so the wiring into react-aria is isolated
+ * from the selection helpers the hook derives afterward.
+ */ function useComboboxStateProps({ items, multiSelect, matcher, isItemDisabled, allowNewValue, initialInputValue, initialSelectedItem, formValue, formOnChange, onStateChange, onIsOpenChange, externalSelectedItems, externalSetSelectedItems, stateRef, onValueChange }) {
+    const { itemToString, getKey, wrappedItems, itemsByKey, itemsByTextValue } = items;
+    // react-aria blocks selection of keys listed here (keyboard + pointer); the per-item `isDisabled`
+    // prop only styles the row.
+    const disabledKeys = useMemo(()=>isItemDisabled ? wrappedItems.filter((w)=>isItemDisabled(w.value)).map((w)=>w.id) : [], [
+        isItemDisabled,
+        wrappedItems
+    ]);
+    const { contains } = useFilter({
+        sensitivity: 'base'
+    });
+    const defaultFilter = useCallback((textValue, inputValue)=>{
+        if (matcher) {
+            const group = itemsByTextValue.get(textValue);
+            // A label is shown if any item carrying it matches — items that share a display string are
+            // indistinguishable to react-aria's filter (it only gets the string), so we can't route a
+            // single row to a single item here.
+            if (group !== undefined) {
+                const lowerCasedInputValue = inputValue.toLocaleLowerCase();
+                return group.some((item)=>matcher(item, lowerCasedInputValue));
+            }
+            return contains(textValue, inputValue);
+        }
+        return contains(textValue, inputValue);
+    }, [
+        matcher,
+        itemsByTextValue,
+        contains
+    ]);
+    // A single-select consumer opts into controlling the selection by passing `formValue` +
+    // `formOnChange`. Once controlled, "nothing selected" must stay controlled as `null` (not
+    // `undefined`) — otherwise clearing the input, which react-aria turns into setValue(null), would
+    // flip the selection value from controlled to uncontrolled (React warns, and clicks revert).
+    const isControlledSingleSelect = !multiSelect && formOnChange !== undefined;
+    const controlledValue = useMemo(()=>{
+        if (externalSelectedItems !== null) return externalSelectedItems.map(getKey);
+        if (formValue !== undefined) return getKey(formValue);
+        return isControlledSingleSelect ? null : undefined;
+    }, [
+        externalSelectedItems,
+        formValue,
+        getKey,
+        isControlledSingleSelect
+    ]);
+    const handleSelectionChange = useCallback((newValue)=>{
+        if (externalSetSelectedItems !== null) {
+            const keys = newValue ?? [];
+            const selected = keys.map((k)=>itemsByKey.get(k)).filter((x)=>x !== undefined);
+            externalSetSelectedItems(selected);
+            // Multi-select stays open after a pick; clear the search text so the menu resets to all items.
+            stateRef.current?.setInputValue('');
+            onValueChange?.(mapItemsToString$1(selected, itemToString));
+            onStateChange?.({
+                type: 'select',
+                selectedItem: selected[selected.length - 1] ?? null,
+                inputValue: ''
+            });
+            return;
+        }
+        const key = newValue;
+        const item = key === null ? null : itemsByKey.get(key) ?? null;
+        formOnChange?.(item);
+        onValueChange?.(itemToString(item));
+        onStateChange?.({
+            type: 'select',
+            selectedItem: item,
+            inputValue: ''
+        });
+    }, [
+        externalSetSelectedItems,
+        itemsByKey,
+        onValueChange,
+        itemToString,
+        formOnChange,
+        onStateChange,
+        stateRef
+    ]);
+    // Seed the initial input text, then let react-aria manage it (show the selected item's text,
+    // revert on blur, etc.). `defaultInputValue` is uncontrolled — we no longer mirror it in state.
+    const defaultInputValue = useMemo(()=>{
+        if (initialInputValue !== undefined) return initialInputValue;
+        if (initialSelectedItem !== undefined) return itemToString(initialSelectedItem);
+        if (formValue !== undefined) return itemToString(formValue);
+        return undefined;
+    }, [
+        initialInputValue,
+        initialSelectedItem,
+        formValue,
+        itemToString
+    ]);
+    // `defaultItems` rather than `items`: react-aria skips `defaultFilter` when `items` is set
+    // ("No default filter if items are controlled" — useComboBoxState.js:110).
+    return {
+        defaultItems: wrappedItems,
+        defaultFilter,
+        disabledKeys,
+        allowsCustomValue: allowNewValue,
+        defaultInputValue,
+        defaultSelectedKey: initialSelectedItem !== undefined ? getKey(initialSelectedItem) : undefined,
+        selectionMode: multiSelect ? 'multiple' : 'single',
+        value: controlledValue,
+        onChange: handleSelectionChange,
+        children: (wrapped)=>/*#__PURE__*/ jsx(Item, {
+                textValue: itemToString(wrapped.value),
+                children: itemToString(wrapped.value)
+            }, wrapped.id),
+        onInputChange: (inputValue)=>{
+            onStateChange?.({
+                type: 'input',
+                selectedItem: null,
+                inputValue
+            });
+        },
+        onOpenChange: (isOpen)=>{
+            onIsOpenChange?.(isOpen);
+            onStateChange?.({
+                type: isOpen ? 'open' : 'close',
+                selectedItem: null,
+                inputValue: ''
+            });
+        },
+        // Non-modal popovers rely on blur as their dismiss path (usePopover hard-codes
+        // isDismissable=false when isNonModal=true), so we can't ever leave this off.
+        shouldCloseOnBlur: true
+    };
+}
+
+/**
+ * Backs the Du Bois TypeaheadCombobox (react-aria variant) by wrapping react-aria's
+ * `useComboBoxState`. Handles single- and multi-select modes, item↔key mapping, filtering
+ * (default substring match or a custom `matcher`), selection helpers (`removeItem`,
+ * `clearSelection`, `isSelected`), form `onChange`/`onBlur` bridging, and analytics wiring.
+ * The returned object is what the `Root`/`Input`/`Menu` subtree consumes via context.
+ */ function useComboboxState(props) {
+    const multiSelect = props.multiSelect === true;
+    // Narrow the discriminated union once for stable typed refs in deps/callbacks.
+    const externalSelectedItems = multiSelect && props.multiSelect ? props.selectedItems : null;
+    const externalSetSelectedItems = multiSelect && props.multiSelect ? props.setSelectedItems : null;
+    const { allItems, itemToString: itemToStringProp, getKey: getKeyProp, matcher, isItemDisabled, componentId, analyticsEvents, valueHasNoPii, initialInputValue, initialSelectedItem, formValue, formOnChange, formOnBlur, onStateChange, onIsOpenChange, allowNewValue = false } = props;
+    // `preventUnsetOnBlur` is accepted for source compatibility with the original API but is a
+    // no-op: in react-aria, blur never clears the selection (only re-syncs input text), and
+    // closing on blur is required for non-modal popover dismissal.
+    const emitOnView = safex('databricks.fe.observability.defaultComponentView.typeaheadCombobox', false);
+    const items = useComboboxItems({
+        allItems,
+        itemToString: itemToStringProp,
+        getKey: getKeyProp
+    });
+    const { itemToString, getKey, itemsByKey } = items;
+    const memoizedAnalyticsEvents = useMemo(()=>analyticsEvents ? [
+            ...analyticsEvents
+        ] : emitOnView ? [
+            DesignSystemEventProviderAnalyticsEventTypes.OnValueChange,
+            DesignSystemEventProviderAnalyticsEventTypes.OnView
+        ] : [
+            DesignSystemEventProviderAnalyticsEventTypes.OnValueChange
+        ], [
+        analyticsEvents,
+        emitOnView
+    ]);
+    const eventContext = useDesignSystemEventComponentCallbacks({
+        componentType: DesignSystemEventProviderComponentTypes.TypeaheadCombobox,
+        componentId,
+        analyticsEvents: memoizedAnalyticsEvents,
+        valueHasNoPii
+    });
+    // react-aria owns the input value. `stateRef` lets the selection handler clear the input in
+    // multi-select mode without making inputValue a controlled prop.
+    const stateRef = useRef(null);
+    const stateOptions = useComboboxStateProps({
+        items,
+        multiSelect,
+        matcher,
+        isItemDisabled,
+        allowNewValue,
+        initialInputValue,
+        initialSelectedItem,
+        formValue,
+        formOnChange,
+        onStateChange,
+        onIsOpenChange,
+        externalSelectedItems,
+        externalSetSelectedItems,
+        stateRef,
+        onValueChange: eventContext.onValueChange
+    });
+    const state = useComboBoxState(stateOptions);
+    stateRef.current = state;
+    // Keep the first option highlighted while the menu is open so Enter commits it, matching the
+    // original downshift variant's `defaultHighlightedIndex: 0`. react-aria clears the focused key on
+    // every input change (useComboBoxState: "Clear focused key when input value changes"), and its
+    // `commit()` only selects when `focusedKey != null` — so without this, typing leaves nothing
+    // highlighted and Enter falls through to commitValue(), selecting nothing.
+    //
+    // Only re-focus when nothing is focused: that way arrowing or hovering to another option sticks,
+    // and we merely restore the default after react-aria drops it. Keyed on the collection so it
+    // re-runs as filtering narrows the list.
+    //
+    // Skipped when `allowNewValue`: there Enter is how the user commits the text they just typed, so
+    // pre-highlighting an option would hijack it and select the option instead.
+    const { collection, isOpen, selectionManager, disabledKeys } = state;
+    const focusedKey = selectionManager.focusedKey;
+    useEffect(()=>{
+        if (allowNewValue || !isOpen || focusedKey != null) return;
+        // Only restore the highlight while the combobox input itself holds DOM focus. With
+        // footerFocusable, Tab moves focus onto a footer control and deliberately clears focusedKey so
+        // no stale aria-activedescendant points at an option while focus sits on the footer button
+        // (WCAG 4.1.3). Re-focusing the first option here would undo that. The input carries
+        // role="combobox", so this cleanly excludes footer buttons, tag remove-buttons, etc.
+        if (document.activeElement?.getAttribute('role') !== 'combobox') return;
+        // Walk to the first *selectable* option; a disabled one could not be committed by Enter anyway.
+        let candidate = collection.getFirstKey();
+        while(candidate != null && disabledKeys.has(candidate)){
+            candidate = collection.getKeyAfter(candidate);
+        }
+        if (candidate == null) return;
+        selectionManager.setFocusedKey(candidate);
+    }, [
+        allowNewValue,
+        isOpen,
+        focusedKey,
+        collection,
+        selectionManager,
+        disabledKeys
+    ]);
+    const selectedKeys = useMemo(()=>{
+        if (externalSelectedItems !== null) {
+            const set = new Set();
+            for (const it of externalSelectedItems)set.add(getKey(it));
+            return set;
+        }
+        return state.selectedKey === null ? new Set() : new Set([
+            state.selectedKey
+        ]);
+    }, [
+        externalSelectedItems,
+        getKey,
+        state.selectedKey
+    ]);
+    const selectedItems = useMemo(()=>{
+        if (externalSelectedItems !== null) return externalSelectedItems;
+        if (state.selectedKey === null) return [];
+        const item = itemsByKey.get(state.selectedKey);
+        return item === undefined ? [] : [
+            item
+        ];
+    }, [
+        externalSelectedItems,
+        state.selectedKey,
+        itemsByKey
+    ]);
+    // Fire the consumer's formOnBlur on a *real* input blur, reading the committed selection at blur
+    // time. react-aria has no blur-with-value callback, so Root wires this onto the input's onBlur
+    // (guarded so focus moving within the widget — toggle/clear buttons — doesn't count as a blur).
+    // Keying an effect on selectedKey instead — the previous approach — fired formOnBlur on every
+    // selection commit/clear while the field still had focus, diverging from RHF touched/validation
+    // semantics (DUBOIS-455). Multi-select never routed formOnBlur through the single-value path in
+    // the original downshift variant, so it stays single-select-scoped here.
+    const selectedItemsRef = useRef(selectedItems);
+    selectedItemsRef.current = selectedItems;
+    const onInputBlur = useCallback(()=>{
+        if (multiSelect) return;
+        if (allowNewValue) {
+            // Free-text parity with the downshift variant: react-aria's selection handler only reports
+            // matched options, so a typed custom value would otherwise never reach the form. On blur,
+            // register the current input string as the form value (empty input → null). allowNewValue
+            // implies T is a string, so the raw inputValue is a valid T.
+            const custom = stateRef.current?.inputValue ? stateRef.current.inputValue : null;
+            formOnChange?.(custom);
+            formOnBlur?.(custom);
+            return;
+        }
+        formOnBlur?.(selectedItemsRef.current[0] ?? null);
+    }, [
+        multiSelect,
+        allowNewValue,
+        formOnChange,
+        formOnBlur
+    ]);
+    // Unwrap state.collection (post-filter) back to T[] for consumers.
+    const filteredItems = useMemo(()=>{
+        const out = [];
+        for (const node of state.collection){
+            if (node.type === 'item' && node.value) out.push(node.value.value);
+        }
+        return out;
+    }, [
+        state.collection
+    ]);
+    const removeByKey = useCallback((key)=>{
+        // Normalize to a string so a consumer passing a raw numeric key still matches our string
+        // keys (getKey stringifies; react-aria's collection keys are strings — see useComboboxItems).
+        const normalizedKey = String(key);
+        if (externalSelectedItems !== null && externalSetSelectedItems !== null) {
+            const next = externalSelectedItems.filter((it)=>getKey(it) !== normalizedKey);
+            if (next.length === externalSelectedItems.length) return;
+            externalSetSelectedItems(next);
+            eventContext.onValueChange?.(mapItemsToString$1(next, itemToString));
+            return;
+        }
+        // Single-select: removing the active selection clears it.
+        if (state.selectedKey === normalizedKey) {
+            formOnChange?.(null);
+            state.setSelectedKey(null);
+            eventContext.onValueChange?.(itemToString(null));
+        }
+    }, [
+        externalSelectedItems,
+        externalSetSelectedItems,
+        getKey,
+        eventContext,
+        itemToString,
+        state,
+        formOnChange
+    ]);
+    const removeItem = useCallback((item)=>removeByKey(getKey(item)), [
+        removeByKey,
+        getKey
+    ]);
+    const clearSelection = useCallback(()=>{
+        if (externalSetSelectedItems !== null) {
+            externalSetSelectedItems([]);
+            eventContext.onValueChange?.('[]');
+            return;
+        }
+        formOnChange?.(null);
+        state.setInputValue('');
+        state.setSelectedKey(null);
+    }, [
+        externalSetSelectedItems,
+        eventContext,
+        formOnChange,
+        state
+    ]);
+    const isSelected = useCallback((item)=>selectedKeys.has(getKey(item)), [
+        selectedKeys,
+        getKey
+    ]);
+    const firstOnViewValue = useMemo(()=>{
+        if (externalSelectedItems !== null) return mapItemsToString$1(externalSelectedItems, itemToString);
+        return itemToString(initialSelectedItem ?? null);
+    }, [
+        externalSelectedItems,
+        initialSelectedItem,
+        itemToString
+    ]);
+    return {
+        state,
+        itemsByKey,
+        getKeyForItem: getKey,
+        itemToString,
+        selectedItems,
+        selectedKeys,
+        filteredItems,
+        removeItem,
+        removeByKey,
+        clearSelection,
+        isSelected,
+        onInputBlur,
+        componentId,
+        analyticsEvents: memoizedAnalyticsEvents,
+        valueHasNoPii,
+        onView: eventContext.onView,
+        firstOnViewValue,
+        multiSelect
+    };
+}
+
+const mapItemsToString = (items, itemToString)=>{
+    return JSON.stringify(items.map(itemToString));
+};
+/**
+ * Companion hook to `useComboboxState` in multi-select mode. Returns chip-management helpers
+ * keyed off the consumer-owned `selectedItems` array, plus analytics wiring. Mostly redundant —
+ * the state hook already exposes `removeItem`/`removeByKey`/`clearSelection` — but kept for API
+ * parity with the original.
+ */ function useMultipleSelectionState(selectedItems, setSelectedItems, { componentId, analyticsEvents, valueHasNoPii, itemToString, getKey }) {
+    const toString = useCallback((item)=>item === null || item === undefined ? '' : itemToString ? itemToString(item) : String(item), [
+        itemToString
+    ]);
+    const keyFor = useCallback((item)=>getKey ? getKey(item) : toString(item), [
+        getKey,
+        toString
+    ]);
+    const memoizedAnalyticsEvents = useMemo(()=>analyticsEvents ?? [
+            DesignSystemEventProviderAnalyticsEventTypes.OnValueChange
+        ], [
+        analyticsEvents
+    ]);
+    const eventContext = useDesignSystemEventComponentCallbacks({
+        componentType: DesignSystemEventProviderComponentTypes.TypeaheadCombobox,
+        componentId,
+        analyticsEvents: memoizedAnalyticsEvents,
+        valueHasNoPii
+    });
+    const selectedKeys = useMemo(()=>{
+        const set = new Set();
+        for (const item of selectedItems)set.add(keyFor(item));
+        return set;
+    }, [
+        selectedItems,
+        keyFor
+    ]);
+    const addItem = useCallback((item)=>{
+        const k = keyFor(item);
+        if (selectedKeys.has(k)) return;
+        const next = [
+            ...selectedItems,
+            item
+        ];
+        setSelectedItems(next);
+        eventContext.onValueChange?.(mapItemsToString(next, toString));
+    }, [
+        keyFor,
+        selectedKeys,
+        selectedItems,
+        setSelectedItems,
+        eventContext,
+        toString
+    ]);
+    const removeByKey = useCallback((key)=>{
+        const next = selectedItems.filter((item)=>keyFor(item) !== key);
+        if (next.length === selectedItems.length) return;
+        setSelectedItems(next);
+        eventContext.onValueChange?.(mapItemsToString(next, toString));
+    }, [
+        selectedItems,
+        setSelectedItems,
+        keyFor,
+        eventContext,
+        toString
+    ]);
+    const removeItem = useCallback((item)=>removeByKey(keyFor(item)), [
+        removeByKey,
+        keyFor
+    ]);
+    const clear = useCallback(()=>{
+        setSelectedItems([]);
+        eventContext.onValueChange?.('[]');
+    }, [
+        setSelectedItems,
+        eventContext
+    ]);
+    const isSelected = useCallback((item)=>selectedKeys.has(keyFor(item)), [
+        selectedKeys,
+        keyFor
+    ]);
+    return {
+        selectedItems,
+        selectedKeys,
+        addItem,
+        removeItem,
+        removeByKey,
+        clear,
+        isSelected
+    };
+}
+
+/**
+ * Scrolls the virtually-focused option into view when it is NOT currently rendered. Under
+ * virtualization only a window of options is in the DOM, so react-aria's own scroll-into-view (and
+ * our per-item `useScrollOptionIntoView`) can't reach an option that hasn't mounted — arrowing past
+ * the rendered window would otherwise appear to do nothing. This bridges react-aria's
+ * `selectionManager.focusedKey` to the consumer's virtualizer so the row mounts and scrolls in.
+ *
+ * Consumer-invoked (the consumer owns the virtualizer instance).
+ *
+ * The effect keys ONLY on `focusedKey`/`isOpen` — i.e. it runs when the *active option* changes,
+ * not on every render. This is essential: `useVirtual` returns a new `virtualizer` object on every
+ * render and re-renders on every scroll frame, so depending on it would re-fire `scrollToIndex` on
+ * each scroll tick and fight the user's scrollbar drag. The mutable inputs are read through a ref
+ * instead. Hovering an option also moves `focusedKey`, but a hovered option is by definition already
+ * rendered/visible, so `scrollToIndex` (align "auto") is a no-op for it.
+ */ function useVirtualizedComboboxScroll({ state, filteredItems, getKey, virtualizer }) {
+    const focusedKey = state.selectionManager.focusedKey;
+    const isOpen = state.isOpen;
+    // Latest mutable inputs, read inside the effect without adding them as deps (they change identity
+    // every render / scroll frame).
+    const latest = useRef({
+        filteredItems,
+        getKey,
+        virtualizer
+    });
+    latest.current = {
+        filteredItems,
+        getKey,
+        virtualizer
+    };
+    useEffect(()=>{
+        if (!isOpen || focusedKey == null) return;
+        const { filteredItems: items, getKey: key, virtualizer: v } = latest.current;
+        const index = items.findIndex((item)=>key(item) === focusedKey);
+        if (index < 0) return;
+        // Defer one frame so the collection re-render + virtualizer measurement settle before we scroll.
+        const raf = requestAnimationFrame(()=>v.scrollToIndex(index));
+        return ()=>cancelAnimationFrame(raf);
+    }, [
+        focusedKey,
+        isOpen
+    ]);
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  TypeaheadComboboxAddButton: TypeaheadComboboxAddButton,
+  TypeaheadComboboxCheckboxItem: TypeaheadComboboxCheckboxItem,
+  TypeaheadComboboxFooter: TypeaheadComboboxFooter,
+  TypeaheadComboboxInput: TypeaheadComboboxInput,
+  TypeaheadComboboxMenu: TypeaheadComboboxMenu,
+  TypeaheadComboboxMenuItem: TypeaheadComboboxMenuItem,
+  TypeaheadComboboxMultiSelectInput: TypeaheadComboboxMultiSelectInput,
+  TypeaheadComboboxRoot: TypeaheadComboboxRoot,
+  TypeaheadComboboxSectionHeader: TypeaheadComboboxSectionHeader,
+  TypeaheadComboboxSelectedItem: TypeaheadComboboxSelectedItem$1,
+  TypeaheadComboboxSeparator: TypeaheadComboboxSeparator,
+  TypeaheadComboboxToggleButton: TypeaheadComboboxToggleButton,
+  useComboboxState: useComboboxState,
+  useMultipleSelectionState: useMultipleSelectionState,
+  useTypeaheadComboboxReactAriaContext: useTypeaheadComboboxReactAriaContext,
+  useVirtualizedComboboxScroll: useVirtualizedComboboxScroll
+});
+
 // Single source of truth for the DM Sans font-family stack used by Databricks One surfaces
 // (webapp DatabricksOneRouter, accounts-ui DatabricksOneWrapper). Co-located with the vendored
 // font CSS under `@databricks/design-system/fonts/dm-sans.css` so consumers can import both
 // from the design-system without duplicating the fallback chain.
 const DM_SANS_FONT_FAMILY = "'DM Sans', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, 'Noto Sans', sans-serif";
 
-export { AccessibleContainer, Alert, ApplyGlobalStyles, AssistantAvatar, AutoComplete, Avatar, AvatarGroup, Breadcrumb, Button, Card, CheckCircleFillIcon, CheckCircleIcon, Checkbox, ChevronDownIcon, ChevronRightIcon, CircleIcon, CircleOffIcon, CircleOutlineIcon, CloseIcon, CloseSmallIcon, Col, DBAssistantAvatar, DM_SANS_FONT_FAMILY, DU_BOIS_ENABLE_ANIMATION_CLASSNAME, DangerFillIcon, DangerIcon, DesignSystemAntDConfigProvider, DesignSystemEventProvider, DesignSystemEventProviderAnalyticsEventTypes, DesignSystemEventProviderComponentSubTypeMap, DesignSystemEventProviderComponentTypes, DesignSystemEventSuppressInteractionProviderContext, DesignSystemEventSuppressInteractionTrueContextValue, DialogCombobox, DialogComboboxAddButton, DialogComboboxContent, EmptyResults as DialogComboboxEmpty, DialogComboboxFooter, DialogComboboxHintRow, DialogComboboxOptionControlledList, DialogComboboxOptionList, DialogComboboxOptionListCheckboxItem, DialogComboboxOptionListSearch, DialogComboboxOptionListSelectItem, DialogComboboxSeparator, DialogComboboxTrigger, Dropdown, DuboisDatePicker, FormUI, GenericSkeleton, Header, HoverCard, InfoFillIcon, InfoPopover, InfoSmallIcon, Input, LegacyDatePicker, LegacyInfoCircleOutlined, LegacyInfoTooltip, LegacyPopover, LegacySelect, LegacySkeleton, LegacyTooltip, LoadingState, Menu, MinusSquareIcon, Modal, Notification, OverflowPopover, PageWrapper, ParagraphSkeleton, PlusIcon, PlusSquareIcon, RHFControlledComponents, ROW_GUTTER_SIZE, Radio, ResourceStatusIndicator, RestoreAntDDefaultClsPrefix, Row, SearchIcon, Select, SelectContent, SelectOption, SelectTrigger, ShapeTokens, SnackBar, SortAscendingIcon, SortDescendingIcon, SortUnsortedIcon, Space, SparkleDoubleIcon, Steps, Switch, Table, TableCell, TableContext, TableFilterInput, TableFilterLayout, TableHeader, TableRow, TableRowAction, TableRowActionHeader, TableRowContext, TableRowMenuContainer, TableRowMultiAction, TableRowSelectCell, TableSkeleton, TableSkeletonRows, TitleSkeleton, Tooltip, TreeGrid, TruncationTooltip, TypeaheadComboboxAddButton, TypeaheadComboboxInput, TypeaheadComboboxMenu, TypeaheadComboboxMultiSelectInput, TypeaheadComboboxRoot, TypeaheadComboboxSectionHeader, TypeaheadComboboxSelectedItem, TypeaheadComboboxSeparator, TypeaheadComboboxToggleButton, Typography, WarningFillIcon, WarningIcon, consumerDarkColorList, consumerLightColorList, findClosestOptionSibling, findHighlightedOption, flushFastdomForTesting, getAnimationCss, getComboboxOptionItemWrapperStyles, getContentOptions, getDarkModePortalStyles, getGlobalResetStyles, getGlobalStyles, getSwitchWithLabelStyles, getValidationStateColor, hideIconButtonRowStyles, highlightOption, importantify, isSafeRelativeUrl, isSafeUrl, measure, sanitizeNextUrl, setupDesignSystemEventProviderForTesting, snackBarManager, update, useComboboxState, useDefaultTreeGridState, useDesignSystemEventComponentCallbacks, useDesignSystemFlags, useDesignSystemTheme, useFastDom, useLegacyNotification, useModalContext, useMultipleSelectionState, useNotifyOnFirstView, useSnackBar, useThemedStyles, useTypeaheadComboboxContext, visuallyHidden, withNotifications };
+export { AccessibleContainer, Alert, ApplyGlobalStyles, AssistantAvatar, AutoComplete, Avatar, AvatarGroup, Breadcrumb, Button, Card, CheckCircleFillIcon, CheckCircleIcon, Checkbox, ChevronDownIcon, ChevronRightIcon, CircleIcon, CircleOffIcon, CircleOutlineIcon, CloseIcon, CloseSmallIcon, Col, DBAssistantAvatar, DM_SANS_FONT_FAMILY, DU_BOIS_ENABLE_ANIMATION_CLASSNAME, DangerFillIcon, DangerIcon, DesignSystemAntDConfigProvider, DesignSystemEventProvider, DesignSystemEventProviderAnalyticsEventTypes, DesignSystemEventProviderComponentSubTypeMap, DesignSystemEventProviderComponentTypes, DesignSystemEventSuppressInteractionProviderContext, DesignSystemEventSuppressInteractionTrueContextValue, DialogCombobox, DialogComboboxAddButton, DialogComboboxContent, EmptyResults as DialogComboboxEmpty, DialogComboboxFooter, DialogComboboxHintRow, DialogComboboxOptionControlledList, DialogComboboxOptionList, DialogComboboxOptionListCheckboxItem, DialogComboboxOptionListSearch, DialogComboboxOptionListSelectItem, DialogComboboxSeparator, DialogComboboxTrigger, Dropdown, DuboisDatePicker, FormUI, GenericSkeleton, Header, HoverCard, InfoFillIcon, InfoPopover, InfoSmallIcon, InfoTooltip, Input, LegacyDatePicker, LegacyPopover, LegacySelect, LegacySkeleton, LoadingState, Menu, MinusSquareIcon, Modal, Notification, OverflowPopover, PageWrapper, ParagraphSkeleton, PlusIcon, PlusSquareIcon, RHFControlledComponents, ROW_GUTTER_SIZE, Radio, ResourceStatusIndicator, RestoreAntDDefaultClsPrefix, Row, SearchIcon, Select, SelectContent, SelectOption, SelectTrigger, ShapeTokens, SnackBar, SortAscendingIcon, SortDescendingIcon, SortUnsortedIcon, Space, SparkleDoubleIcon, Steps, Switch, Table, TableCell, TableContext, TableFilterInput, TableFilterLayout, TableHeader, TableRow, TableRowAction, TableRowActionHeader, TableRowContext, TableRowMenuContainer, TableRowMultiAction, TableRowSelectCell, TableSkeleton, TableSkeletonRows, TitleSkeleton, Tooltip, TreeGrid, TruncationTooltip, TypeaheadComboboxAddButton$1 as TypeaheadComboboxAddButton, TypeaheadComboboxInput$1 as TypeaheadComboboxInput, TypeaheadComboboxMenu$1 as TypeaheadComboboxMenu, TypeaheadComboboxMultiSelectInput$1 as TypeaheadComboboxMultiSelectInput, index as TypeaheadComboboxReactAria, TypeaheadComboboxRoot$1 as TypeaheadComboboxRoot, TypeaheadComboboxSectionHeader$1 as TypeaheadComboboxSectionHeader, TypeaheadComboboxSelectedItem, TypeaheadComboboxSeparator$1 as TypeaheadComboboxSeparator, TypeaheadComboboxToggleButton$1 as TypeaheadComboboxToggleButton, Typography, WarningFillIcon, WarningIcon, consumerDarkColorList, consumerLightColorList, findClosestOptionSibling, findHighlightedOption, flushFastdomForTesting, getAnimationCss, getComboboxOptionItemWrapperStyles, getContentOptions, getDarkModePortalStyles, getGlobalResetStyles, getGlobalStyles, getSwitchWithLabelStyles, getValidationStateColor, hideIconButtonRowStyles, highlightOption, importantify, isSafeRelativeUrl, isSafeUrl, measure, sanitizeNextUrl, setupDesignSystemEventProviderForTesting, snackBarManager, update, useComboboxState$1 as useComboboxState, useDefaultTreeGridState, useDesignSystemEventComponentCallbacks, useDesignSystemFlags, useDesignSystemTheme, useFastDom, useLegacyNotification, useModalContext, useMultipleSelectionState$1 as useMultipleSelectionState, useNotifyOnFirstView, useRadixModalContext, useSnackBar, useThemedStyles, useTypeaheadComboboxContext, visuallyHidden, withNotifications };
 //# sourceMappingURL=index.js.map