@databricks/design-system 2.0.1 → 2.0.3

package/dist/index.js

@@ -1,11 +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-CFCTOSm8.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-CFCTOSm8.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 Tooltip, K as SparkleDoubleIcon, O as OverflowPopover, L as LoadingState, N as visuallyHidden, P as genSkeletonAnimatedColor, Q as getOffsets, U as DesignSystemEventSuppressInteractionProviderContext, V as DesignSystemEventSuppressInteractionTrueContextValue, X as tableStyles, Y as repeatingElementsStyles, Z as tableClassNames, _ as hideIconButtonRowStyles, $ as hideIconButtonActionCellClassName, a0 as safex, a1 as TitleSkeleton, a2 as useDialogComboboxContext, a3 as PlusIcon, a4 as importantify, a5 as getComboboxOptionItemWrapperStyles, a6 as getFooterStyles, 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 TypeaheadComboboxContextProvider, an as useTypeaheadComboboxContext, ao as useDuboisThemeClass, ap as useDesignTokenOverrideStyles, aq as getComboboxContentWrapperStyles, ar as ClearSelectionButton, as as TypeaheadComboboxSelectedItem, at as CountBadge, au as getValidationStateColor, av as SectionHeader, aw as useComboboxState$1, ax as useMultipleSelectionState$1, 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, a_ as TypeaheadComboboxV2ContextProvider, a$ as useTypeaheadComboboxV2Context, b0 as useRadixModalContext, b1 as useIsomorphicLayoutEffect, b2 as useScrollOptionIntoView, b3 as InfoTooltip, b4 as getInfoIconStyles, b5 as HintRow, b6 as getCheckboxStyles, b7 as getMenuItemStyles, b8 as TypeaheadComboboxSelectedItem$1, b9 as CountBadge$1, ba as TypeaheadComboboxMenuItem } from './WizardStepContentWrapper-DsAS2ZAT.js';
+export { bb as AccessDeniedGraphic, bc as Accordion, bd as AccordionPanel, be as AlignCenterIcon, bf as AlignJustifyIcon, bg as AlignLeftIcon, bh as AlignRightIcon, bi as AlignVerticalBottomIcon, bj as AlignVerticalCenterIcon, bk as AlignVerticalTopIcon, bl as AppIcon, bm as ApplyDesignSystemContextOverrides, bn as ApplyDesignSystemFlags, bo as ArrowDownDotIcon, bp as ArrowDownFillIcon, bq as ArrowDownIcon, br as ArrowInIcon, bs as ArrowInTableIcon, bt as ArrowLeftIcon, bu as ArrowOutTableIcon, bv as ArrowOverIcon, bw as ArrowRightIcon, bx as ArrowUpDotIcon, by as ArrowUpFillIcon, bz as ArrowUpIcon, bA as ArrowsCollapseIcon, bB as ArrowsConnectIcon, bC as ArrowsExpandIcon, bD as ArrowsUpDownIcon, bE as AssistantIcon, bF as AtIcon, bG as Auth0Graphic, bH as Auth0GraphicLarge, bI as AzHorizontalIcon, bJ as AzVerticalIcon, bK as BANNER_MAX_HEIGHT, bL as BANNER_MIN_HEIGHT, bM as BackupIcon, bN as BadgeCodeIcon, bO as BadgeCodeOffIcon, bP as Banner, bQ as BarChartIcon, bR as BarGroupedIcon, bS as BarStackedIcon, bT as BarStackedPercentageIcon, bU as BarsAscendingHorizontalIcon, bV as BarsAscendingVerticalIcon, bW as BarsDescendingHorizontalIcon, bX as BarsDescendingVerticalIcon, bY as BeakerIcon, bZ as BinaryIcon, b_ as BlockQuoteIcon, b$ as BoldIcon, c0 as BookIcon, c1 as BookmarkFillIcon, c2 as BookmarkIcon, c3 as BooksIcon, c4 as BracketsCheckIcon, c5 as BracketsCurlyIcon, c6 as BracketsErrorIcon, c7 as BracketsSquareIcon, c8 as BracketsXIcon, c9 as BranchCheckIcon, ca as BranchIcon, cb as BranchResetIcon, cc as BriefcaseFillIcon, cd as BriefcaseIcon, ce as BrushIcon, cf as BugIcon, cg as CalendarClockIcon, ch as CalendarEventIcon, ci as CalendarIcon, cj as CalendarRangeIcon, ck as CalendarSyncIcon, cl as CameraIcon, cm as CapitalizeIcon, cn as CaretDownSquareIcon, co as CaretUpSquareIcon, cp as CatalogCloudIcon, cq as CatalogGearIcon, cr as CatalogHomeIcon, cs as CatalogIcon, ct as CatalogOffIcon, cu as CatalogSharedIcon, cv as CatalogUserHomeIcon, cw as CellsSquareIcon, cx as CertifiedFillIcon, cy as CertifiedFillSmallIcon, cz as CertifiedIcon, cA as ChainIcon, cB as ChartLineIcon, cC as CheckCircleBadgeIcon, cD as CheckCircleSmallIcon, cE as CheckIcon, cF as CheckLineIcon, cG as CheckSmallIcon, cH as CheckboxIcon, cI as ChecklistIcon, cJ as ChevronDoubleDownIcon, cK as ChevronDoubleLeftIcon, cL as ChevronDoubleLeftOffIcon, cM as ChevronDoubleRightIcon, cN as ChevronDoubleRightOffIcon, cO as ChevronDoubleUpIcon, cP as ChevronLeftIcon, cQ as ChevronUpIcon, cR as ChipIcon, cS as CircleOffLargeIcon, cT as CircleOutlineLargeIcon, cU as ClipboardIcon, cV as ClockIcon, cW as ClockKeyIcon, cX as ClockOffIcon, cY as CloudCheckIcon, cZ as CloudDatabaseIcon, c_ as CloudDownloadIcon, c$ as CloudIcon, d0 as CloudKeyIcon, d1 as CloudModelIcon, d2 as CloudOffIcon, d3 as CloudUploadIcon, d4 as CodeIcon, d5 as ColorFillIcon, d6 as ColorVars, d7 as ColumnIcon, d8 as ColumnSplitIcon, d9 as ColumnTagIcon, da as ColumnsIcon, db as CommandIcon, dc as CommandPaletteIcon, dd as CompassIcon, de as ComponentFinderContext, df as ConnectIcon, dg as Content, dh as ContextMenu, di as CopyIcon, dj as CreditCardIcon, dk as CursorClickIcon, dl as CursorIcon, dm as CursorPagination, dn as CursorTypeIcon, dp as CustomAppIcon, dq as DS_OVERRIDE_TOKENS_WRAPPER_TESTID, dr as DagHorizontalIcon, ds as DagIcon, dt as DagVerticalIcon, du as DangerModal, dv as DangerSmallIcon, dw as DashIcon, dx as DashboardCodeIcon, dy as DashboardIcon, dz as DataIcon, dA as DataMaskiingGraphic, dB as DatabaseClockIcon, dC as DatabaseIcon, dD as DatabaseImportIcon, dE as DatePicker, dF as DecimalIcon, dG as DeprecatedIcon, dH as DeprecatedSmallIcon, dI as DesignSystemContext, dJ as DesignSystemEventProviderComponentSubTypes, dK as DesignSystemProvider, dL as DesignSystemThemeContext, dM as DesignSystemThemeProvider, dN as DialogComboboxCountBadge, dO as DialogComboboxCustomButtonTriggerWrapper, dP as DialogComboboxSectionHeader, D as DocumentationSidebar, dQ as DollarIcon, dR as DomainCirclesThree, dS as DomainsIcon, dT as DotsCircleIcon, dU as DownloadIcon, dV as DragIcon, dW as Drawer, dX as DropdownMenu, dY as Empty, dZ as EmptyDashboardGraphic, d_ as ErdIcon, d$ as ExpandLessIcon, e0 as ExpandMoreIcon, F as FIXED_VERTICAL_STEPPER_WIDTH, e1 as FaceFrownIcon, e2 as FaceNeutralIcon, e3 as FaceSmileIcon, e4 as FileCodeIcon, e5 as FileCubeIcon, e6 as FileDocumentIcon, e7 as FileIcon, e8 as FileImageIcon, e9 as FileLockIcon, ea as FileModelIcon, eb as FileNewIcon, ec as FilePipelineIcon, ed as FilterFillIcon, ee as FilterIcon, ef as FlagPointerIcon, eg as FloatIcon, eh as FlowIcon, ei as FlowsIcon, ej as FolderBranchFillIcon, ek as FolderBranchIcon, el as FolderCloudFilledIcon, em as FolderCloudIcon, en as FolderCubeIcon, eo as FolderCubeOutlineIcon, ep as FolderFillIcon, eq as FolderHomeIcon, er as FolderIcon, es as FolderNewIcon, et as FolderNodeIcon, eu as FolderOpenBranchIcon, ev as FolderOpenCloudIcon, ew as FolderOpenCubeIcon, ex as FolderOpenIcon, ey as FolderOpenPipelineIcon, ez as FolderOutlinePipelineIcon, eA as FolderSolidPipelineIcon, eB as FontIcon, eC as ForkHorizontalIcon, eD as ForkIcon, eE as Form, eF as FormContextResetBoundary, eG as FullscreenExitIcon, eH as FullscreenIcon, eI as FunctionIcon, eJ as FunctionInputIcon, eK as GavelIcon, eL as GearFillIcon, eM as GearIcon, eN as GenieCodeIcon, eO as GenieDeepResearchIcon, eP as GiftIcon, eQ as GitCommitIcon, eR as GitMergeIcon, eS as GitRebaseIcon, eT as GlobeIcon, eU as Graphic, eV as GridDashIcon, eW as GridIcon, eX as GroupIcon, eY as H1Icon, eZ as H2Icon, e_ as H3Icon, e$ as H4Icon, f0 as H5Icon, f1 as H6Icon, f2 as HashIcon, f3 as HistoryIcon, f4 as HomeIcon, f5 as Icon, f6 as ImageIcon, f7 as IndentDecreaseIcon, f8 as IndentIncreaseIcon, f9 as InfinityIcon, fa as InfoBookIcon, fb as InfoIcon, fc as IngestionIcon, fd as ItalicIcon, fe as JoinOperatorIcon, ff as KeyIcon, fg as KeyboardIcon, fh as LakebaseCatalogIcon, fi as LakebaseIcon, fj as LakeflowDesignerIcon, fk as LakewatchAlertIcon, fl as LakewatchDatasourceIcon, fm as LakewatchDetectionRuleIcon, fn as LakewatchParserIcon, fo as LayerGraphIcon, fp as LayerIcon, fq as Layout, fr as LeafIcon, fs as LegacyForm, ft as LegacyFormDubois, fu as LegacyOptGroup, fv as LegacyOption, fw as LegacySelectOptGroup, fx as LegacySelectOption, fy as LegacyTable, fz as LegacyTooltip, fA as LetterFormatIcon, fB as LettersIcon, fC as LettersNumbersIcon, fD as LibrariesIcon, fE as LifesaverIcon, fF as LightbulbIcon, fG as LightningCircleFillIcon, fH as LightningIcon, fI as LinearLineIcon, fJ as LinkIcon, fK as LinkOffIcon, fL as ListBorderIcon, fM as ListClearIcon, fN as ListIcon, fO as ListNumberIcon, fP as Listbox, fQ as LoadingIcon, fR as LoadingStateContext, fS as LockFillIcon, fT as LockIcon, fU as LockShareIcon, fV as LockUnlockedIcon, fW as LoopIcon, fX as LowercaseIcon, M as MAX_VERTICAL_WIZARD_CONTENT_WIDTH, fY as MailIcon, fZ as MapIcon, f_ as MarkdownIcon, f$ as McpIcon, g0 as MeasureIcon, g1 as MegaphoneIcon, g2 as MenuIcon, g3 as MinusCircleFillIcon, g4 as MinusCircleIcon, g5 as MinusCircleSmallIcon, g6 as MissingBranchGraphic, g7 as MissingGraphic, g8 as ModelsIcon, g9 as MonotoneLineIcon, ga as MonthPickerGrid, gb as MoonIcon, gc as Nav, gd as NavButton, ge as NavigationMenu, gf as NeonProjectIcon, gg as NewChatIcon, gh as NewTabIcon, gi as NewWindowIcon, gj as NoCaseIcon, gk as NoIcon, gl as NotebookIcon, gm as NotebookPipelineIcon, gn as NotificationIcon, go as NotificationOffIcon, gp as NumberFormatIcon, gq as NumbersIcon, gr as OfficeIcon, gs as OntologyIcon, gt as OutageGraphic, gu as Overflow, gv as OverflowHorizontalIcon, gw as OverflowIcon, gx as PageBottomIcon, gy as PageFirstIcon, gz as PageIcon, gA as PageLastIcon, gB as PageTopIcon, gC as Pagination, gD as Panel, gE as PanelBody, gF as PanelDockedIcon, gG as PanelFloatingIcon, gH as PanelHeader, gI as PanelHeaderButtons, gJ as PanelHeaderTitle, gK as PaperclipIcon, gL as PassFailChecklistIcon, gM as PauseIcon, gN as PencilFillIcon, gO as PencilIcon, gP as PencilSparkleIcon, gQ as PieChartIcon, gR as PillControl, gS as PinCancelIcon, gT as PinFillIcon, gU as PinIcon, gV as PipelineCodeIcon, gW as PipelineCubeIcon, gX as PipelineIcon, gY as PivotOperatorIcon, gZ as PlayCircleFillIcon, g_ as PlayCircleIcon, g$ as PlayDoubleIcon, h0 as PlayIcon, h1 as PlayMultipleIcon, h2 as PlugIcon, h3 as PlusCircleFillIcon, h4 as PlusCircleIcon, h5 as PlusCircleSmallIcon, h6 as PlusMinusSquareIcon, h7 as Popover, h8 as PositionBottomIcon, h9 as PositionLeftIcon, ha as PositionRightIcon, hb as PositionTopIcon, hc as PreviewCard, hd as Progress, he as PullRequestIcon, hf as PuzzleIcon, hg as QueryEditorIcon, hh as QueryIcon, hi as QuestionMarkFillIcon, hj as QuestionMarkIcon, hk as RadioIcon, hl as RadioTile, hm as RangePicker, hn as ReaderModeIcon, ho as RedoIcon, hp as RefreshIcon, hq as RefreshPlayIcon, hr as RefreshXIcon, hs as ReplyIcon, ht as ResizeIcon, hu as RhfForm, hv as RichTextIcon, hw as RobotIcon, hx as RocketIcon, hy as RowsIcon, hz as RunIcon, hA as RunningIcon, hB as SMALL_BUTTON_HEIGHT, hC as SaveClockIcon, hD as SaveIcon, hE as SchemaIcon, hF as SchoolIcon, hG as SearchDataIcon, hH as SegmentedControlButton, hI as SegmentedControlGroup, hJ as SelectContext, hK as SelectContextProvider, hL as SelectOptionGroup, hM as SendIcon, hN as ShareIcon, hO as ShareNodesIcon, hP as ShieldCheckIcon, hQ as ShieldIcon, hR as ShieldOffIcon, hS as ShortcutIcon, hT as Sidebar, hU as SidebarAutoIcon, hV as SidebarClosedIcon, hW as SidebarCollapseIcon, hX as SidebarExpandIcon, hY as SidebarIcon, hZ as SidebarOpenIcon, h_ as SidebarSyncIcon, h$ as SimpleSelect, i0 as SimpleSelectOption, i1 as SimpleSelectOptionGroup, i2 as SlashSquareIcon, i3 as Slider, i4 as SlidersIcon, i5 as SnippetIcon, i6 as SortCustomHorizontalIcon, i7 as SortCustomVerticalIcon, i8 as SortHorizontalAscendingIcon, i9 as SortHorizontalDescendingIcon, ia as SortLetterHorizontalAscendingIcon, ib as SortLetterHorizontalDescendingIcon, ic as SortLetterUnsortedIcon, id as SortLetterVerticalAscendingIcon, ie as SortLetterVerticalDescendingIcon, ig as Spacer, ih as SparkleDoubleFillIcon, ii as SparkleFillIcon, ij as SparkleIcon, ik as SparkleRectangleIcon, il as SpeechBubbleIcon, im as SpeechBubblePlusIcon, io as SpeechBubbleQuestionMarkFillIcon, ip as SpeechBubbleQuestionMarkIcon, iq as SpeechBubbleStarIcon, ir as SpeedometerIcon, is as Spinner, it as SplitButton, iu as SqlIcon, iv as StarFillIcon, iw as StarIcon, ix as StepAfterLineIcon, iy as StepBeforeLineIcon, iz as Stepper, iA as StopCircleFillIcon, iB as StopCircleIcon, iC as StopIcon, iD as StoredProcedureIcon, iE as StorefrontIcon, iF as StreamIcon, iG as StrikeThroughIcon, iH as SunIcon, iI as SyncIcon, iJ as SyncSmallIcon, iK as SyncToFileIcon, iL as TableAsteriskIcon, iM as TableClockIcon, iN as TableCombineIcon, iO as TableGlassesIcon, iP as TableGlobeIcon, iQ as TableIcon, iR as TableLightningIcon, iS as TableMeasureIcon, iT as TableModelIcon, iU as TableReportIcon, iV as TableStreamIcon, iW as TableVectorIcon, iX as TableViewIcon, iY as Tabs, iZ as Tag, i_ as TagColumnIcon, i$ as TagIcon, j0 as TagTableIcon, j1 as TargetIcon, j2 as TerminalIcon, j3 as TextBoxIcon, j4 as TextColorIcon, j5 as TextIcon, j6 as TextJustifyIcon, j7 as TextUnderlineIcon, j8 as ThreeDotsIcon, j9 as ThumbsDownFilledIcon, ja as ThumbsDownIcon, jb as ThumbsUpFilledIcon, jc as ThumbsUpIcon, jd as ToggleButton, je as TokenIcon, jf as Toolbar, jg as TrashIcon, jh as Tree, ji as TreeIcon, jj as TrendingFillIcon, jk as TrendingIcon, jl as TriangleIcon, jm as TypeaheadComboboxCheckboxItem, jn as TypeaheadComboboxFooter, jo as TypeaheadComboboxMenuItem, jp as TypeaheadComboboxMultiSelectStateChangeTypes, jq as TypeaheadComboboxStateChangeTypes, jr as UnderlineIcon, js as UndoIcon, jt as UploadIcon, ju as UppercaseIcon, jv as UsageOverageGraphic, jw as UsageSpikeGraphic, jx as UsbIcon, jy as UserBadgeIcon, jz as UserCircleIcon, jA as UserGroupFillIcon, jB as UserGroupIcon, jC as UserIcon, jD as UserKeyIconIcon, jE as UserShieldIcon, jF as UserSparkleIcon, jG as UserTeamIcon, jH as VisibleFillIcon, jI as VisibleIcon, jJ as VisibleOffIcon, jK as WithDesignSystemThemeHoc, W as Wizard, a as WizardControlled, b as WizardModal, c as WizardStepContentWrapper, jL as WorkflowCodeIcon, jM as WorkflowCubeIcon, jN as WorkflowsIcon, jO as WorkspacesIcon, jP as WrenchIcon, jQ as WrenchSparkleIcon, jR as XCircleFillIcon, jS as XCircleIcon, jT as YearPickerGrid, jU as ZaHorizontalIcon, jV as ZaVerticalIcon, jW as ZeroOpsIcon, jX as ZeroOpsOutlineIcon, jY as ZoomInIcon, jZ as ZoomMarqueeSelection, j_ as ZoomOutIcon, j$ as ZoomToFitIcon, k0 as __INTERNAL_DO_NOT_USE__FormItem, k1 as __INTERNAL_DO_NOT_USE__Group, k2 as __INTERNAL_DO_NOT_USE__HorizontalGroup, k3 as __INTERNAL_DO_NOT_USE__VerticalGroup, k4 as __INTERNAL_DO_NOT_USE__wrapLegacyFormRules, k5 as augmentWithDataComponentProps, k6 as dialogComboboxLookAheadKeyDown, k7 as getBottomOnlyShadowScrollStyles, k8 as getButtonEmotionStyles, k9 as getComboboxOptionLabelStyles, ka as getDatePickerQuickActionBasic, kb as getDialogComboboxOptionLabelWidth, kc as getHorizontalTabShadowStyles, kd as getInputStyles, ke as getKeyboardNavigationFunctions, kf as getMemoizedButtonEmotionStyles, kg as getPaginationEmotionStyles, kh as getPanelContainmentStyle, ki as getRadioStyles, kj as getRangeQuickActionsBasic, kk as getShadowScrollStyles, kl as getTypographyColor, km as getVirtualListScrollbarStyles, kn as getVirtualListScrollbarThumbColor, ko as getVirtualizedComboboxMenuItemStyles, kp as getWrapperStyle, kq as highlightFirstNonDisabledOption, kr as isOptionDisabled, ks as resetTabIndexToFocusedElement, kt as setImplicitContextGetter, ku as skipHideIconButtonActionClassName, kv as themeMemoKey, kw as useAntDConfigProviderContext, kx as useCallbackOnEnter, ky as useComponentFinderContext, kz as useDesignSystemEventSuppressInteractionContext, kA as useFormContext, kB as useRadioGroupContext, u as useWizardCurrentStep } from './WizardStepContentWrapper-DsAS2ZAT.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 '@ant-design/icons';
+import React__default, { useState, useRef, useEffect, useCallback, useMemo, forwardRef, useImperativeHandle, createContext, useContext, Children, Fragment as Fragment$1, useLayoutEffect, useReducer, isValidElement } from 'react';
 import { useMergeRefs, useFloating, autoUpdate, offset, flip, shift } from '@floating-ui/react';
 import isUndefined from 'lodash/isUndefined';
 import 'lodash/uniqueId';
@@ -17,6 +16,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';
@@ -34,6 +42,8 @@ import 'lodash/isString';
 import 'lodash/mapValues';
 import '@radix-ui/react-accordion';
 import '@radix-ui/react-tooltip-patch';
+import 'lodash/kebabCase';
+import '@ant-design/icons';
 import 'lodash/random';
 import 'lodash/times';
 import '@radix-ui/react-context-menu';
@@ -133,7 +143,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 +229,8 @@ const consumerLightColorList = {
     textValidationDanger: primitiveColors.red600,
     textValidationSuccess: primitiveColors.green600,
     textValidationWarning: primitiveColors.yellow600,
-    tooltipBackgroundTooltip: primitiveColors.neutral800
+    tooltipBackgroundTooltip: primitiveColors.neutral800,
+    tooltipTextTooltip: primitiveColors.white
 };
 
 /**
@@ -581,7 +593,7 @@ const Alert = ({ componentId, analyticsEvents = [
         }),
         children: [
             props.description,
-            ' ',
+            props.description != null && showMoreContent ? ' ' : null,
             showMoreContent && /*#__PURE__*/ jsx(Typography.Link, {
                 href: "#",
                 componentId: componentId ? `${componentId}.show_more` : 'alert.show_more',
@@ -892,35 +904,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();
@@ -989,6 +972,73 @@ const InfoPopover = ({ children, popoverProps, iconTitle, iconProps, isKeyboardF
     });
 };
 
+/**
+ * A variant of Tooltip that only shows when the child's text content is truncated.
+ * The tooltip content is automatically derived from the child element's textContent,
+ * so consumers don't need to pass the text.
+ *
+ * Truncation is checked lazily only on mouse enter, not during render.
+ * This ensures negligible performance impact even with many TruncationTooltips on the page.
+ *
+ * Detects both:
+ * - Horizontal ellipsis (text-overflow: ellipsis or overflow: hidden)
+ * - Vertical line-clamp (line-clamp or -webkit-line-clamp)
+ *
+ * See go/dubois.
+ */ const TruncationTooltip = ({ children, ...tooltipProps })=>{
+    const [open, setOpen] = useState(false);
+    const [tooltipContent, setTooltipContent] = useState('');
+    const childRef = useRef(null);
+    const handleOpenChange = useCallback((shouldOpen)=>{
+        if (shouldOpen && childRef.current) {
+            const isHorizontallyTruncated = childRef.current.scrollWidth > childRef.current.clientWidth;
+            const isVerticallyTruncated = childRef.current.scrollHeight > childRef.current.clientHeight;
+            if (isHorizontallyTruncated || isVerticallyTruncated) {
+                setTooltipContent(childRef.current.textContent ?? '');
+                setOpen(true);
+            }
+        } else {
+            setOpen(false);
+        }
+    }, []);
+    const wrappedChildren = useMemo(()=>{
+        if (/*#__PURE__*/ React__default.isValidElement(children)) {
+            const childElement = children;
+            // TypeScript doesn't expose ref directly on ReactElement, so we need to cast
+            const originalRef = childElement.ref;
+            return /*#__PURE__*/ React__default.cloneElement(childElement, {
+                ref: (node)=>{
+                    childRef.current = node;
+                    if (typeof originalRef === 'function') {
+                        originalRef(node);
+                    } else if (originalRef) {
+                        originalRef.current = node;
+                    }
+                },
+                // Radix Tooltip sets aria-describedby on the trigger pointing to the tooltip content.
+                // For truncation tooltips this causes screen readers to double-read: the full text is
+                // already in the DOM (CSS truncation is visual-only), so the aria-describedby is
+                // redundant. Setting undefined here overrides Radix's value via Slot prop merging.
+                'aria-describedby': undefined
+            });
+        }
+        return /*#__PURE__*/ jsx("span", {
+            ref: childRef,
+            "aria-describedby": undefined,
+            children: children
+        });
+    }, [
+        children
+    ]);
+    return /*#__PURE__*/ jsx(Tooltip, {
+        ...tooltipProps,
+        content: tooltipContent,
+        open: open,
+        onOpenChange: handleOpenChange,
+        children: wrappedChildren
+    });
+};
+
 const SIZE = new Map([
     [
         'xl',
@@ -1433,52 +1483,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
@@ -2249,7 +2253,7 @@ const DialogComboboxAddButton = ({ children, ...restProps })=>{
         throw new Error('`DialogComboboxAddButton` must be used within `DialogCombobox`');
     }
     return /*#__PURE__*/ jsx(Button, {
-        // eslint-disable-next-line @databricks/no-dynamic-property-value -- Contextual component ID validated through DialogCombobox component exempt:fc0846cb-b73b-401b-834e-75bb8b6d4c20
+        // oxlint-disable-next-line @databricks/no-dynamic-property-value -- Contextual component ID validated through DialogCombobox component exempt:fc0846cb-b73b-401b-834e-75bb8b6d4c20
         componentId: `${componentId ? componentId : 'design_system.dialogcombobox'}.add_option`,
         ...restProps,
         type: "tertiary",
@@ -2301,73 +2305,6 @@ const DialogComboboxHintRow = ({ children })=>{
     });
 };
 
-/**
- * A variant of Tooltip that only shows when the child's text content is truncated.
- * The tooltip content is automatically derived from the child element's textContent,
- * so consumers don't need to pass the text.
- *
- * Truncation is checked lazily only on mouse enter, not during render.
- * This ensures negligible performance impact even with many TruncationTooltips on the page.
- *
- * Detects both:
- * - Horizontal ellipsis (text-overflow: ellipsis or overflow: hidden)
- * - Vertical line-clamp (line-clamp or -webkit-line-clamp)
- *
- * See go/dubois.
- */ const TruncationTooltip = ({ children, ...tooltipProps })=>{
-    const [open, setOpen] = useState(false);
-    const [tooltipContent, setTooltipContent] = useState('');
-    const childRef = useRef(null);
-    const handleOpenChange = useCallback((shouldOpen)=>{
-        if (shouldOpen && childRef.current) {
-            const isHorizontallyTruncated = childRef.current.scrollWidth > childRef.current.clientWidth;
-            const isVerticallyTruncated = childRef.current.scrollHeight > childRef.current.clientHeight;
-            if (isHorizontallyTruncated || isVerticallyTruncated) {
-                setTooltipContent(childRef.current.textContent ?? '');
-                setOpen(true);
-            }
-        } else {
-            setOpen(false);
-        }
-    }, []);
-    const wrappedChildren = useMemo(()=>{
-        if (/*#__PURE__*/ React__default.isValidElement(children)) {
-            const childElement = children;
-            // TypeScript doesn't expose ref directly on ReactElement, so we need to cast
-            const originalRef = childElement.ref;
-            return /*#__PURE__*/ React__default.cloneElement(childElement, {
-                ref: (node)=>{
-                    childRef.current = node;
-                    if (typeof originalRef === 'function') {
-                        originalRef(node);
-                    } else if (originalRef) {
-                        originalRef.current = node;
-                    }
-                },
-                // Radix Tooltip sets aria-describedby on the trigger pointing to the tooltip content.
-                // For truncation tooltips this causes screen readers to double-read: the full text is
-                // already in the DOM (CSS truncation is visual-only), so the aria-describedby is
-                // redundant. Setting undefined here overrides Radix's value via Slot prop merging.
-                'aria-describedby': undefined
-            });
-        }
-        return /*#__PURE__*/ jsx("span", {
-            ref: childRef,
-            "aria-describedby": undefined,
-            children: children
-        });
-    }, [
-        children
-    ]);
-    return /*#__PURE__*/ jsx(Tooltip, {
-        ...tooltipProps,
-        content: tooltipContent,
-        open: open,
-        onOpenChange: handleOpenChange,
-        children: wrappedChildren
-    });
-};
-
 const extractTextContent = (node)=>{
     if (typeof node === 'string' || typeof node === 'number') {
         return node.toString();
@@ -2509,7 +2446,7 @@ const DialogComboboxOptionListSearch = /*#__PURE__*/ forwardRef(// eslint-disabl
                     },
                     children: [
                         /*#__PURE__*/ jsx(Input, {
-                            // eslint-disable-next-line @databricks/no-dynamic-property-value -- Contextual component ID validated through DialogCombobox component exempt:a992c761-9f18-43b0-af9d-dc9ee629260a
+                            // oxlint-disable-next-line @databricks/no-dynamic-property-value -- Contextual component ID validated through DialogCombobox component exempt:a992c761-9f18-43b0-af9d-dc9ee629260a
                             componentId: componentId ? `${componentId}.search` : 'codegen_design_system_src_design_system_dialogcombobox_dialogcomboboxoptionlistsearch.tsx_173',
                             type: "search",
                             name: "search",
@@ -3126,41 +3063,29 @@ children, dangerouslySetAntdProps, onClick, ...restProps }, ref) {
         onClick,
         onValueChange
     ]);
-    // Self-scope the theme class so the native token cascade resolves dark/light here, with no
-    // provider-emitted wrapper node in the consumer tree (DUBOIS-448). Applied to both the bare
-    // switch label AND the .ds-switch-wrapper below, because the wrapper's state-message reads
-    // themed tokens too.
-    const themeClass = useDuboisThemeClass();
-    const rootClassName = classnames('ds-switch', themeClass, className);
+    // Inherits the `--db-color-*` scope (theme-class + consumer override) from the DesignSystemProvider
+    // wrapper; no self-scoped theme class, so a consumer override set on that wrapper reaches here.
+    const rootClassName = classnames('ds-switch', className);
     // Set only one of checked/defaultChecked — React warns if an input has both.
     const checkedStateProps = checked !== undefined ? {
         checked
     } : {
         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;
@@ -3177,7 +3102,7 @@ children, dangerouslySetAntdProps, onClick, ...restProps }, ref) {
     });
     return /*#__PURE__*/ jsx("div", {
         ...addDebugOutlineIfEnabled(),
-        className: classnames('ds-switch-wrapper', themeClass),
+        className: "ds-switch-wrapper",
         children: hasNewLabels ? /*#__PURE__*/ jsxs(Fragment, {
             children: [
                 labelComponent,
@@ -3212,11 +3137,14 @@ 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)=>{
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ const TypeaheadComboboxRoot$1 = /*#__PURE__*/ forwardRef(({ comboboxState, multiSelect = false, floatingStrategy = 'absolute', children, ...props }, ref)=>{
     const { classNamePrefix } = useDesignSystemTheme();
     const { refs, floatingStyles } = useFloating({
         whileElementsMounted: autoUpdate,
@@ -3255,11 +3183,11 @@ 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,
-            // eslint-disable-next-line @databricks/no-dynamic-property-value -- Valid case, as combostate componentId is checked in the hook exempt:a7de1e72-e1ae-4747-9806-90853bef6a06
+            // oxlint-disable-next-line @databricks/no-dynamic-property-value -- Valid case, as combostate componentId is checked in the hook exempt:a7de1e72-e1ae-4747-9806-90853bef6a06
             "data-component-id": comboboxState.componentId,
             children: children
         })
@@ -3274,8 +3202,11 @@ 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)
-({ comboboxState, loading, emptyText, width, minWidth = 240, maxWidth, minHeight, maxHeight, listWrapperHeight, virtualizerRef, children, matchTriggerWidth, ...restProps }, ref)=>{
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ 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, className, style, ...restProps }, ref)=>{
     const { getMenuProps, isOpen } = comboboxState;
     const { ref: downshiftRef, ...downshiftProps } = getMenuProps({}, {
         suppressRefError: true
@@ -3293,6 +3224,8 @@ const TypeaheadComboboxMenu = /*#__PURE__*/ forwardRef(// eslint-disable-next-li
     ]);
     const { theme } = useDesignSystemTheme();
     const { getPopupContainer } = useDesignSystemContext();
+    const themeClass = useDuboisThemeClass();
+    const themeOverrideStyle = useDesignTokenOverrideStyles();
     const recalculateMaxHeight = useCallback(()=>{
         if (isOpen && floatingUiRefs?.floating && floatingUiRefs.reference.current && floatingUiRefs?.reference && floatingUiRefs.floating.current) {
             computePosition(floatingUiRefs.reference.current, floatingUiRefs.floating.current, {
@@ -3369,10 +3302,13 @@ const TypeaheadComboboxMenu = /*#__PURE__*/ forwardRef(// eslint-disable-next-li
                 width: inputWidth
             }
         ],
+        ...restProps,
+        className: classnames(className, themeClass),
         style: {
-            ...floatingStyles
+            ...floatingStyles,
+            ...style,
+            ...themeOverrideStyle
         },
-        ...restProps,
         children: loading ? /*#__PURE__*/ jsx(LoadingSpinner, {
             "aria-label": "Loading",
             alt: "Loading spinner"
@@ -3402,7 +3338,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 +3355,10 @@ const getToggleButtonStyles = (theme, disabled)=>{
         }
     });
 };
-const TypeaheadComboboxToggleButton = /*#__PURE__*/ React__default.forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ 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 +3370,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 +3406,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 +3421,10 @@ 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)
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ 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) {
@@ -3554,14 +3497,14 @@ const TypeaheadComboboxInput = /*#__PURE__*/ forwardRef(// eslint-disable-next-l
         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:ef606c74-b984-4035-bbdb-9a6ae8e4e88e
+            // oxlint-disable-next-line @databricks/no-dynamic-property-value -- Valid case, as combostate componentId is checked in the hook exempt:ef606c74-b984-4035-bbdb-9a6ae8e4e88e
             componentId: componentId ? `${componentId}.input` : 'design_system.typeahead_combobox.input',
             ref: mergedRef,
             ...downshiftProps,
             "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 +3514,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 +3529,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 +3586,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 +3608,7 @@ const getScrollContainerStyles = (maxHeight)=>{
         } : {}
     });
 };
-const getContentWrapperStyles = ()=>{
+const getContentWrapperStyles$1 = ()=>{
     return /*#__PURE__*/ css({
         display: 'flex',
         flex: 'auto',
@@ -3665,7 +3617,7 @@ const getContentWrapperStyles = ()=>{
         position: 'relative'
     });
 };
-const getInputWrapperStyles = ()=>{
+const getInputWrapperStyles$1 = ()=>{
     return /*#__PURE__*/ css({
         display: 'inline-flex',
         position: 'relative',
@@ -3679,7 +3631,7 @@ const getInputWrapperStyles = ()=>{
         minWidth: 40
     });
 };
-const getInputStyles = (theme)=>{
+const getInputStyles$2 = (theme)=>{
     return /*#__PURE__*/ css({
         lineHeight: 20,
         height: 24,
@@ -3699,8 +3651,12 @@ 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)=>{
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ 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 +3828,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 +3869,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 +3916,10 @@ const TypeaheadComboboxMultiSelectInput = /*#__PURE__*/ forwardRef(// eslint-dis
     return content;
 });
 
-const TypeaheadComboboxSectionHeader = ({ children, ...props })=>{
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ const TypeaheadComboboxSectionHeader$1 = ({ children, ...props })=>{
     const { isInsideTypeaheadCombobox } = useTypeaheadComboboxContext();
     if (!isInsideTypeaheadCombobox) {
         throw new Error('`TypeaheadComboboxSectionHeader` must be used within `TypeaheadComboboxMenu`');
@@ -3970,7 +3930,10 @@ const TypeaheadComboboxSectionHeader = ({ children, ...props })=>{
     });
 };
 
-const TypeaheadComboboxSeparator = (props)=>{
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ const TypeaheadComboboxSeparator$1 = (props)=>{
     const { isInsideTypeaheadCombobox } = useTypeaheadComboboxContext();
     if (!isInsideTypeaheadCombobox) {
         throw new Error('`TypeaheadComboboxSeparator` must be used within `TypeaheadComboboxMenu`');
@@ -3980,7 +3943,10 @@ const TypeaheadComboboxSeparator = (props)=>{
     });
 };
 
-const TypeaheadComboboxAddButton = /*#__PURE__*/ forwardRef(// eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
+/**
+ * Deprecated in favor of `TypeaheadComboboxV2`.
+ * @deprecated
+ */ 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();
@@ -3989,7 +3955,7 @@ const TypeaheadComboboxAddButton = /*#__PURE__*/ forwardRef(// eslint-disable-ne
     }
     return /*#__PURE__*/ jsx(Button, {
         ...restProps,
-        // eslint-disable-next-line @databricks/no-dynamic-property-value -- Validated in the Root for the context exempt:844c1e83-84b8-41ba-95af-bae4799834aa
+        // oxlint-disable-next-line @databricks/no-dynamic-property-value -- Validated in the Root for the context exempt:844c1e83-84b8-41ba-95af-bae4799834aa
         componentId: `${componentId}.add_option`,
         type: "tertiary",
         onClick: (event)=>{
@@ -4256,7 +4222,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 +4252,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 +4296,7 @@ function RHFControlledMultiSelectTypeaheadCombobox({ name, control, rules, allIt
         field.onChange(item);
         setSelectedItems(item);
     };
-    const comboboxState = useComboboxState({
+    const comboboxState = useComboboxState$1({
         allItems,
         items,
         setInputValue,
@@ -4346,7 +4312,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 +4323,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 +4337,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,14 +4510,19 @@ const FormUI = {
     HorizontalFormRow
 };
 
-const Col = ({ dangerouslySetAntdProps, ...props })=>/*#__PURE__*/ jsx(DesignSystemAntDConfigProvider, {
+const Col = (props)=>/*#__PURE__*/ jsx(DesignSystemAntDConfigProvider, {
         children: /*#__PURE__*/ jsx(Col$1, {
-            ...props,
-            ...dangerouslySetAntdProps
+            ...props
         })
     });
 
-const ROW_GUTTER_SIZE = 8;
+/**
+ * Default horizontal gutter (px) for `Row`. NOTE this diverges from AntD's own default of `0`:
+ * DuBois has always defaulted `Row` to `8`, and ~75% of `<Row>` usages rely on it, so both the
+ * AntD-backed `Row` and the native `NativeRow` must apply it. Kept in its own module so both
+ * variants (and the flag-gated `Row`) share one source without an import cycle.
+ */ const ROW_GUTTER_SIZE = 8;
+
 const Row = ({ gutter = ROW_GUTTER_SIZE, ...props })=>{
     return /*#__PURE__*/ jsx(DesignSystemAntDConfigProvider, {
         children: /*#__PURE__*/ jsx(Row$1, {
@@ -4693,6 +4664,8 @@ const Header = ({ breadcrumbs, title, titleAddOns, dangerouslyAppendEmotionCSS,
         maxWidth,
         backgroundColor
     });
+    const themeClass = useDuboisThemeClass();
+    const themeOverrideStyle = useDesignTokenOverrideStyles();
     return /*#__PURE__*/ jsxs(RadixHoverCard.Root, {
         ...props,
         children: [
@@ -4707,6 +4680,8 @@ const Header = ({ breadcrumbs, title, titleAddOns, dangerouslyAppendEmotionCSS,
                     sideOffset: sideOffset,
                     align: align,
                     css: hoverCardStyles['content'],
+                    className: themeClass,
+                    style: themeOverrideStyle,
                     children: [
                         content,
                         withArrow && /*#__PURE__*/ jsx(RadixHoverCard.Arrow, {
@@ -5079,7 +5054,7 @@ const getToastRootStyle = (theme, classNamePrefix)=>{
 const Root = // eslint-disable-next-line react-component-name/react-component-name -- TODO(FEINF-4716)
 /*#__PURE__*/ forwardRef(function({ children, severity = 'info', severityLabel, componentId, analyticsEvents = [
     DesignSystemEventProviderAnalyticsEventTypes.OnView
-], ...props }, ref) {
+], className, style, ...props }, ref) {
     const { theme, classNamePrefix } = useDesignSystemTheme();
     const memoizedAnalyticsEvents = useMemo(()=>analyticsEvents, [
         analyticsEvents
@@ -5095,6 +5070,8 @@ const Root = // eslint-disable-next-line react-component-name/react-component-na
     const { elementRef } = useNotifyOnFirstView({
         onView: eventContext.onView
     });
+    const themeClass = useDuboisThemeClass();
+    const themeOverrideStyle = useDesignTokenOverrideStyles();
     // Radix Toast already has a hidden announcer — the legacy `<span role="status" aria-live>`
     // wrapper double-announced. We rely on Radix's defaults (`role="status"` on the <li>) and
     // pass `type="foreground"` for errors so the hidden announcer goes assertive. The
@@ -5106,6 +5083,11 @@ const Root = // eslint-disable-next-line react-component-name/react-component-na
         ...props,
         ...addDebugOutlineIfEnabled(),
         ...preventSwipeToClose(),
+        className: classnames(className, themeClass),
+        style: {
+            ...style,
+            ...themeOverrideStyle
+        },
         children: [
             /*#__PURE__*/ jsx(SeverityIcon, {
                 className: `${classNamePrefix}-notification-severity-icon ${classNamePrefix}-notification-${severity}-icon`,
@@ -5449,6 +5431,8 @@ const getViewportStyle = (theme, vertical, horizontal)=>{
 };
 const SnackBarRoot = /*#__PURE__*/ forwardRef(function SnackBarRoot({ snack }, ref) {
     const { theme } = useDesignSystemTheme();
+    const themeClass = useDuboisThemeClass();
+    const themeOverrideStyle = useDesignTokenOverrideStyles();
     const memoizedAnalyticsEvents = useMemo(()=>[
             DesignSystemEventProviderAnalyticsEventTypes.OnView
         ], []);
@@ -5489,9 +5473,13 @@ const SnackBarRoot = /*#__PURE__*/ forwardRef(function SnackBarRoot({ snack }, r
     return /*#__PURE__*/ jsxs(Toast.Root, {
         ref: ref,
         css: getSnackBarRootStyle(theme, snack.backgroundColor, snack.textColor),
-        style: snack.closeButton === false ? {
-            cursor: 'pointer'
-        } : undefined,
+        className: themeClass,
+        style: {
+            ...snack.closeButton === false ? {
+                cursor: 'pointer'
+            } : undefined,
+            ...themeOverrideStyle
+        },
         open: snack.open,
         onOpenChange: handleOpenChange,
         duration: snack.autoDismiss,
@@ -6420,11 +6408,1750 @@ 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,
+            showAllOptionsOnOpen: comboboxState.showAllOptionsOnOpen,
+            isInsideTypeaheadCombobox: true,
+            comboBoxState: state,
+            inputProps,
+            listBoxProps,
+            buttonProps,
+            inputRef,
+            listBoxRef,
+            popoverRef,
+            buttonRef,
+            triggerRef,
+            footerFocusable,
+            footerRef,
+            itemsByKey,
+            getKeyForItem,
+            itemToString,
+            removeByKey,
+            clearSelection
+        }), [
+        comboboxState.componentId,
+        comboboxState.multiSelect,
+        comboboxState.showAllOptionsOnOpen,
+        state,
+        inputProps,
+        listBoxProps,
+        buttonProps,
+        footerFocusable,
+        itemsByKey,
+        getKeyForItem,
+        itemToString,
+        removeByKey,
+        clearSelection
+    ]);
+    return /*#__PURE__*/ jsx(TypeaheadComboboxV2ContextProvider, {
+        value: contextValue,
+        children: /*#__PURE__*/ jsx("div", {
+            className: `${classNamePrefix}-typeahead-combobox-react-aria`,
+            css: ROOT_CSS,
+            ...props,
+            ref: mergedRef,
+            "data-component-type": DesignSystemEventProviderComponentTypes.TypeaheadCombobox,
+            // oxlint-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 } = useTypeaheadComboboxV2Context();
+    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 = useTypeaheadComboboxV2Context();
+    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 = useTypeaheadComboboxV2Context();
+    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_v2.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 } = useTypeaheadComboboxV2Context();
+    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 = useTypeaheadComboboxV2Context();
+    if (!ctx.isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxInput` must be used within `TypeaheadComboboxRoot`');
+    }
+    const { inputProps, inputRef, comboBoxState: state, setTriggerWidth, triggerRef, componentId, clearSelection, footerFocusable, footerRef, showAllOptionsOnOpen } = 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.
+        // showAllOptionsOnOpen: open via the 'manual' trigger so react-aria shows all options; typing re-filters.
+        if (state && !state.isOpen) state.open(null, showAllOptionsOnOpen ? 'manual' : undefined);
+    };
+    // 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/TypeaheadComboboxV2FooterFocus.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, {
+            // oxlint-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_v2.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 = useTypeaheadComboboxV2Context();
+    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 } = useTypeaheadComboboxV2Context();
+    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 } = useTypeaheadComboboxV2Context();
+    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 } = useTypeaheadComboboxV2Context();
+    if (!isInsideTypeaheadCombobox) {
+        throw new Error('`TypeaheadComboboxAddButton` must be used within `TypeaheadComboboxRoot`');
+    }
+    return /*#__PURE__*/ jsx(Button, {
+        ...restProps,
+        // oxlint-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
+    };
+}
+
+/**
+ * Keeps an 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-focuses when nothing is focused, so 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 commits the typed text, so
+ * pre-highlighting an option would hijack it and select the option instead.
+ */ function useRestoreHighlightedOption(state, { allowNewValue, showAllOptionsOnOpen }) {
+    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;
+        // On a show-all reopen the selected option is not necessarily first, so highlight it (not option 0)
+        // — aria-activedescendant should land on the current selection. Only while the list is still
+        // unfiltered though: the input then still shows the selection's label, so once the user types a query
+        // (input diverges) react-stately filters and we highlight the first match for Enter, as usual.
+        const selectedKey = state.selectedKey;
+        const selectedNode = selectedKey != null ? collection.getItem(selectedKey) : null;
+        const showingSelection = selectedNode != null && state.inputValue === selectedNode.textValue;
+        let candidate = showAllOptionsOnOpen && showingSelection ? selectedKey : 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,
+        showAllOptionsOnOpen,
+        state.selectedKey,
+        state.inputValue
+    ]);
+}
+
+/**
+ * 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, showAllOptionsOnOpen = 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;
+    useRestoreHighlightedOption(state, {
+        allowNewValue,
+        showAllOptionsOnOpen
+    });
+    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,
+        showAllOptionsOnOpen
+    };
+}
+
+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,
+  useTypeaheadComboboxV2Context: useTypeaheadComboboxV2Context,
+  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";
+// Monospace counterpart to DM_SANS_FONT_FAMILY, vendored under
+// `@databricks/design-system/fonts/dm-mono.css`. Falls back to the platform monospace stack so
+// code and other tabular text keep a fixed-width face if the web font fails to load.
+const DM_MONO_FONT_FAMILY = "'DM Mono', ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace";
 
-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_MONO_FONT_FAMILY, 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, TypeaheadComboboxRoot$1 as TypeaheadComboboxRoot, TypeaheadComboboxSectionHeader$1 as TypeaheadComboboxSectionHeader, TypeaheadComboboxSelectedItem, TypeaheadComboboxSeparator$1 as TypeaheadComboboxSeparator, TypeaheadComboboxToggleButton$1 as TypeaheadComboboxToggleButton, index as TypeaheadComboboxV2, 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, useDesignTokenOverrideStyles, useDuboisThemeClass, useFastDom, useLegacyNotification, useModalContext, useMultipleSelectionState$1 as useMultipleSelectionState, useNotifyOnFirstView, useRadixModalContext, useSnackBar, useThemedStyles, useTypeaheadComboboxContext, visuallyHidden, withNotifications };
 //# sourceMappingURL=index.js.map