// Utilities
"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    Accordion: function() {
        return _reactaccordion.Accordion;
    },
    AccordionHeader: function() {
        return _reactaccordion.AccordionHeader;
    },
    AccordionItem: function() {
        return _reactaccordion.AccordionItem;
    },
    AccordionItemProvider: function() {
        return _reactaccordion.AccordionItemProvider;
    },
    AccordionPanel: function() {
        return _reactaccordion.AccordionPanel;
    },
    AccordionProvider: function() {
        return _reactaccordion.AccordionProvider;
    },
    AlphaSlider: function() {
        return _reactcolorpicker.AlphaSlider;
    },
    AnnounceProvider: function() {
        return _reactsharedcontexts.AnnounceProvider;
    },
    AppItem: function() {
        return _reactnav.AppItem;
    },
    AppItemStatic: function() {
        return _reactnav.AppItemStatic;
    },
    AriaLiveAnnouncer: function() {
        return _reactaria.AriaLiveAnnouncer;
    },
    Avatar: function() {
        return _reactavatar.Avatar;
    },
    AvatarGroup: function() {
        return _reactavatar.AvatarGroup;
    },
    AvatarGroupItem: function() {
        return _reactavatar.AvatarGroupItem;
    },
    AvatarGroupPopover: function() {
        return _reactavatar.AvatarGroupPopover;
    },
    AvatarGroupProvider: function() {
        return _reactavatar.AvatarGroupProvider;
    },
    Badge: function() {
        return _reactbadge.Badge;
    },
    Body1: function() {
        return _reacttext.Body1;
    },
    Body1Strong: function() {
        return _reacttext.Body1Strong;
    },
    Body1Stronger: function() {
        return _reacttext.Body1Stronger;
    },
    Body2: function() {
        return _reacttext.Body2;
    },
    Breadcrumb: function() {
        return _reactbreadcrumb.Breadcrumb;
    },
    BreadcrumbButton: function() {
        return _reactbreadcrumb.BreadcrumbButton;
    },
    BreadcrumbDivider: function() {
        return _reactbreadcrumb.BreadcrumbDivider;
    },
    BreadcrumbItem: function() {
        return _reactbreadcrumb.BreadcrumbItem;
    },
    BreadcrumbProvider: function() {
        return _reactbreadcrumb.BreadcrumbProvider;
    },
    Button: function() {
        return _reactbutton.Button;
    },
    Caption1: function() {
        return _reacttext.Caption1;
    },
    Caption1Strong: function() {
        return _reacttext.Caption1Strong;
    },
    Caption1Stronger: function() {
        return _reacttext.Caption1Stronger;
    },
    Caption2: function() {
        return _reacttext.Caption2;
    },
    Caption2Strong: function() {
        return _reacttext.Caption2Strong;
    },
    Card: function() {
        return _reactcard.Card;
    },
    CardFooter: function() {
        return _reactcard.CardFooter;
    },
    CardHeader: function() {
        return _reactcard.CardHeader;
    },
    CardPreview: function() {
        return _reactcard.CardPreview;
    },
    Carousel: function() {
        return _reactcarousel.Carousel;
    },
    CarouselAutoplayButton: function() {
        return _reactcarousel.CarouselAutoplayButton;
    },
    CarouselButton: function() {
        return _reactcarousel.CarouselButton;
    },
    CarouselCard: function() {
        return _reactcarousel.CarouselCard;
    },
    CarouselNav: function() {
        return _reactcarousel.CarouselNav;
    },
    CarouselNavButton: function() {
        return _reactcarousel.CarouselNavButton;
    },
    CarouselNavContainer: function() {
        return _reactcarousel.CarouselNavContainer;
    },
    CarouselNavImageButton: function() {
        return _reactcarousel.CarouselNavImageButton;
    },
    CarouselProvider: function() {
        return _reactcarousel.CarouselProvider;
    },
    CarouselSlider: function() {
        return _reactcarousel.CarouselSlider;
    },
    CarouselViewport: function() {
        return _reactcarousel.CarouselViewport;
    },
    Checkbox: function() {
        return _reactcheckbox.Checkbox;
    },
    ColorArea: function() {
        return _reactcolorpicker.ColorArea;
    },
    ColorPicker: function() {
        return _reactcolorpicker.ColorPicker;
    },
    ColorSlider: function() {
        return _reactcolorpicker.ColorSlider;
    },
    ColorSwatch: function() {
        return _reactswatchpicker.ColorSwatch;
    },
    ColumnIdContextProvider: function() {
        return _reacttable.ColumnIdContextProvider;
    },
    Combobox: function() {
        return _reactcombobox.Combobox;
    },
    // eslint-disable-next-line @typescript-eslint/no-deprecated
    ComboboxProvider: function() {
        return _reactcombobox.ComboboxProvider;
    },
    CompoundButton: function() {
        return _reactbutton.CompoundButton;
    },
    CounterBadge: function() {
        return _reactbadge.CounterBadge;
    },
    DATA_OVERFLOWING: function() {
        return _reactoverflow.DATA_OVERFLOWING;
    },
    DATA_OVERFLOW_DIVIDER: function() {
        return _reactoverflow.DATA_OVERFLOW_DIVIDER;
    },
    DATA_OVERFLOW_ITEM: function() {
        return _reactoverflow.DATA_OVERFLOW_ITEM;
    },
    DATA_OVERFLOW_MENU: function() {
        return _reactoverflow.DATA_OVERFLOW_MENU;
    },
    DataGrid: function() {
        return _reacttable.DataGrid;
    },
    DataGridBody: function() {
        return _reacttable.DataGridBody;
    },
    DataGridCell: function() {
        return _reacttable.DataGridCell;
    },
    DataGridContextProvider: function() {
        return _reacttable.DataGridContextProvider;
    },
    DataGridHeader: function() {
        return _reacttable.DataGridHeader;
    },
    DataGridHeaderCell: function() {
        return _reacttable.DataGridHeaderCell;
    },
    DataGridRow: function() {
        return _reacttable.DataGridRow;
    },
    DataGridSelectionCell: function() {
        return _reacttable.DataGridSelectionCell;
    },
    Dialog: function() {
        return _reactdialog.Dialog;
    },
    DialogActions: function() {
        return _reactdialog.DialogActions;
    },
    DialogBody: function() {
        return _reactdialog.DialogBody;
    },
    DialogContent: function() {
        return _reactdialog.DialogContent;
    },
    DialogProvider: function() {
        return _reactdialog.DialogProvider;
    },
    DialogSurface: function() {
        return _reactdialog.DialogSurface;
    },
    DialogTitle: function() {
        return _reactdialog.DialogTitle;
    },
    DialogTrigger: function() {
        return _reactdialog.DialogTrigger;
    },
    Display: function() {
        return _reacttext.Display;
    },
    Divider: function() {
        return _reactdivider.Divider;
    },
    Drawer: function() {
        return _reactdrawer.Drawer;
    },
    DrawerBody: function() {
        return _reactdrawer.DrawerBody;
    },
    DrawerFooter: function() {
        return _reactdrawer.DrawerFooter;
    },
    DrawerHeader: function() {
        return _reactdrawer.DrawerHeader;
    },
    DrawerHeaderNavigation: function() {
        return _reactdrawer.DrawerHeaderNavigation;
    },
    DrawerHeaderTitle: function() {
        return _reactdrawer.DrawerHeaderTitle;
    },
    DrawerProvider: function() {
        return _reactdrawer.DrawerProvider;
    },
    Dropdown: function() {
        return _reactcombobox.Dropdown;
    },
    EmptySwatch: function() {
        return _reactswatchpicker.EmptySwatch;
    },
    Field: function() {
        return _reactfield.Field;
    },
    FieldContextProvider: function() {
        return _reactfield.FieldContextProvider;
    },
    FlatTree: function() {
        return _reacttree.FlatTree;
    },
    FlatTreeItem: function() {
        return _reacttree.FlatTreeItem;
    },
    FluentProvider: function() {
        return _reactprovider.FluentProvider;
    },
    Hamburger: function() {
        return _reactnav.Hamburger;
    },
    IdPrefixProvider: function() {
        return _reactutilities.IdPrefixProvider;
    },
    Image: function() {
        return _reactimage.Image;
    },
    ImageSwatch: function() {
        return _reactswatchpicker.ImageSwatch;
    },
    InfoButton: function() {
        return _reactinfolabel.InfoButton;
    },
    InfoLabel: function() {
        return _reactinfolabel.InfoLabel;
    },
    InlineDrawer: function() {
        return _reactdrawer.InlineDrawer;
    },
    Input: function() {
        return _reactinput.Input;
    },
    InteractionTag: function() {
        return _reacttags.InteractionTag;
    },
    InteractionTagPrimary: function() {
        return _reacttags.InteractionTagPrimary;
    },
    InteractionTagSecondary: function() {
        return _reacttags.InteractionTagSecondary;
    },
    Label: function() {
        return _reactlabel.Label;
    },
    LargeTitle: function() {
        return _reacttext.LargeTitle;
    },
    Link: function() {
        return _reactlink.Link;
    },
    List: function() {
        return _reactlist.List;
    },
    ListItem: function() {
        return _reactlist.ListItem;
    },
    Listbox: function() {
        return _reactcombobox.Listbox;
    },
    ListboxProvider: function() {
        return _reactcombobox.ListboxProvider;
    },
    Menu: function() {
        return _reactmenu.Menu;
    },
    MenuButton: function() {
        return _reactbutton.MenuButton;
    },
    MenuDivider: function() {
        return _reactmenu.MenuDivider;
    },
    MenuGroup: function() {
        return _reactmenu.MenuGroup;
    },
    MenuGroupContextProvider: function() {
        return _reactmenu.MenuGroupContextProvider;
    },
    MenuGroupHeader: function() {
        return _reactmenu.MenuGroupHeader;
    },
    MenuItem: function() {
        return _reactmenu.MenuItem;
    },
    MenuItemCheckbox: function() {
        return _reactmenu.MenuItemCheckbox;
    },
    MenuItemLink: function() {
        return _reactmenu.MenuItemLink;
    },
    MenuItemRadio: function() {
        return _reactmenu.MenuItemRadio;
    },
    MenuItemSwitch: function() {
        return _reactmenu.MenuItemSwitch;
    },
    MenuList: function() {
        return _reactmenu.MenuList;
    },
    MenuListProvider: function() {
        return _reactmenu.MenuListProvider;
    },
    MenuPopover: function() {
        return _reactmenu.MenuPopover;
    },
    MenuProvider: function() {
        return _reactmenu.MenuProvider;
    },
    MenuSplitGroup: function() {
        return _reactmenu.MenuSplitGroup;
    },
    MenuTrigger: function() {
        return _reactmenu.MenuTrigger;
    },
    MenuTriggerContextProvider: function() {
        return _reactmenu.MenuTriggerContextProvider;
    },
    MessageBar: function() {
        return _reactmessagebar.MessageBar;
    },
    MessageBarActions: function() {
        return _reactmessagebar.MessageBarActions;
    },
    MessageBarBody: function() {
        return _reactmessagebar.MessageBarBody;
    },
    MessageBarContextProvider: function() {
        return _reactmessagebar.MessageBarContextProvider;
    },
    MessageBarGroup: function() {
        return _reactmessagebar.MessageBarGroup;
    },
    MessageBarTitle: function() {
        return _reactmessagebar.MessageBarTitle;
    },
    Nav: function() {
        return _reactnav.Nav;
    },
    NavCategory: function() {
        return _reactnav.NavCategory;
    },
    NavCategoryItem: function() {
        return _reactnav.NavCategoryItem;
    },
    NavCategoryItemProvider: function() {
        return _reactnav.NavCategoryItemProvider;
    },
    NavCategoryProvider: function() {
        return _reactnav.NavCategoryProvider;
    },
    NavDivider: function() {
        return _reactnav.NavDivider;
    },
    NavDrawer: function() {
        return _reactnav.NavDrawer;
    },
    NavDrawerBody: function() {
        return _reactnav.NavDrawerBody;
    },
    NavDrawerFooter: function() {
        return _reactnav.NavDrawerFooter;
    },
    NavDrawerHeader: function() {
        return _reactnav.NavDrawerHeader;
    },
    NavItem: function() {
        return _reactnav.NavItem;
    },
    NavProvider: function() {
        return _reactnav.NavProvider;
    },
    NavSectionHeader: function() {
        return _reactnav.NavSectionHeader;
    },
    NavSubItem: function() {
        return _reactnav.NavSubItem;
    },
    NavSubItemGroup: function() {
        return _reactnav.NavSubItemGroup;
    },
    Option: function() {
        return _reactcombobox.Option;
    },
    OptionGroup: function() {
        return _reactcombobox.OptionGroup;
    },
    Overflow: function() {
        return _reactoverflow.Overflow;
    },
    OverflowDivider: function() {
        return _reactoverflow.OverflowDivider;
    },
    OverflowItem: function() {
        return _reactoverflow.OverflowItem;
    },
    OverlayDrawer: function() {
        return _reactdrawer.OverlayDrawer;
    },
    Persona: function() {
        return _reactpersona.Persona;
    },
    Popover: function() {
        return _reactpopover.Popover;
    },
    PopoverProvider: function() {
        return _reactpopover.PopoverProvider;
    },
    PopoverSurface: function() {
        return _reactpopover.PopoverSurface;
    },
    PopoverTrigger: function() {
        return _reactpopover.PopoverTrigger;
    },
    Portal: function() {
        return _reactportal.Portal;
    },
    PortalMountNodeProvider: function() {
        return _reactsharedcontexts.PortalMountNodeProvider;
    },
    PositioningConfigurationProvider: function() {
        return _reactpositioning.PositioningConfigurationProvider;
    },
    PresenceBadge: function() {
        return _reactbadge.PresenceBadge;
    },
    PresenceGroup: function() {
        return _reactmotion.PresenceGroup;
    },
    ProgressBar: function() {
        return _reactprogress.ProgressBar;
    },
    Radio: function() {
        return _reactradio.Radio;
    },
    RadioGroup: function() {
        return _reactradio.RadioGroup;
    },
    RadioGroupProvider: function() {
        return _reactradio.RadioGroupProvider;
    },
    Rating: function() {
        return _reactrating.Rating;
    },
    RatingDisplay: function() {
        return _reactrating.RatingDisplay;
    },
    RatingItem: function() {
        return _reactrating.RatingItem;
    },
    RatingItemProvider: function() {
        return _reactrating.RatingItemProvider;
    },
    RendererProvider: function() {
        return _react.RendererProvider;
    },
    SSRProvider: function() {
        return _reactutilities.SSRProvider;
    },
    SearchBox: function() {
        return _reactsearch.SearchBox;
    },
    Select: function() {
        return _reactselect.Select;
    },
    Skeleton: function() {
        return _reactskeleton.Skeleton;
    },
    SkeletonContextProvider: function() {
        return _reactskeleton.SkeletonContextProvider;
    },
    SkeletonItem: function() {
        return _reactskeleton.SkeletonItem;
    },
    Slider: function() {
        return _reactslider.Slider;
    },
    SpinButton: function() {
        return _reactspinbutton.SpinButton;
    },
    Spinner: function() {
        return _reactspinner.Spinner;
    },
    SplitButton: function() {
        return _reactbutton.SplitButton;
    },
    SplitNavItem: function() {
        return _reactnav.SplitNavItem;
    },
    Subtitle1: function() {
        return _reacttext.Subtitle1;
    },
    Subtitle2: function() {
        return _reacttext.Subtitle2;
    },
    Subtitle2Stronger: function() {
        return _reacttext.Subtitle2Stronger;
    },
    SwatchPicker: function() {
        return _reactswatchpicker.SwatchPicker;
    },
    SwatchPickerProvider: function() {
        return _reactswatchpicker.SwatchPickerProvider;
    },
    SwatchPickerRow: function() {
        return _reactswatchpicker.SwatchPickerRow;
    },
    Switch: function() {
        return _reactswitch.Switch;
    },
    Tab: function() {
        return _reacttabs.Tab;
    },
    TabList: function() {
        return _reacttabs.TabList;
    },
    TabListProvider: function() {
        return _reacttabs.TabListProvider;
    },
    Table: function() {
        return _reacttable.Table;
    },
    TableBody: function() {
        return _reacttable.TableBody;
    },
    TableCell: function() {
        return _reacttable.TableCell;
    },
    TableCellActions: function() {
        return _reacttable.TableCellActions;
    },
    TableCellLayout: function() {
        return _reacttable.TableCellLayout;
    },
    TableContextProvider: function() {
        return _reacttable.TableContextProvider;
    },
    TableHeader: function() {
        return _reacttable.TableHeader;
    },
    TableHeaderCell: function() {
        return _reacttable.TableHeaderCell;
    },
    TableHeaderContextProvider: function() {
        return _reacttable.TableHeaderContextProvider;
    },
    TableResizeHandle: function() {
        return _reacttable.TableResizeHandle;
    },
    TableRow: function() {
        return _reacttable.TableRow;
    },
    TableRowIdContextProvider: function() {
        return _reacttable.TableRowIdContextProvider;
    },
    TableSelectionCell: function() {
        return _reacttable.TableSelectionCell;
    },
    Tag: function() {
        return _reacttags.Tag;
    },
    TagGroup: function() {
        return _reacttags.TagGroup;
    },
    TagPicker: function() {
        return _reacttagpicker.TagPicker;
    },
    TagPickerButton: function() {
        return _reacttagpicker.TagPickerButton;
    },
    TagPickerControl: function() {
        return _reacttagpicker.TagPickerControl;
    },
    TagPickerGroup: function() {
        return _reacttagpicker.TagPickerGroup;
    },
    TagPickerInput: function() {
        return _reacttagpicker.TagPickerInput;
    },
    TagPickerList: function() {
        return _reacttagpicker.TagPickerList;
    },
    TagPickerOption: function() {
        return _reacttagpicker.TagPickerOption;
    },
    TagPickerOptionGroup: function() {
        return _reacttagpicker.TagPickerOptionGroup;
    },
    TeachingPopover: function() {
        return _reactteachingpopover.TeachingPopover;
    },
    TeachingPopoverBody: function() {
        return _reactteachingpopover.TeachingPopoverBody;
    },
    TeachingPopoverCarousel: function() {
        return _reactteachingpopover.TeachingPopoverCarousel;
    },
    TeachingPopoverCarouselCard: function() {
        return _reactteachingpopover.TeachingPopoverCarouselCard;
    },
    TeachingPopoverCarouselFooter: function() {
        return _reactteachingpopover.TeachingPopoverCarouselFooter;
    },
    TeachingPopoverCarouselNav: function() {
        return _reactteachingpopover.TeachingPopoverCarouselNav;
    },
    TeachingPopoverCarouselNavButton: function() {
        return _reactteachingpopover.TeachingPopoverCarouselNavButton;
    },
    TeachingPopoverCarouselPageCount: function() {
        return _reactteachingpopover.TeachingPopoverCarouselPageCount;
    },
    TeachingPopoverFooter: function() {
        return _reactteachingpopover.TeachingPopoverFooter;
    },
    TeachingPopoverHeader: function() {
        return _reactteachingpopover.TeachingPopoverHeader;
    },
    TeachingPopoverSurface: function() {
        return _reactteachingpopover.TeachingPopoverSurface;
    },
    TeachingPopoverTitle: function() {
        return _reactteachingpopover.TeachingPopoverTitle;
    },
    TeachingPopoverTrigger: function() {
        return _reactteachingpopover.TeachingPopoverTrigger;
    },
    Text: function() {
        return _reacttext.Text;
    },
    Textarea: function() {
        return _reacttextarea.Textarea;
    },
    Title1: function() {
        return _reacttext.Title1;
    },
    Title2: function() {
        return _reacttext.Title2;
    },
    Title3: function() {
        return _reacttext.Title3;
    },
    Toast: function() {
        return _reacttoast.Toast;
    },
    ToastBody: function() {
        return _reacttoast.ToastBody;
    },
    ToastFooter: function() {
        return _reacttoast.ToastFooter;
    },
    ToastTitle: function() {
        return _reacttoast.ToastTitle;
    },
    ToastTrigger: function() {
        return _reacttoast.ToastTrigger;
    },
    Toaster: function() {
        return _reacttoast.Toaster;
    },
    ToggleButton: function() {
        return _reactbutton.ToggleButton;
    },
    Toolbar: function() {
        return _reacttoolbar.Toolbar;
    },
    ToolbarButton: function() {
        return _reacttoolbar.ToolbarButton;
    },
    ToolbarDivider: function() {
        return _reacttoolbar.ToolbarDivider;
    },
    ToolbarGroup: function() {
        return _reacttoolbar.ToolbarGroup;
    },
    ToolbarRadioButton: function() {
        return _reacttoolbar.ToolbarRadioButton;
    },
    ToolbarRadioGroup: function() {
        return _reacttoolbar.ToolbarRadioGroup;
    },
    ToolbarToggleButton: function() {
        return _reacttoolbar.ToolbarToggleButton;
    },
    Tooltip: function() {
        return _reacttooltip.Tooltip;
    },
    Tree: function() {
        return _reacttree.Tree;
    },
    TreeItem: function() {
        return _reacttree.TreeItem;
    },
    TreeItemLayout: function() {
        return _reacttree.TreeItemLayout;
    },
    TreeItemPersonaLayout: function() {
        return _reacttree.TreeItemPersonaLayout;
    },
    TreeItemProvider: function() {
        return _reacttree.TreeItemProvider;
    },
    TreeProvider: function() {
        return _reacttree.TreeProvider;
    },
    TreeRootReset: function() {
        return _reacttree.TreeRootReset;
    },
    __css: function() {
        return _react.__css;
    },
    __resetCSS: function() {
        return _react.__resetCSS;
    },
    __resetStyles: function() {
        return _react.__resetStyles;
    },
    __styles: function() {
        return _react.__styles;
    },
    accordionClassNames: function() {
        return _reactaccordion.accordionClassNames;
    },
    accordionHeaderClassNames: function() {
        return _reactaccordion.accordionHeaderClassNames;
    },
    accordionItemClassNames: function() {
        return _reactaccordion.accordionItemClassNames;
    },
    accordionPanelClassNames: function() {
        return _reactaccordion.accordionPanelClassNames;
    },
    alphaSliderClassNames: function() {
        return _reactcolorpicker.alphaSliderClassNames;
    },
    appItemClassNames: function() {
        return _reactnav.appItemClassNames;
    },
    appItemStaticClassNames: function() {
        return _reactnav.appItemStaticClassNames;
    },
    arrowHeights: function() {
        return _reactpopover.arrowHeights;
    },
    assertSlots: function() {
        return _reactutilities.assertSlots;
    },
    avatarClassNames: function() {
        return _reactavatar.avatarClassNames;
    },
    avatarGroupClassNames: function() {
        return _reactavatar.avatarGroupClassNames;
    },
    avatarGroupItemClassNames: function() {
        return _reactavatar.avatarGroupItemClassNames;
    },
    avatarGroupPopoverClassNames: function() {
        return _reactavatar.avatarGroupPopoverClassNames;
    },
    badgeClassNames: function() {
        return _reactbadge.badgeClassNames;
    },
    body1ClassNames: function() {
        return _reacttext.body1ClassNames;
    },
    body1StrongClassNames: function() {
        return _reacttext.body1StrongClassNames;
    },
    body1StrongerClassNames: function() {
        return _reacttext.body1StrongerClassNames;
    },
    body2ClassNames: function() {
        return _reacttext.body2ClassNames;
    },
    breadcrumbButtonClassNames: function() {
        return _reactbreadcrumb.breadcrumbButtonClassNames;
    },
    breadcrumbClassNames: function() {
        return _reactbreadcrumb.breadcrumbClassNames;
    },
    breadcrumbDividerClassNames: function() {
        return _reactbreadcrumb.breadcrumbDividerClassNames;
    },
    breadcrumbItemClassNames: function() {
        return _reactbreadcrumb.breadcrumbItemClassNames;
    },
    buttonClassNames: function() {
        return _reactbutton.buttonClassNames;
    },
    caption1ClassNames: function() {
        return _reacttext.caption1ClassNames;
    },
    caption1StrongClassNames: function() {
        return _reacttext.caption1StrongClassNames;
    },
    caption1StrongerClassNames: function() {
        return _reacttext.caption1StrongerClassNames;
    },
    caption2ClassNames: function() {
        return _reacttext.caption2ClassNames;
    },
    caption2StrongClassNames: function() {
        return _reacttext.caption2StrongClassNames;
    },
    cardCSSVars: function() {
        return _reactcard.cardCSSVars;
    },
    cardClassNames: function() {
        return _reactcard.cardClassNames;
    },
    cardFooterClassNames: function() {
        return _reactcard.cardFooterClassNames;
    },
    cardHeaderCSSVars: function() {
        return _reactcard.cardHeaderCSSVars;
    },
    cardHeaderClassNames: function() {
        return _reactcard.cardHeaderClassNames;
    },
    cardPreviewClassNames: function() {
        return _reactcard.cardPreviewClassNames;
    },
    carouselAutoplayButtonClassNames: function() {
        return _reactcarousel.carouselAutoplayButtonClassNames;
    },
    carouselButtonClassNames: function() {
        return _reactcarousel.carouselButtonClassNames;
    },
    carouselCardClassNames: function() {
        return _reactcarousel.carouselCardClassNames;
    },
    carouselClassNames: function() {
        return _reactcarousel.carouselClassNames;
    },
    carouselContextDefaultValue: function() {
        return _reactcarousel.carouselContextDefaultValue;
    },
    carouselNavButtonClassNames: function() {
        return _reactcarousel.carouselNavButtonClassNames;
    },
    carouselNavClassNames: function() {
        return _reactcarousel.carouselNavClassNames;
    },
    carouselNavContainerClassNames: function() {
        return _reactcarousel.carouselNavContainerClassNames;
    },
    carouselNavImageButtonClassNames: function() {
        return _reactcarousel.carouselNavImageButtonClassNames;
    },
    carouselSliderClassNames: function() {
        return _reactcarousel.carouselSliderClassNames;
    },
    carouselViewportClassNames: function() {
        return _reactcarousel.carouselViewportClassNames;
    },
    checkboxClassNames: function() {
        return _reactcheckbox.checkboxClassNames;
    },
    colorAreaClassNames: function() {
        return _reactcolorpicker.colorAreaClassNames;
    },
    colorPickerClassNames: function() {
        return _reactcolorpicker.colorPickerClassNames;
    },
    colorSliderClassNames: function() {
        return _reactcolorpicker.colorSliderClassNames;
    },
    colorSwatchClassNames: function() {
        return _reactswatchpicker.colorSwatchClassNames;
    },
    comboboxClassNames: function() {
        return _reactcombobox.comboboxClassNames;
    },
    compoundButtonClassNames: function() {
        return _reactbutton.compoundButtonClassNames;
    },
    counterBadgeClassNames: function() {
        return _reactbadge.counterBadgeClassNames;
    },
    createCSSRuleFromTheme: function() {
        return _reactprovider.createCSSRuleFromTheme;
    },
    createCustomFocusIndicatorStyle: function() {
        return _reacttabster.createCustomFocusIndicatorStyle;
    },
    createDOMRenderer: function() {
        return _react.createDOMRenderer;
    },
    createDarkTheme: function() {
        return _reacttheme.createDarkTheme;
    },
    createFocusOutlineStyle: function() {
        return _reacttabster.createFocusOutlineStyle;
    },
    createHighContrastTheme: function() {
        return _reacttheme.createHighContrastTheme;
    },
    createLightTheme: function() {
        return _reacttheme.createLightTheme;
    },
    createMotionComponent: function() {
        return _reactmotion.createMotionComponent;
    },
    createMotionComponentVariant: function() {
        return _reactmotion.createMotionComponentVariant;
    },
    createPresenceComponent: function() {
        return _reactmotion.createPresenceComponent;
    },
    createPresenceComponentVariant: function() {
        return _reactmotion.createPresenceComponentVariant;
    },
    createTableColumn: function() {
        return _reacttable.createTableColumn;
    },
    createTeamsDarkTheme: function() {
        return _reacttheme.createTeamsDarkTheme;
    },
    dataGridBodyClassNames: function() {
        return _reacttable.dataGridBodyClassNames;
    },
    dataGridCellClassNames: function() {
        return _reacttable.dataGridCellClassNames;
    },
    dataGridClassNames: function() {
        return _reacttable.dataGridClassNames;
    },
    dataGridHeaderCellClassNames: function() {
        return _reacttable.dataGridHeaderCellClassNames;
    },
    dataGridHeaderClassNames: function() {
        return _reacttable.dataGridHeaderClassNames;
    },
    dataGridRowClassNames: function() {
        return _reacttable.dataGridRowClassNames;
    },
    dataGridSelectionCellClassNames: function() {
        return _reacttable.dataGridSelectionCellClassNames;
    },
    dialogActionsClassNames: function() {
        return _reactdialog.dialogActionsClassNames;
    },
    dialogBodyClassNames: function() {
        return _reactdialog.dialogBodyClassNames;
    },
    dialogContentClassNames: function() {
        return _reactdialog.dialogContentClassNames;
    },
    dialogSurfaceClassNames: function() {
        return _reactdialog.dialogSurfaceClassNames;
    },
    dialogTitleClassNames: function() {
        return _reactdialog.dialogTitleClassNames;
    },
    displayClassNames: function() {
        return _reacttext.displayClassNames;
    },
    dividerClassNames: function() {
        return _reactdivider.dividerClassNames;
    },
    drawerBodyClassNames: function() {
        return _reactdrawer.drawerBodyClassNames;
    },
    drawerFooterClassNames: function() {
        return _reactdrawer.drawerFooterClassNames;
    },
    drawerHeaderClassNames: function() {
        return _reactdrawer.drawerHeaderClassNames;
    },
    drawerHeaderNavigationClassNames: function() {
        return _reactdrawer.drawerHeaderNavigationClassNames;
    },
    drawerHeaderTitleClassNames: function() {
        return _reactdrawer.drawerHeaderTitleClassNames;
    },
    dropdownClassNames: function() {
        return _reactcombobox.dropdownClassNames;
    },
    emptySwatchClassNames: function() {
        return _reactswatchpicker.emptySwatchClassNames;
    },
    fieldClassNames: function() {
        return _reactfield.fieldClassNames;
    },
    flatTreeClassNames: function() {
        return _reacttree.flatTreeClassNames;
    },
    flattenTree_unstable: function() {
        return _reacttree.flattenTree_unstable;
    },
    fluentProviderClassNames: function() {
        return _reactprovider.fluentProviderClassNames;
    },
    getIntrinsicElementProps: function() {
        return _reactutilities.getIntrinsicElementProps;
    },
    // getNativeElementProps is deprecated but removing it would be a breaking change
    // eslint-disable-next-line @typescript-eslint/no-deprecated
    getNativeElementProps: function() {
        return _reactutilities.getNativeElementProps;
    },
    getPartitionedNativeProps: function() {
        return _reactutilities.getPartitionedNativeProps;
    },
    getSlotClassNameProp_unstable: function() {
        return _reactutilities.getSlotClassNameProp_unstable;
    },
    // getSlots is deprecated but removing it would be a breaking change
    // eslint-disable-next-line @typescript-eslint/no-deprecated
    getSlots: function() {
        return _reactutilities.getSlots;
    },
    hamburgerClassNames: function() {
        return _reactnav.hamburgerClassNames;
    },
    imageClassNames: function() {
        return _reactimage.imageClassNames;
    },
    imageSwatchClassNames: function() {
        return _reactswatchpicker.imageSwatchClassNames;
    },
    infoButtonClassNames: function() {
        return _reactinfolabel.infoButtonClassNames;
    },
    infoLabelClassNames: function() {
        return _reactinfolabel.infoLabelClassNames;
    },
    inlineDrawerClassNames: function() {
        return _reactdrawer.inlineDrawerClassNames;
    },
    inputClassNames: function() {
        return _reactinput.inputClassNames;
    },
    interactionTagClassNames: function() {
        return _reacttags.interactionTagClassNames;
    },
    interactionTagPrimaryClassNames: function() {
        return _reacttags.interactionTagPrimaryClassNames;
    },
    interactionTagSecondaryClassNames: function() {
        return _reacttags.interactionTagSecondaryClassNames;
    },
    isHTMLElement: function() {
        return _reactutilities.isHTMLElement;
    },
    isTruncatableBreadcrumbContent: function() {
        return _reactbreadcrumb.isTruncatableBreadcrumbContent;
    },
    labelClassNames: function() {
        return _reactlabel.labelClassNames;
    },
    largeTitleClassNames: function() {
        return _reacttext.largeTitleClassNames;
    },
    linkClassNames: function() {
        return _reactlink.linkClassNames;
    },
    listClassNames: function() {
        return _reactlist.listClassNames;
    },
    listItemClassNames: function() {
        return _reactlist.listItemClassNames;
    },
    listboxClassNames: function() {
        return _reactcombobox.listboxClassNames;
    },
    makeResetStyles: function() {
        return _react.makeResetStyles;
    },
    makeStaticStyles: function() {
        return _react.makeStaticStyles;
    },
    makeStyles: function() {
        return _react.makeStyles;
    },
    menuButtonClassNames: function() {
        return _reactbutton.menuButtonClassNames;
    },
    menuDividerClassNames: function() {
        return _reactmenu.menuDividerClassNames;
    },
    menuGroupClassNames: function() {
        return _reactmenu.menuGroupClassNames;
    },
    menuGroupHeaderClassNames: function() {
        return _reactmenu.menuGroupHeaderClassNames;
    },
    menuItemCheckboxClassNames: function() {
        return _reactmenu.menuItemCheckboxClassNames;
    },
    menuItemClassNames: function() {
        return _reactmenu.menuItemClassNames;
    },
    menuItemLinkClassNames: function() {
        return _reactmenu.menuItemLinkClassNames;
    },
    menuItemRadioClassNames: function() {
        return _reactmenu.menuItemRadioClassNames;
    },
    menuItemSwitchClassNames: function() {
        return _reactmenu.menuItemSwitchClassNames;
    },
    menuListClassNames: function() {
        return _reactmenu.menuListClassNames;
    },
    menuPopoverClassNames: function() {
        return _reactmenu.menuPopoverClassNames;
    },
    menuSplitGroupClassNames: function() {
        return _reactmenu.menuSplitGroupClassNames;
    },
    mergeCallbacks: function() {
        return _reactutilities.mergeCallbacks;
    },
    mergeClasses: function() {
        return _react.mergeClasses;
    },
    messageBarActionsClassNames: function() {
        return _reactmessagebar.messageBarActionsClassNames;
    },
    messageBarBodyClassNames: function() {
        return _reactmessagebar.messageBarBodyClassNames;
    },
    messageBarClassNames: function() {
        return _reactmessagebar.messageBarClassNames;
    },
    messageBarGroupClassNames: function() {
        return _reactmessagebar.messageBarGroupClassNames;
    },
    messageBarTitleClassNames: function() {
        return _reactmessagebar.messageBarTitleClassNames;
    },
    motionTokens: function() {
        return _reactmotion.motionTokens;
    },
    navCategoryItemClassNames: function() {
        return _reactnav.navCategoryItemClassNames;
    },
    navClassNames: function() {
        return _reactnav.navClassNames;
    },
    navDividerClassNames: function() {
        return _reactnav.navDividerClassNames;
    },
    navDrawerBodyClassNames: function() {
        return _reactnav.navDrawerBodyClassNames;
    },
    navDrawerClassNames: function() {
        return _reactnav.navDrawerClassNames;
    },
    navDrawerFooterClassNames: function() {
        return _reactnav.navDrawerFooterClassNames;
    },
    navDrawerHeaderClassNames: function() {
        return _reactnav.navDrawerHeaderClassNames;
    },
    navItemClassNames: function() {
        return _reactnav.navItemClassNames;
    },
    navSectionHeaderClassNames: function() {
        return _reactnav.navSectionHeaderClassNames;
    },
    navSubItemClassNames: function() {
        return _reactnav.navSubItemClassNames;
    },
    navSubItemGroupClassNames: function() {
        return _reactnav.navSubItemGroupClassNames;
    },
    optionClassNames: function() {
        return _reactcombobox.optionClassNames;
    },
    optionGroupClassNames: function() {
        return _reactcombobox.optionGroupClassNames;
    },
    overlayDrawerClassNames: function() {
        return _reactdrawer.overlayDrawerClassNames;
    },
    partitionAvatarGroupItems: function() {
        return _reactavatar.partitionAvatarGroupItems;
    },
    partitionBreadcrumbItems: function() {
        return _reactbreadcrumb.partitionBreadcrumbItems;
    },
    personaClassNames: function() {
        return _reactpersona.personaClassNames;
    },
    popoverSurfaceClassNames: function() {
        return _reactpopover.popoverSurfaceClassNames;
    },
    presenceAvailableFilled: function() {
        return _reactbadge.presenceAvailableFilled;
    },
    presenceAvailableRegular: function() {
        return _reactbadge.presenceAvailableRegular;
    },
    presenceAwayFilled: function() {
        return _reactbadge.presenceAwayFilled;
    },
    presenceAwayRegular: function() {
        return _reactbadge.presenceAwayRegular;
    },
    presenceBadgeClassNames: function() {
        return _reactbadge.presenceBadgeClassNames;
    },
    presenceBlockedRegular: function() {
        return _reactbadge.presenceBlockedRegular;
    },
    presenceBusyFilled: function() {
        return _reactbadge.presenceBusyFilled;
    },
    presenceDndFilled: function() {
        return _reactbadge.presenceDndFilled;
    },
    presenceDndRegular: function() {
        return _reactbadge.presenceDndRegular;
    },
    presenceOfflineRegular: function() {
        return _reactbadge.presenceOfflineRegular;
    },
    presenceOofRegular: function() {
        return _reactbadge.presenceOofRegular;
    },
    presenceUnknownRegular: function() {
        return _reactbadge.presenceUnknownRegular;
    },
    progressBarClassNames: function() {
        return _reactprogress.progressBarClassNames;
    },
    radioClassNames: function() {
        return _reactradio.radioClassNames;
    },
    radioGroupClassNames: function() {
        return _reactradio.radioGroupClassNames;
    },
    ratingClassNames: function() {
        return _reactrating.ratingClassNames;
    },
    ratingDisplayClassNames: function() {
        return _reactrating.ratingDisplayClassNames;
    },
    ratingItemClassNames: function() {
        return _reactrating.ratingItemClassNames;
    },
    renderAccordionHeader_unstable: function() {
        return _reactaccordion.renderAccordionHeader_unstable;
    },
    renderAccordionItem_unstable: function() {
        return _reactaccordion.renderAccordionItem_unstable;
    },
    renderAccordionPanel_unstable: function() {
        return _reactaccordion.renderAccordionPanel_unstable;
    },
    renderAccordion_unstable: function() {
        return _reactaccordion.renderAccordion_unstable;
    },
    renderAlphaSlider_unstable: function() {
        return _reactcolorpicker.renderAlphaSlider_unstable;
    },
    renderAppItemStatic_unstable: function() {
        return _reactnav.renderAppItemStatic_unstable;
    },
    renderAppItem_unstable: function() {
        return _reactnav.renderAppItem_unstable;
    },
    renderAriaLiveAnnouncer_unstable: function() {
        return _reactaria.renderAriaLiveAnnouncer_unstable;
    },
    renderAvatarGroupItem_unstable: function() {
        return _reactavatar.renderAvatarGroupItem_unstable;
    },
    renderAvatarGroupPopover_unstable: function() {
        return _reactavatar.renderAvatarGroupPopover_unstable;
    },
    renderAvatarGroup_unstable: function() {
        return _reactavatar.renderAvatarGroup_unstable;
    },
    renderAvatar_unstable: function() {
        return _reactavatar.renderAvatar_unstable;
    },
    renderBadge_unstable: function() {
        return _reactbadge.renderBadge_unstable;
    },
    renderBreadcrumbButton_unstable: function() {
        return _reactbreadcrumb.renderBreadcrumbButton_unstable;
    },
    renderBreadcrumbDivider_unstable: function() {
        return _reactbreadcrumb.renderBreadcrumbDivider_unstable;
    },
    renderBreadcrumbItem_unstable: function() {
        return _reactbreadcrumb.renderBreadcrumbItem_unstable;
    },
    renderBreadcrumb_unstable: function() {
        return _reactbreadcrumb.renderBreadcrumb_unstable;
    },
    renderButton_unstable: function() {
        return _reactbutton.renderButton_unstable;
    },
    renderCardFooter_unstable: function() {
        return _reactcard.renderCardFooter_unstable;
    },
    renderCardHeader_unstable: function() {
        return _reactcard.renderCardHeader_unstable;
    },
    renderCardPreview_unstable: function() {
        return _reactcard.renderCardPreview_unstable;
    },
    renderCard_unstable: function() {
        return _reactcard.renderCard_unstable;
    },
    renderCarouselAutoplayButton_unstable: function() {
        return _reactcarousel.renderCarouselAutoplayButton_unstable;
    },
    renderCarouselButton_unstable: function() {
        return _reactcarousel.renderCarouselButton_unstable;
    },
    renderCarouselCard_unstable: function() {
        return _reactcarousel.renderCarouselCard_unstable;
    },
    renderCarouselNavButton_unstable: function() {
        return _reactcarousel.renderCarouselNavButton_unstable;
    },
    renderCarouselNavContainer_unstable: function() {
        return _reactcarousel.renderCarouselNavContainer_unstable;
    },
    renderCarouselNavImageButton_unstable: function() {
        return _reactcarousel.renderCarouselNavImageButton_unstable;
    },
    renderCarouselNav_unstable: function() {
        return _reactcarousel.renderCarouselNav_unstable;
    },
    renderCarouselSlider_unstable: function() {
        return _reactcarousel.renderCarouselSlider_unstable;
    },
    renderCarouselViewport_unstable: function() {
        return _reactcarousel.renderCarouselViewport_unstable;
    },
    renderCarousel_unstable: function() {
        return _reactcarousel.renderCarousel_unstable;
    },
    renderCheckbox_unstable: function() {
        return _reactcheckbox.renderCheckbox_unstable;
    },
    renderColorArea_unstable: function() {
        return _reactcolorpicker.renderColorArea_unstable;
    },
    renderColorPicker_unstable: function() {
        return _reactcolorpicker.renderColorPicker_unstable;
    },
    renderColorSlider_unstable: function() {
        return _reactcolorpicker.renderColorSlider_unstable;
    },
    renderColorSwatch_unstable: function() {
        return _reactswatchpicker.renderColorSwatch_unstable;
    },
    renderCombobox_unstable: function() {
        return _reactcombobox.renderCombobox_unstable;
    },
    renderCompoundButton_unstable: function() {
        return _reactbutton.renderCompoundButton_unstable;
    },
    renderDataGridBody_unstable: function() {
        return _reacttable.renderDataGridBody_unstable;
    },
    renderDataGridCell_unstable: function() {
        return _reacttable.renderDataGridCell_unstable;
    },
    renderDataGridHeaderCell_unstable: function() {
        return _reacttable.renderDataGridHeaderCell_unstable;
    },
    renderDataGridHeader_unstable: function() {
        return _reacttable.renderDataGridHeader_unstable;
    },
    renderDataGridRow_unstable: function() {
        return _reacttable.renderDataGridRow_unstable;
    },
    renderDataGridSelectionCell_unstable: function() {
        return _reacttable.renderDataGridSelectionCell_unstable;
    },
    renderDataGrid_unstable: function() {
        return _reacttable.renderDataGrid_unstable;
    },
    renderDialogActions_unstable: function() {
        return _reactdialog.renderDialogActions_unstable;
    },
    renderDialogBody_unstable: function() {
        return _reactdialog.renderDialogBody_unstable;
    },
    renderDialogContent_unstable: function() {
        return _reactdialog.renderDialogContent_unstable;
    },
    renderDialogSurface_unstable: function() {
        return _reactdialog.renderDialogSurface_unstable;
    },
    renderDialogTitle_unstable: function() {
        return _reactdialog.renderDialogTitle_unstable;
    },
    renderDialogTrigger_unstable: function() {
        return _reactdialog.renderDialogTrigger_unstable;
    },
    renderDialog_unstable: function() {
        return _reactdialog.renderDialog_unstable;
    },
    renderDivider_unstable: function() {
        return _reactdivider.renderDivider_unstable;
    },
    renderDrawerBody_unstable: function() {
        return _reactdrawer.renderDrawerBody_unstable;
    },
    renderDrawerFooter_unstable: function() {
        return _reactdrawer.renderDrawerFooter_unstable;
    },
    renderDrawerHeaderNavigation_unstable: function() {
        return _reactdrawer.renderDrawerHeaderNavigation_unstable;
    },
    renderDrawerHeaderTitle_unstable: function() {
        return _reactdrawer.renderDrawerHeaderTitle_unstable;
    },
    renderDrawerHeader_unstable: function() {
        return _reactdrawer.renderDrawerHeader_unstable;
    },
    renderDrawer_unstable: function() {
        return _reactdrawer.renderDrawer_unstable;
    },
    renderDropdown_unstable: function() {
        return _reactcombobox.renderDropdown_unstable;
    },
    renderEmptySwatch_unstable: function() {
        return _reactswatchpicker.renderEmptySwatch_unstable;
    },
    renderField_unstable: function() {
        return _reactfield.renderField_unstable;
    },
    renderFlatTree_unstable: function() {
        return _reacttree.renderFlatTree_unstable;
    },
    renderFluentProvider_unstable: function() {
        return _reactprovider.renderFluentProvider_unstable;
    },
    renderImageSwatch_unstable: function() {
        return _reactswatchpicker.renderImageSwatch_unstable;
    },
    renderImage_unstable: function() {
        return _reactimage.renderImage_unstable;
    },
    renderInfoButton_unstable: function() {
        return _reactinfolabel.renderInfoButton_unstable;
    },
    renderInfoLabel_unstable: function() {
        return _reactinfolabel.renderInfoLabel_unstable;
    },
    renderInlineDrawer_unstable: function() {
        return _reactdrawer.renderInlineDrawer_unstable;
    },
    renderInput_unstable: function() {
        return _reactinput.renderInput_unstable;
    },
    renderInteractionTagPrimary_unstable: function() {
        return _reacttags.renderInteractionTagPrimary_unstable;
    },
    renderInteractionTagSecondary_unstable: function() {
        return _reacttags.renderInteractionTagSecondary_unstable;
    },
    renderInteractionTag_unstable: function() {
        return _reacttags.renderInteractionTag_unstable;
    },
    renderLabel_unstable: function() {
        return _reactlabel.renderLabel_unstable;
    },
    renderLink_unstable: function() {
        return _reactlink.renderLink_unstable;
    },
    renderListItem_unstable: function() {
        return _reactlist.renderListItem_unstable;
    },
    renderList_unstable: function() {
        return _reactlist.renderList_unstable;
    },
    renderListbox_unstable: function() {
        return _reactcombobox.renderListbox_unstable;
    },
    renderMenuButton_unstable: function() {
        return _reactbutton.renderMenuButton_unstable;
    },
    renderMenuDivider_unstable: function() {
        return _reactmenu.renderMenuDivider_unstable;
    },
    renderMenuGroupHeader_unstable: function() {
        return _reactmenu.renderMenuGroupHeader_unstable;
    },
    renderMenuGroup_unstable: function() {
        return _reactmenu.renderMenuGroup_unstable;
    },
    renderMenuItemCheckbox_unstable: function() {
        return _reactmenu.renderMenuItemCheckbox_unstable;
    },
    renderMenuItemLink_unstable: function() {
        return _reactmenu.renderMenuItemLink_unstable;
    },
    renderMenuItemRadio_unstable: function() {
        return _reactmenu.renderMenuItemRadio_unstable;
    },
    renderMenuItemSwitch_unstable: function() {
        return _reactmenu.renderMenuItemSwitch_unstable;
    },
    renderMenuItem_unstable: function() {
        return _reactmenu.renderMenuItem_unstable;
    },
    renderMenuList_unstable: function() {
        return _reactmenu.renderMenuList_unstable;
    },
    renderMenuPopover_unstable: function() {
        return _reactmenu.renderMenuPopover_unstable;
    },
    renderMenuSplitGroup_unstable: function() {
        return _reactmenu.renderMenuSplitGroup_unstable;
    },
    renderMenuTrigger_unstable: function() {
        return _reactmenu.renderMenuTrigger_unstable;
    },
    renderMenu_unstable: function() {
        return _reactmenu.renderMenu_unstable;
    },
    renderMessageBarActions_unstable: function() {
        return _reactmessagebar.renderMessageBarActions_unstable;
    },
    renderMessageBarBody_unstable: function() {
        return _reactmessagebar.renderMessageBarBody_unstable;
    },
    renderMessageBarGroup_unstable: function() {
        return _reactmessagebar.renderMessageBarGroup_unstable;
    },
    renderMessageBarTitle_unstable: function() {
        return _reactmessagebar.renderMessageBarTitle_unstable;
    },
    renderMessageBar_unstable: function() {
        return _reactmessagebar.renderMessageBar_unstable;
    },
    renderNavCategoryItem_unstable: function() {
        return _reactnav.renderNavCategoryItem_unstable;
    },
    renderNavCategory_unstable: function() {
        return _reactnav.renderNavCategory_unstable;
    },
    renderNavDrawer_unstable: function() {
        return _reactnav.renderNavDrawer_unstable;
    },
    renderNavItem_unstable: function() {
        return _reactnav.renderNavItem_unstable;
    },
    renderNavSectionHeader_unstable: function() {
        return _reactnav.renderNavSectionHeader_unstable;
    },
    renderNavSubItemGroup_unstable: function() {
        return _reactnav.renderNavSubItemGroup_unstable;
    },
    renderNavSubItem_unstable: function() {
        return _reactnav.renderNavSubItem_unstable;
    },
    renderNav_unstable: function() {
        return _reactnav.renderNav_unstable;
    },
    renderOptionGroup_unstable: function() {
        return _reactcombobox.renderOptionGroup_unstable;
    },
    renderOption_unstable: function() {
        return _reactcombobox.renderOption_unstable;
    },
    renderOverlayDrawer_unstable: function() {
        return _reactdrawer.renderOverlayDrawer_unstable;
    },
    renderPersona_unstable: function() {
        return _reactpersona.renderPersona_unstable;
    },
    renderPopoverSurface_unstable: function() {
        return _reactpopover.renderPopoverSurface_unstable;
    },
    renderPopoverTrigger_unstable: function() {
        return _reactpopover.renderPopoverTrigger_unstable;
    },
    renderPopover_unstable: function() {
        return _reactpopover.renderPopover_unstable;
    },
    renderPortal_unstable: function() {
        return _reactportal.renderPortal_unstable;
    },
    renderProgressBar_unstable: function() {
        return _reactprogress.renderProgressBar_unstable;
    },
    renderRadioGroup_unstable: function() {
        return _reactradio.renderRadioGroup_unstable;
    },
    renderRadio_unstable: function() {
        return _reactradio.renderRadio_unstable;
    },
    renderRatingDisplay_unstable: function() {
        return _reactrating.renderRatingDisplay_unstable;
    },
    renderRatingItem_unstable: function() {
        return _reactrating.renderRatingItem_unstable;
    },
    renderRating_unstable: function() {
        return _reactrating.renderRating_unstable;
    },
    renderSearchBox_unstable: function() {
        return _reactsearch.renderSearchBox_unstable;
    },
    renderSelect_unstable: function() {
        return _reactselect.renderSelect_unstable;
    },
    renderSkeletonItem_unstable: function() {
        return _reactskeleton.renderSkeletonItem_unstable;
    },
    renderSkeleton_unstable: function() {
        return _reactskeleton.renderSkeleton_unstable;
    },
    renderSlider_unstable: function() {
        return _reactslider.renderSlider_unstable;
    },
    renderSpinButton_unstable: function() {
        return _reactspinbutton.renderSpinButton_unstable;
    },
    renderSpinner_unstable: function() {
        return _reactspinner.renderSpinner_unstable;
    },
    renderSplitButton_unstable: function() {
        return _reactbutton.renderSplitButton_unstable;
    },
    renderSplitNavItem_unstable: function() {
        return _reactnav.renderSplitNavItem_unstable;
    },
    renderSwatchPickerGrid: function() {
        return _reactswatchpicker.renderSwatchPickerGrid;
    },
    renderSwatchPickerRow_unstable: function() {
        return _reactswatchpicker.renderSwatchPickerRow_unstable;
    },
    renderSwatchPicker_unstable: function() {
        return _reactswatchpicker.renderSwatchPicker_unstable;
    },
    renderSwitch_unstable: function() {
        return _reactswitch.renderSwitch_unstable;
    },
    renderTabList_unstable: function() {
        return _reacttabs.renderTabList_unstable;
    },
    renderTab_unstable: function() {
        return _reacttabs.renderTab_unstable;
    },
    renderTableBody_unstable: function() {
        return _reacttable.renderTableBody_unstable;
    },
    renderTableCellActions_unstable: function() {
        return _reacttable.renderTableCellActions_unstable;
    },
    renderTableCellLayout_unstable: function() {
        return _reacttable.renderTableCellLayout_unstable;
    },
    renderTableCell_unstable: function() {
        return _reacttable.renderTableCell_unstable;
    },
    renderTableHeaderCell_unstable: function() {
        return _reacttable.renderTableHeaderCell_unstable;
    },
    renderTableHeader_unstable: function() {
        return _reacttable.renderTableHeader_unstable;
    },
    renderTableResizeHandle_unstable: function() {
        return _reacttable.renderTableResizeHandle_unstable;
    },
    renderTableRow_unstable: function() {
        return _reacttable.renderTableRow_unstable;
    },
    renderTableSelectionCell_unstable: function() {
        return _reacttable.renderTableSelectionCell_unstable;
    },
    renderTable_unstable: function() {
        return _reacttable.renderTable_unstable;
    },
    renderTagGroup_unstable: function() {
        return _reacttags.renderTagGroup_unstable;
    },
    renderTagPickerButton_unstable: function() {
        return _reacttagpicker.renderTagPickerButton_unstable;
    },
    renderTagPickerControl_unstable: function() {
        return _reacttagpicker.renderTagPickerControl_unstable;
    },
    renderTagPickerGroup_unstable: function() {
        return _reacttagpicker.renderTagPickerGroup_unstable;
    },
    renderTagPickerInput_unstable: function() {
        return _reacttagpicker.renderTagPickerInput_unstable;
    },
    renderTagPickerList_unstable: function() {
        return _reacttagpicker.renderTagPickerList_unstable;
    },
    renderTagPickerOptionGroup: function() {
        return _reacttagpicker.renderTagPickerOptionGroup;
    },
    renderTagPickerOption_unstable: function() {
        return _reacttagpicker.renderTagPickerOption_unstable;
    },
    renderTagPicker_unstable: function() {
        return _reacttagpicker.renderTagPicker_unstable;
    },
    renderTag_unstable: function() {
        return _reacttags.renderTag_unstable;
    },
    renderTeachingPopoverBody_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverBody_unstable;
    },
    renderTeachingPopoverCarouselCard_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverCarouselCard_unstable;
    },
    renderTeachingPopoverCarouselFooter_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverCarouselFooter_unstable;
    },
    renderTeachingPopoverCarouselNavButton_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverCarouselNavButton_unstable;
    },
    renderTeachingPopoverCarouselNav_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverCarouselNav_unstable;
    },
    renderTeachingPopoverCarouselPageCount_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverCarouselPageCount_unstable;
    },
    renderTeachingPopoverCarousel_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverCarousel_unstable;
    },
    renderTeachingPopoverFooter_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverFooter_unstable;
    },
    renderTeachingPopoverHeader_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverHeader_unstable;
    },
    renderTeachingPopoverSurface_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverSurface_unstable;
    },
    renderTeachingPopoverTitle_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverTitle_unstable;
    },
    renderTeachingPopoverTrigger_unstable: function() {
        return _reactteachingpopover.renderTeachingPopoverTrigger_unstable;
    },
    renderTeachingPopover_unstable: function() {
        return _reactteachingpopover.renderTeachingPopover_unstable;
    },
    renderText_unstable: function() {
        return _reacttext.renderText_unstable;
    },
    renderTextarea_unstable: function() {
        return _reacttextarea.renderTextarea_unstable;
    },
    renderToStyleElements: function() {
        return _react.renderToStyleElements;
    },
    renderToastBody_unstable: function() {
        return _reacttoast.renderToastBody_unstable;
    },
    renderToastFooter_unstable: function() {
        return _reacttoast.renderToastFooter_unstable;
    },
    renderToastTitle_unstable: function() {
        return _reacttoast.renderToastTitle_unstable;
    },
    renderToastTrigger_unstable: function() {
        return _reacttoast.renderToastTrigger_unstable;
    },
    renderToast_unstable: function() {
        return _reacttoast.renderToast_unstable;
    },
    renderToaster_unstable: function() {
        return _reacttoast.renderToaster_unstable;
    },
    renderToggleButton_unstable: function() {
        return _reactbutton.renderToggleButton_unstable;
    },
    renderToolbarGroup_unstable: function() {
        return _reacttoolbar.renderToolbarGroup_unstable;
    },
    renderToolbar_unstable: function() {
        return _reacttoolbar.renderToolbar_unstable;
    },
    renderTooltip_unstable: function() {
        return _reacttooltip.renderTooltip_unstable;
    },
    renderTreeItemLayout_unstable: function() {
        return _reacttree.renderTreeItemLayout_unstable;
    },
    renderTreeItemPersonaLayout_unstable: function() {
        return _reacttree.renderTreeItemPersonaLayout_unstable;
    },
    renderTreeItem_unstable: function() {
        return _reacttree.renderTreeItem_unstable;
    },
    renderTree_unstable: function() {
        return _reacttree.renderTree_unstable;
    },
    resetIdsForTests: function() {
        return _reactutilities.resetIdsForTests;
    },
    resolvePositioningShorthand: function() {
        return _reactpositioning.resolvePositioningShorthand;
    },
    // resolveShorthand is deprecated but removing it would be a breaking change
    // eslint-disable-next-line @typescript-eslint/no-deprecated
    resolveShorthand: function() {
        return _reactutilities.resolveShorthand;
    },
    searchBoxClassNames: function() {
        return _reactsearch.searchBoxClassNames;
    },
    selectClassNames: function() {
        return _reactselect.selectClassNames;
    },
    shorthands: function() {
        return _react.shorthands;
    },
    skeletonClassNames: function() {
        return _reactskeleton.skeletonClassNames;
    },
    skeletonItemClassNames: function() {
        return _reactskeleton.skeletonItemClassNames;
    },
    sliderCSSVars: function() {
        return _reactslider.sliderCSSVars;
    },
    sliderClassNames: function() {
        return _reactslider.sliderClassNames;
    },
    slot: function() {
        return _reactutilities.slot;
    },
    spinButtonClassNames: function() {
        return _reactspinbutton.spinButtonClassNames;
    },
    spinnerClassNames: function() {
        return _reactspinner.spinnerClassNames;
    },
    splitButtonClassNames: function() {
        return _reactbutton.splitButtonClassNames;
    },
    splitNavItemClassNames: function() {
        return _reactnav.splitNavItemClassNames;
    },
    subtitle1ClassNames: function() {
        return _reacttext.subtitle1ClassNames;
    },
    subtitle2ClassNames: function() {
        return _reacttext.subtitle2ClassNames;
    },
    subtitle2StrongerClassNames: function() {
        return _reacttext.subtitle2StrongerClassNames;
    },
    swatchCSSVars: function() {
        return _reactswatchpicker.swatchCSSVars;
    },
    swatchPickerClassNames: function() {
        return _reactswatchpicker.swatchPickerClassNames;
    },
    swatchPickerContextDefaultValue: function() {
        return _reactswatchpicker.swatchPickerContextDefaultValue;
    },
    swatchPickerRowClassNames: function() {
        return _reactswatchpicker.swatchPickerRowClassNames;
    },
    switchClassNames: function() {
        return _reactswitch.switchClassNames;
    },
    tabClassNames: function() {
        return _reacttabs.tabClassNames;
    },
    tabListClassNames: function() {
        return _reacttabs.tabListClassNames;
    },
    tableBodyClassName: function() {
        return _reacttable.tableBodyClassName;
    },
    tableBodyClassNames: function() {
        return _reacttable.tableBodyClassNames;
    },
    tableCellActionsClassNames: function() {
        return _reacttable.tableCellActionsClassNames;
    },
    tableCellClassName: function() {
        return _reacttable.tableCellClassName;
    },
    tableCellClassNames: function() {
        return _reacttable.tableCellClassNames;
    },
    tableCellLayoutClassNames: function() {
        return _reacttable.tableCellLayoutClassNames;
    },
    tableClassName: function() {
        return _reacttable.tableClassName;
    },
    tableClassNames: function() {
        return _reacttable.tableClassNames;
    },
    tableHeaderCellClassName: function() {
        return _reacttable.tableHeaderCellClassName;
    },
    tableHeaderCellClassNames: function() {
        return _reacttable.tableHeaderCellClassNames;
    },
    tableHeaderClassName: function() {
        return _reacttable.tableHeaderClassName;
    },
    tableHeaderClassNames: function() {
        return _reacttable.tableHeaderClassNames;
    },
    tableResizeHandleClassNames: function() {
        return _reacttable.tableResizeHandleClassNames;
    },
    tableRowClassName: function() {
        return _reacttable.tableRowClassName;
    },
    tableRowClassNames: function() {
        return _reacttable.tableRowClassNames;
    },
    tableSelectionCellClassNames: function() {
        return _reacttable.tableSelectionCellClassNames;
    },
    tagClassNames: function() {
        return _reacttags.tagClassNames;
    },
    tagGroupClassNames: function() {
        return _reacttags.tagGroupClassNames;
    },
    tagPickerButtonClassNames: function() {
        return _reacttagpicker.tagPickerButtonClassNames;
    },
    tagPickerControlClassNames: function() {
        return _reacttagpicker.tagPickerControlClassNames;
    },
    tagPickerGroupClassNames: function() {
        return _reacttagpicker.tagPickerGroupClassNames;
    },
    tagPickerInputClassNames: function() {
        return _reacttagpicker.tagPickerInputClassNames;
    },
    tagPickerListClassNames: function() {
        return _reacttagpicker.tagPickerListClassNames;
    },
    tagPickerOptionClassNames: function() {
        return _reacttagpicker.tagPickerOptionClassNames;
    },
    tagPickerOptionGroupClassNames: function() {
        return _reacttagpicker.tagPickerOptionGroupClassNames;
    },
    teachingPopoverBodyClassNames: function() {
        return _reactteachingpopover.teachingPopoverBodyClassNames;
    },
    teachingPopoverCarouselCardClassNames: function() {
        return _reactteachingpopover.teachingPopoverCarouselCardClassNames;
    },
    teachingPopoverCarouselClassNames: function() {
        return _reactteachingpopover.teachingPopoverCarouselClassNames;
    },
    teachingPopoverCarouselFooterClassNames: function() {
        return _reactteachingpopover.teachingPopoverCarouselFooterClassNames;
    },
    teachingPopoverCarouselNavButtonClassNames: function() {
        return _reactteachingpopover.teachingPopoverCarouselNavButtonClassNames;
    },
    teachingPopoverCarouselNavClassNames: function() {
        return _reactteachingpopover.teachingPopoverCarouselNavClassNames;
    },
    teachingPopoverCarouselPageCountClassNames: function() {
        return _reactteachingpopover.teachingPopoverCarouselPageCountClassNames;
    },
    teachingPopoverFooterClassNames: function() {
        return _reactteachingpopover.teachingPopoverFooterClassNames;
    },
    teachingPopoverHeaderClassNames: function() {
        return _reactteachingpopover.teachingPopoverHeaderClassNames;
    },
    teachingPopoverSurfaceClassNames: function() {
        return _reactteachingpopover.teachingPopoverSurfaceClassNames;
    },
    teachingPopoverTitleClassNames: function() {
        return _reactteachingpopover.teachingPopoverTitleClassNames;
    },
    teamsDarkTheme: function() {
        return _reacttheme.teamsDarkTheme;
    },
    teamsDarkV21Theme: function() {
        return _reacttheme.teamsDarkV21Theme;
    },
    teamsHighContrastTheme: function() {
        return _reacttheme.teamsHighContrastTheme;
    },
    teamsLightTheme: function() {
        return _reacttheme.teamsLightTheme;
    },
    teamsLightV21Theme: function() {
        return _reacttheme.teamsLightV21Theme;
    },
    textClassNames: function() {
        return _reacttext.textClassNames;
    },
    textareaClassNames: function() {
        return _reacttextarea.textareaClassNames;
    },
    themeToTokensObject: function() {
        return _reacttheme.themeToTokensObject;
    },
    title1ClassNames: function() {
        return _reacttext.title1ClassNames;
    },
    title2ClassNames: function() {
        return _reacttext.title2ClassNames;
    },
    title3ClassNames: function() {
        return _reacttext.title3ClassNames;
    },
    toMountNodeProps: function() {
        return _reactportal.toMountNodeProps;
    },
    toastBodyClassNames: function() {
        return _reacttoast.toastBodyClassNames;
    },
    toastFooterClassNames: function() {
        return _reacttoast.toastFooterClassNames;
    },
    toastTitleClassNames: function() {
        return _reacttoast.toastTitleClassNames;
    },
    toasterClassNames: function() {
        return _reacttoast.toasterClassNames;
    },
    toggleButtonClassNames: function() {
        return _reactbutton.toggleButtonClassNames;
    },
    tokens: function() {
        return _reacttheme.tokens;
    },
    toolbarClassNames: function() {
        return _reacttoolbar.toolbarClassNames;
    },
    toolbarGroupClassNames: function() {
        return _reacttoolbar.toolbarGroupClassNames;
    },
    tooltipClassNames: function() {
        return _reacttooltip.tooltipClassNames;
    },
    treeClassNames: function() {
        return _reacttree.treeClassNames;
    },
    treeItemClassNames: function() {
        return _reacttree.treeItemClassNames;
    },
    treeItemLayoutClassNames: function() {
        return _reacttree.treeItemLayoutClassNames;
    },
    treeItemLevelToken: function() {
        return _reacttree.treeItemLevelToken;
    },
    treeItemPersonaLayoutClassNames: function() {
        return _reacttree.treeItemPersonaLayoutClassNames;
    },
    truncateBreadcrumLongTooltip: function() {
        return _reactbreadcrumb.truncateBreadcrumLongTooltip;
    },
    truncateBreadcrumbLongName: function() {
        return _reactbreadcrumb.truncateBreadcrumbLongName;
    },
    typographyStyles: function() {
        return _reacttheme.typographyStyles;
    },
    useAccordionContextValues_unstable: function() {
        return _reactaccordion.useAccordionContextValues_unstable;
    },
    useAccordionContext_unstable: function() {
        return _reactaccordion.useAccordionContext_unstable;
    },
    useAccordionHeaderContextValues_unstable: function() {
        return _reactaccordion.useAccordionHeaderContextValues_unstable;
    },
    useAccordionHeaderStyles_unstable: function() {
        return _reactaccordion.useAccordionHeaderStyles_unstable;
    },
    useAccordionHeader_unstable: function() {
        return _reactaccordion.useAccordionHeader_unstable;
    },
    useAccordionItemContextValues_unstable: function() {
        return _reactaccordion.useAccordionItemContextValues_unstable;
    },
    useAccordionItemContext_unstable: function() {
        return _reactaccordion.useAccordionItemContext_unstable;
    },
    useAccordionItemStyles_unstable: function() {
        return _reactaccordion.useAccordionItemStyles_unstable;
    },
    useAccordionItem_unstable: function() {
        return _reactaccordion.useAccordionItem_unstable;
    },
    useAccordionPanelStyles_unstable: function() {
        return _reactaccordion.useAccordionPanelStyles_unstable;
    },
    useAccordionPanel_unstable: function() {
        return _reactaccordion.useAccordionPanel_unstable;
    },
    useAccordionStyles_unstable: function() {
        return _reactaccordion.useAccordionStyles_unstable;
    },
    useAccordion_unstable: function() {
        return _reactaccordion.useAccordion_unstable;
    },
    useAlphaSliderStyles_unstable: function() {
        return _reactcolorpicker.useAlphaSliderStyles_unstable;
    },
    useAlphaSlider_unstable: function() {
        return _reactcolorpicker.useAlphaSlider_unstable;
    },
    useAnimationFrame: function() {
        return _reactutilities.useAnimationFrame;
    },
    useAnnounce: function() {
        return _reactsharedcontexts.useAnnounce;
    },
    useAppItemStaticStyles_unstable: function() {
        return _reactnav.useAppItemStaticStyles_unstable;
    },
    useAppItemStatic_unstable: function() {
        return _reactnav.useAppItemStatic_unstable;
    },
    useAppItemStyles_unstable: function() {
        return _reactnav.useAppItemStyles_unstable;
    },
    useAppItem_unstable: function() {
        return _reactnav.useAppItem_unstable;
    },
    useApplyScrollbarWidth: function() {
        return _reactutilities.useApplyScrollbarWidth;
    },
    useAriaLiveAnnouncerContextValues_unstable: function() {
        return _reactaria.useAriaLiveAnnouncerContextValues_unstable;
    },
    useAriaLiveAnnouncer_unstable: function() {
        return _reactaria.useAriaLiveAnnouncer_unstable;
    },
    useArrowNavigationGroup: function() {
        return _reacttabster.useArrowNavigationGroup;
    },
    useAvatarGroupContextValues: function() {
        return _reactavatar.useAvatarGroupContextValues;
    },
    useAvatarGroupContext_unstable: function() {
        return _reactavatar.useAvatarGroupContext_unstable;
    },
    useAvatarGroupItemStyles_unstable: function() {
        return _reactavatar.useAvatarGroupItemStyles_unstable;
    },
    useAvatarGroupItem_unstable: function() {
        return _reactavatar.useAvatarGroupItem_unstable;
    },
    useAvatarGroupPopoverContextValues_unstable: function() {
        return _reactavatar.useAvatarGroupPopoverContextValues_unstable;
    },
    useAvatarGroupPopoverStyles_unstable: function() {
        return _reactavatar.useAvatarGroupPopoverStyles_unstable;
    },
    useAvatarGroupPopover_unstable: function() {
        return _reactavatar.useAvatarGroupPopover_unstable;
    },
    useAvatarGroupStyles_unstable: function() {
        return _reactavatar.useAvatarGroupStyles_unstable;
    },
    useAvatarGroup_unstable: function() {
        return _reactavatar.useAvatarGroup_unstable;
    },
    useAvatarStyles_unstable: function() {
        return _reactavatar.useAvatarStyles_unstable;
    },
    useAvatar_unstable: function() {
        return _reactavatar.useAvatar_unstable;
    },
    useBadgeStyles_unstable: function() {
        return _reactbadge.useBadgeStyles_unstable;
    },
    useBadge_unstable: function() {
        return _reactbadge.useBadge_unstable;
    },
    useBreadcrumbButtonStyles_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbButtonStyles_unstable;
    },
    useBreadcrumbButton_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbButton_unstable;
    },
    useBreadcrumbContext_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbContext_unstable;
    },
    useBreadcrumbDividerStyles_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbDividerStyles_unstable;
    },
    useBreadcrumbDivider_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbDivider_unstable;
    },
    useBreadcrumbItemStyles_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbItemStyles_unstable;
    },
    useBreadcrumbItem_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbItem_unstable;
    },
    useBreadcrumbStyles_unstable: function() {
        return _reactbreadcrumb.useBreadcrumbStyles_unstable;
    },
    useBreadcrumb_unstable: function() {
        return _reactbreadcrumb.useBreadcrumb_unstable;
    },
    useButtonStyles_unstable: function() {
        return _reactbutton.useButtonStyles_unstable;
    },
    useButton_unstable: function() {
        return _reactbutton.useButton_unstable;
    },
    useCardFooterStyles_unstable: function() {
        return _reactcard.useCardFooterStyles_unstable;
    },
    useCardFooter_unstable: function() {
        return _reactcard.useCardFooter_unstable;
    },
    useCardHeaderStyles_unstable: function() {
        return _reactcard.useCardHeaderStyles_unstable;
    },
    useCardHeader_unstable: function() {
        return _reactcard.useCardHeader_unstable;
    },
    useCardPreviewStyles_unstable: function() {
        return _reactcard.useCardPreviewStyles_unstable;
    },
    useCardPreview_unstable: function() {
        return _reactcard.useCardPreview_unstable;
    },
    useCardStyles_unstable: function() {
        return _reactcard.useCardStyles_unstable;
    },
    useCard_unstable: function() {
        return _reactcard.useCard_unstable;
    },
    useCarouselAutoplayButtonStyles_unstable: function() {
        return _reactcarousel.useCarouselAutoplayButtonStyles_unstable;
    },
    useCarouselAutoplayButton_unstable: function() {
        return _reactcarousel.useCarouselAutoplayButton_unstable;
    },
    useCarouselButtonStyles_unstable: function() {
        return _reactcarousel.useCarouselButtonStyles_unstable;
    },
    useCarouselButton_unstable: function() {
        return _reactcarousel.useCarouselButton_unstable;
    },
    useCarouselCardStyles_unstable: function() {
        return _reactcarousel.useCarouselCardStyles_unstable;
    },
    useCarouselCard_unstable: function() {
        return _reactcarousel.useCarouselCard_unstable;
    },
    useCarouselContext_unstable: function() {
        return _reactcarousel.useCarouselContext_unstable;
    },
    useCarouselNavButtonStyles_unstable: function() {
        return _reactcarousel.useCarouselNavButtonStyles_unstable;
    },
    useCarouselNavButton_unstable: function() {
        return _reactcarousel.useCarouselNavButton_unstable;
    },
    useCarouselNavContainerStyles_unstable: function() {
        return _reactcarousel.useCarouselNavContainerStyles_unstable;
    },
    useCarouselNavContainer_unstable: function() {
        return _reactcarousel.useCarouselNavContainer_unstable;
    },
    useCarouselNavImageButtonStyles_unstable: function() {
        return _reactcarousel.useCarouselNavImageButtonStyles_unstable;
    },
    useCarouselNavImageButton_unstable: function() {
        return _reactcarousel.useCarouselNavImageButton_unstable;
    },
    useCarouselNavStyles_unstable: function() {
        return _reactcarousel.useCarouselNavStyles_unstable;
    },
    useCarouselNav_unstable: function() {
        return _reactcarousel.useCarouselNav_unstable;
    },
    useCarouselSliderStyles_unstable: function() {
        return _reactcarousel.useCarouselSliderStyles_unstable;
    },
    useCarouselSlider_unstable: function() {
        return _reactcarousel.useCarouselSlider_unstable;
    },
    useCarouselStyles_unstable: function() {
        return _reactcarousel.useCarouselStyles_unstable;
    },
    useCarouselViewportStyles_unstable: function() {
        return _reactcarousel.useCarouselViewportStyles_unstable;
    },
    useCarouselViewport_unstable: function() {
        return _reactcarousel.useCarouselViewport_unstable;
    },
    useCarousel_unstable: function() {
        return _reactcarousel.useCarousel_unstable;
    },
    useCheckboxStyles_unstable: function() {
        return _reactcheckbox.useCheckboxStyles_unstable;
    },
    useCheckbox_unstable: function() {
        return _reactcheckbox.useCheckbox_unstable;
    },
    useCheckmarkStyles_unstable: function() {
        return _reactmenu.useCheckmarkStyles_unstable;
    },
    useColorAreaStyles_unstable: function() {
        return _reactcolorpicker.useColorAreaStyles_unstable;
    },
    useColorArea_unstable: function() {
        return _reactcolorpicker.useColorArea_unstable;
    },
    useColorPickerStyles_unstable: function() {
        return _reactcolorpicker.useColorPickerStyles_unstable;
    },
    useColorPicker_unstable: function() {
        return _reactcolorpicker.useColorPicker_unstable;
    },
    useColorSliderStyles_unstable: function() {
        return _reactcolorpicker.useColorSliderStyles_unstable;
    },
    useColorSlider_unstable: function() {
        return _reactcolorpicker.useColorSlider_unstable;
    },
    useColorSwatchStyles_unstable: function() {
        return _reactswatchpicker.useColorSwatchStyles_unstable;
    },
    useColorSwatch_unstable: function() {
        return _reactswatchpicker.useColorSwatch_unstable;
    },
    useColumnIdContext: function() {
        return _reacttable.useColumnIdContext;
    },
    useComboboxContextValues: function() {
        return _reactcombobox.useComboboxContextValues;
    },
    useComboboxFilter: function() {
        return _reactcombobox.useComboboxFilter;
    },
    useComboboxStyles_unstable: function() {
        return _reactcombobox.useComboboxStyles_unstable;
    },
    useCombobox_unstable: function() {
        return _reactcombobox.useCombobox_unstable;
    },
    useCompoundButtonStyles_unstable: function() {
        return _reactbutton.useCompoundButtonStyles_unstable;
    },
    useCompoundButton_unstable: function() {
        return _reactbutton.useCompoundButton_unstable;
    },
    useCounterBadgeStyles_unstable: function() {
        return _reactbadge.useCounterBadgeStyles_unstable;
    },
    useCounterBadge_unstable: function() {
        return _reactbadge.useCounterBadge_unstable;
    },
    useDataGridBodyStyles_unstable: function() {
        return _reacttable.useDataGridBodyStyles_unstable;
    },
    useDataGridBody_unstable: function() {
        return _reacttable.useDataGridBody_unstable;
    },
    useDataGridCellStyles_unstable: function() {
        return _reacttable.useDataGridCellStyles_unstable;
    },
    useDataGridCell_unstable: function() {
        return _reacttable.useDataGridCell_unstable;
    },
    useDataGridContextValues_unstable: function() {
        return _reacttable.useDataGridContextValues_unstable;
    },
    useDataGridContext_unstable: function() {
        return _reacttable.useDataGridContext_unstable;
    },
    useDataGridHeaderCellStyles_unstable: function() {
        return _reacttable.useDataGridHeaderCellStyles_unstable;
    },
    useDataGridHeaderCell_unstable: function() {
        return _reacttable.useDataGridHeaderCell_unstable;
    },
    useDataGridHeaderStyles_unstable: function() {
        return _reacttable.useDataGridHeaderStyles_unstable;
    },
    useDataGridHeader_unstable: function() {
        return _reacttable.useDataGridHeader_unstable;
    },
    useDataGridRowStyles_unstable: function() {
        return _reacttable.useDataGridRowStyles_unstable;
    },
    useDataGridRow_unstable: function() {
        return _reacttable.useDataGridRow_unstable;
    },
    useDataGridSelectionCellStyles_unstable: function() {
        return _reacttable.useDataGridSelectionCellStyles_unstable;
    },
    useDataGridSelectionCell_unstable: function() {
        return _reacttable.useDataGridSelectionCell_unstable;
    },
    useDataGridStyles_unstable: function() {
        return _reacttable.useDataGridStyles_unstable;
    },
    useDataGrid_unstable: function() {
        return _reacttable.useDataGrid_unstable;
    },
    useDialogActionsStyles_unstable: function() {
        return _reactdialog.useDialogActionsStyles_unstable;
    },
    useDialogActions_unstable: function() {
        return _reactdialog.useDialogActions_unstable;
    },
    useDialogBackdropContext_unstable: function() {
        return _reactdialog.useDialogBackdropContext_unstable;
    },
    useDialogBodyStyles_unstable: function() {
        return _reactdialog.useDialogBodyStyles_unstable;
    },
    useDialogBody_unstable: function() {
        return _reactdialog.useDialogBody_unstable;
    },
    useDialogContentStyles_unstable: function() {
        return _reactdialog.useDialogContentStyles_unstable;
    },
    useDialogContent_unstable: function() {
        return _reactdialog.useDialogContent_unstable;
    },
    useDialogContext_unstable: function() {
        return _reactdialog.useDialogContext_unstable;
    },
    useDialogSurfaceContextValues_unstable: function() {
        return _reactdialog.useDialogSurfaceContextValues_unstable;
    },
    useDialogSurfaceContext_unstable: function() {
        return _reactdialog.useDialogSurfaceContext_unstable;
    },
    useDialogSurfaceStyles_unstable: function() {
        return _reactdialog.useDialogSurfaceStyles_unstable;
    },
    useDialogSurface_unstable: function() {
        return _reactdialog.useDialogSurface_unstable;
    },
    useDialogTitleStyles_unstable: function() {
        return _reactdialog.useDialogTitleStyles_unstable;
    },
    useDialogTitle_unstable: function() {
        return _reactdialog.useDialogTitle_unstable;
    },
    useDialogTrigger_unstable: function() {
        return _reactdialog.useDialogTrigger_unstable;
    },
    useDialog_unstable: function() {
        return _reactdialog.useDialog_unstable;
    },
    useDividerStyles_unstable: function() {
        return _reactdivider.useDividerStyles_unstable;
    },
    useDivider_unstable: function() {
        return _reactdivider.useDivider_unstable;
    },
    useDrawerBodyStyles_unstable: function() {
        return _reactdrawer.useDrawerBodyStyles_unstable;
    },
    useDrawerBody_unstable: function() {
        return _reactdrawer.useDrawerBody_unstable;
    },
    useDrawerContextValue: function() {
        return _reactdrawer.useDrawerContextValue;
    },
    useDrawerContext_unstable: function() {
        return _reactdrawer.useDrawerContext_unstable;
    },
    useDrawerFooterStyles_unstable: function() {
        return _reactdrawer.useDrawerFooterStyles_unstable;
    },
    useDrawerFooter_unstable: function() {
        return _reactdrawer.useDrawerFooter_unstable;
    },
    useDrawerHeaderNavigationStyles_unstable: function() {
        return _reactdrawer.useDrawerHeaderNavigationStyles_unstable;
    },
    useDrawerHeaderNavigation_unstable: function() {
        return _reactdrawer.useDrawerHeaderNavigation_unstable;
    },
    useDrawerHeaderStyles_unstable: function() {
        return _reactdrawer.useDrawerHeaderStyles_unstable;
    },
    useDrawerHeaderTitleStyles_unstable: function() {
        return _reactdrawer.useDrawerHeaderTitleStyles_unstable;
    },
    useDrawerHeaderTitle_unstable: function() {
        return _reactdrawer.useDrawerHeaderTitle_unstable;
    },
    useDrawerHeader_unstable: function() {
        return _reactdrawer.useDrawerHeader_unstable;
    },
    useDrawerStyles_unstable: function() {
        return _reactdrawer.useDrawerStyles_unstable;
    },
    useDrawer_unstable: function() {
        return _reactdrawer.useDrawer_unstable;
    },
    useDropdownStyles_unstable: function() {
        return _reactcombobox.useDropdownStyles_unstable;
    },
    useDropdown_unstable: function() {
        return _reactcombobox.useDropdown_unstable;
    },
    useEmptySwatchStyles_unstable: function() {
        return _reactswatchpicker.useEmptySwatchStyles_unstable;
    },
    useEmptySwatch_unstable: function() {
        return _reactswatchpicker.useEmptySwatch_unstable;
    },
    useEventCallback: function() {
        return _reactutilities.useEventCallback;
    },
    useFieldContextValues_unstable: function() {
        return _reactfield.useFieldContextValues_unstable;
    },
    useFieldContext_unstable: function() {
        return _reactfield.useFieldContext_unstable;
    },
    useFieldControlProps_unstable: function() {
        return _reactfield.useFieldControlProps_unstable;
    },
    useFieldStyles_unstable: function() {
        return _reactfield.useFieldStyles_unstable;
    },
    useField_unstable: function() {
        return _reactfield.useField_unstable;
    },
    useFlatTreeContextValues_unstable: function() {
        return _reacttree.useFlatTreeContextValues_unstable;
    },
    useFlatTreeStyles_unstable: function() {
        return _reacttree.useFlatTreeStyles_unstable;
    },
    useFlatTree_unstable: function() {
        return _reacttree.useFlatTree_unstable;
    },
    useFluent: function() {
        return _reactsharedcontexts.useFluent_unstable;
    },
    useFluentProviderContextValues_unstable: function() {
        return _reactprovider.useFluentProviderContextValues_unstable;
    },
    useFluentProviderStyles_unstable: function() {
        return _reactprovider.useFluentProviderStyles_unstable;
    },
    useFluentProviderThemeStyleTag: function() {
        return _reactprovider.useFluentProviderThemeStyleTag;
    },
    useFluentProvider_unstable: function() {
        return _reactprovider.useFluentProvider_unstable;
    },
    useFocusFinders: function() {
        return _reacttabster.useFocusFinders;
    },
    useFocusObserved: function() {
        return _reacttabster.useFocusObserved;
    },
    useFocusVisible: function() {
        return _reacttabster.useFocusVisible;
    },
    useFocusWithin: function() {
        return _reacttabster.useFocusWithin;
    },
    useFocusableGroup: function() {
        return _reacttabster.useFocusableGroup;
    },
    useHamburgerStyles_unstable: function() {
        return _reactnav.useHamburgerStyles_unstable;
    },
    useHamburger_unstable: function() {
        return _reactnav.useHamburger_unstable;
    },
    useHeadlessFlatTree_unstable: function() {
        return _reacttree.useHeadlessFlatTree_unstable;
    },
    useId: function() {
        return _reactutilities.useId;
    },
    useImageStyles_unstable: function() {
        return _reactimage.useImageStyles_unstable;
    },
    useImageSwatchStyles_unstable: function() {
        return _reactswatchpicker.useImageSwatchStyles_unstable;
    },
    useImageSwatch_unstable: function() {
        return _reactswatchpicker.useImageSwatch_unstable;
    },
    useImage_unstable: function() {
        return _reactimage.useImage_unstable;
    },
    useInfoButtonStyles_unstable: function() {
        return _reactinfolabel.useInfoButtonStyles_unstable;
    },
    useInfoButton_unstable: function() {
        return _reactinfolabel.useInfoButton_unstable;
    },
    useInfoLabelStyles_unstable: function() {
        return _reactinfolabel.useInfoLabelStyles_unstable;
    },
    useInfoLabel_unstable: function() {
        return _reactinfolabel.useInfoLabel_unstable;
    },
    useInlineDrawerStyles_unstable: function() {
        return _reactdrawer.useInlineDrawerStyles_unstable;
    },
    useInlineDrawer_unstable: function() {
        return _reactdrawer.useInlineDrawer_unstable;
    },
    useInputStyles_unstable: function() {
        return _reactinput.useInputStyles_unstable;
    },
    useInput_unstable: function() {
        return _reactinput.useInput_unstable;
    },
    useInteractionTagContextValues_unstable: function() {
        return _reacttags.useInteractionTagContextValues_unstable;
    },
    useInteractionTagPrimaryStyles_unstable: function() {
        return _reacttags.useInteractionTagPrimaryStyles_unstable;
    },
    useInteractionTagPrimary_unstable: function() {
        return _reacttags.useInteractionTagPrimary_unstable;
    },
    useInteractionTagSecondaryStyles_unstable: function() {
        return _reacttags.useInteractionTagSecondaryStyles_unstable;
    },
    useInteractionTagSecondary_unstable: function() {
        return _reacttags.useInteractionTagSecondary_unstable;
    },
    useInteractionTagStyles_unstable: function() {
        return _reacttags.useInteractionTagStyles_unstable;
    },
    useInteractionTag_unstable: function() {
        return _reacttags.useInteractionTag_unstable;
    },
    useIsInTableHeader: function() {
        return _reacttable.useIsInTableHeader;
    },
    useIsOverflowGroupVisible: function() {
        return _reactoverflow.useIsOverflowGroupVisible;
    },
    useIsOverflowItemVisible: function() {
        return _reactoverflow.useIsOverflowItemVisible;
    },
    useIsSSR: function() {
        return _reactutilities.useIsSSR;
    },
    useIsomorphicLayoutEffect: function() {
        return _reactutilities.useIsomorphicLayoutEffect;
    },
    useKeyboardNavAttribute: function() {
        return _reacttabster.useKeyboardNavAttribute;
    },
    useLabelStyles_unstable: function() {
        return _reactlabel.useLabelStyles_unstable;
    },
    useLabel_unstable: function() {
        return _reactlabel.useLabel_unstable;
    },
    useLinkState_unstable: function() {
        return _reactlink.useLinkState_unstable;
    },
    useLinkStyles_unstable: function() {
        return _reactlink.useLinkStyles_unstable;
    },
    useLink_unstable: function() {
        return _reactlink.useLink_unstable;
    },
    useListItemStyles_unstable: function() {
        return _reactlist.useListItemStyles_unstable;
    },
    useListItem_unstable: function() {
        return _reactlist.useListItem_unstable;
    },
    useListStyles_unstable: function() {
        return _reactlist.useListStyles_unstable;
    },
    useList_unstable: function() {
        return _reactlist.useList_unstable;
    },
    useListboxContextValues: function() {
        return _reactcombobox.useListboxContextValues;
    },
    useListboxContext_unstable: function() {
        return _reactcombobox.useListboxContext_unstable;
    },
    useListboxStyles_unstable: function() {
        return _reactcombobox.useListboxStyles_unstable;
    },
    useListbox_unstable: function() {
        return _reactcombobox.useListbox_unstable;
    },
    useMenuButtonStyles_unstable: function() {
        return _reactbutton.useMenuButtonStyles_unstable;
    },
    useMenuButton_unstable: function() {
        return _reactbutton.useMenuButton_unstable;
    },
    useMenuContextValues_unstable: function() {
        return _reactmenu.useMenuContextValues_unstable;
    },
    useMenuContext_unstable: function() {
        return _reactmenu.useMenuContext_unstable;
    },
    useMenuDividerStyles_unstable: function() {
        return _reactmenu.useMenuDividerStyles_unstable;
    },
    useMenuDivider_unstable: function() {
        return _reactmenu.useMenuDivider_unstable;
    },
    useMenuGroupContextValues_unstable: function() {
        return _reactmenu.useMenuGroupContextValues_unstable;
    },
    useMenuGroupContext_unstable: function() {
        return _reactmenu.useMenuGroupContext_unstable;
    },
    useMenuGroupHeaderStyles_unstable: function() {
        return _reactmenu.useMenuGroupHeaderStyles_unstable;
    },
    useMenuGroupHeader_unstable: function() {
        return _reactmenu.useMenuGroupHeader_unstable;
    },
    useMenuGroupStyles_unstable: function() {
        return _reactmenu.useMenuGroupStyles_unstable;
    },
    useMenuGroup_unstable: function() {
        return _reactmenu.useMenuGroup_unstable;
    },
    useMenuItemCheckboxStyles_unstable: function() {
        return _reactmenu.useMenuItemCheckboxStyles_unstable;
    },
    useMenuItemCheckbox_unstable: function() {
        return _reactmenu.useMenuItemCheckbox_unstable;
    },
    useMenuItemLinkStyles_unstable: function() {
        return _reactmenu.useMenuItemLinkStyles_unstable;
    },
    useMenuItemLink_unstable: function() {
        return _reactmenu.useMenuItemLink_unstable;
    },
    useMenuItemRadioStyles_unstable: function() {
        return _reactmenu.useMenuItemRadioStyles_unstable;
    },
    useMenuItemRadio_unstable: function() {
        return _reactmenu.useMenuItemRadio_unstable;
    },
    useMenuItemStyles_unstable: function() {
        return _reactmenu.useMenuItemStyles_unstable;
    },
    useMenuItemSwitchStyles_unstable: function() {
        return _reactmenu.useMenuItemSwitchStyles_unstable;
    },
    useMenuItemSwitch_unstable: function() {
        return _reactmenu.useMenuItemSwitch_unstable;
    },
    useMenuItem_unstable: function() {
        return _reactmenu.useMenuItem_unstable;
    },
    useMenuListContextValues_unstable: function() {
        return _reactmenu.useMenuListContextValues_unstable;
    },
    useMenuListContext_unstable: function() {
        return _reactmenu.useMenuListContext_unstable;
    },
    useMenuListStyles_unstable: function() {
        return _reactmenu.useMenuListStyles_unstable;
    },
    useMenuList_unstable: function() {
        return _reactmenu.useMenuList_unstable;
    },
    useMenuPopoverStyles_unstable: function() {
        return _reactmenu.useMenuPopoverStyles_unstable;
    },
    useMenuPopover_unstable: function() {
        return _reactmenu.useMenuPopover_unstable;
    },
    useMenuSplitGroupStyles_unstable: function() {
        return _reactmenu.useMenuSplitGroupStyles_unstable;
    },
    useMenuSplitGroup_unstable: function() {
        return _reactmenu.useMenuSplitGroup_unstable;
    },
    useMenuTriggerContext_unstable: function() {
        return _reactmenu.useMenuTriggerContext_unstable;
    },
    useMenuTrigger_unstable: function() {
        return _reactmenu.useMenuTrigger_unstable;
    },
    useMenu_unstable: function() {
        return _reactmenu.useMenu_unstable;
    },
    useMergedRefs: function() {
        return _reactutilities.useMergedRefs;
    },
    useMessageBarActionsContextValue_unstable: function() {
        return _reactmessagebar.useMessageBarActionsContextValue_unstable;
    },
    useMessageBarActionsStyles_unstable: function() {
        return _reactmessagebar.useMessageBarActionsStyles_unstable;
    },
    useMessageBarActions_unstable: function() {
        return _reactmessagebar.useMessageBarActions_unstable;
    },
    useMessageBarBodyStyles_unstable: function() {
        return _reactmessagebar.useMessageBarBodyStyles_unstable;
    },
    useMessageBarBody_unstable: function() {
        return _reactmessagebar.useMessageBarBody_unstable;
    },
    useMessageBarContext: function() {
        return _reactmessagebar.useMessageBarContext;
    },
    useMessageBarContextValue_unstable: function() {
        return _reactmessagebar.useMessageBarContextValue_unstable;
    },
    useMessageBarGroupStyles_unstable: function() {
        return _reactmessagebar.useMessageBarGroupStyles_unstable;
    },
    useMessageBarGroup_unstable: function() {
        return _reactmessagebar.useMessageBarGroup_unstable;
    },
    useMessageBarStyles_unstable: function() {
        return _reactmessagebar.useMessageBarStyles_unstable;
    },
    useMessageBarTitleStyles_unstable: function() {
        return _reactmessagebar.useMessageBarTitleStyles_unstable;
    },
    useMessageBarTitle_unstable: function() {
        return _reactmessagebar.useMessageBarTitle_unstable;
    },
    useMessageBar_unstable: function() {
        return _reactmessagebar.useMessageBar_unstable;
    },
    useModalAttributes: function() {
        return _reacttabster.useModalAttributes;
    },
    useNavCategoryContextValues_unstable: function() {
        return _reactnav.useNavCategoryContextValues_unstable;
    },
    useNavCategoryContext_unstable: function() {
        return _reactnav.useNavCategoryContext_unstable;
    },
    useNavCategoryItemContextValues_unstable: function() {
        return _reactnav.useNavCategoryItemContextValues_unstable;
    },
    useNavCategoryItemContext_unstable: function() {
        return _reactnav.useNavCategoryItemContext_unstable;
    },
    useNavCategoryItemStyles_unstable: function() {
        return _reactnav.useNavCategoryItemStyles_unstable;
    },
    useNavCategoryItem_unstable: function() {
        return _reactnav.useNavCategoryItem_unstable;
    },
    useNavCategory_unstable: function() {
        return _reactnav.useNavCategory_unstable;
    },
    useNavContextValues_unstable: function() {
        return _reactnav.useNavContextValues_unstable;
    },
    useNavContext_unstable: function() {
        return _reactnav.useNavContext_unstable;
    },
    useNavDividerStyles_unstable: function() {
        return _reactnav.useNavDividerStyles_unstable;
    },
    useNavDivider_unstable: function() {
        return _reactnav.useNavDivider_unstable;
    },
    useNavDrawerBodyStyles_unstable: function() {
        return _reactnav.useNavDrawerBodyStyles_unstable;
    },
    useNavDrawerBody_unstable: function() {
        return _reactnav.useNavDrawerBody_unstable;
    },
    useNavDrawerFooterStyles_unstable: function() {
        return _reactnav.useNavDrawerFooterStyles_unstable;
    },
    useNavDrawerFooter_unstable: function() {
        return _reactnav.useNavDrawerFooter_unstable;
    },
    useNavDrawerHeaderStyles_unstable: function() {
        return _reactnav.useNavDrawerHeaderStyles_unstable;
    },
    useNavDrawerHeader_unstable: function() {
        return _reactnav.useNavDrawerHeader_unstable;
    },
    useNavDrawerStyles_unstable: function() {
        return _reactnav.useNavDrawerStyles_unstable;
    },
    useNavDrawer_unstable: function() {
        return _reactnav.useNavDrawer_unstable;
    },
    useNavItemStyles_unstable: function() {
        return _reactnav.useNavItemStyles_unstable;
    },
    useNavItem_unstable: function() {
        return _reactnav.useNavItem_unstable;
    },
    useNavSectionHeaderStyles_unstable: function() {
        return _reactnav.useNavSectionHeaderStyles_unstable;
    },
    useNavSectionHeader_unstable: function() {
        return _reactnav.useNavSectionHeader_unstable;
    },
    useNavStyles_unstable: function() {
        return _reactnav.useNavStyles_unstable;
    },
    useNavSubItemGroupStyles_unstable: function() {
        return _reactnav.useNavSubItemGroupStyles_unstable;
    },
    useNavSubItemGroup_unstable: function() {
        return _reactnav.useNavSubItemGroup_unstable;
    },
    useNavSubItemStyles_unstable: function() {
        return _reactnav.useNavSubItemStyles_unstable;
    },
    useNavSubItem_unstable: function() {
        return _reactnav.useNavSubItem_unstable;
    },
    useNav_unstable: function() {
        return _reactnav.useNav_unstable;
    },
    useObservedElement: function() {
        return _reacttabster.useObservedElement;
    },
    useOptionGroupStyles_unstable: function() {
        return _reactcombobox.useOptionGroupStyles_unstable;
    },
    useOptionGroup_unstable: function() {
        return _reactcombobox.useOptionGroup_unstable;
    },
    useOptionStyles_unstable: function() {
        return _reactcombobox.useOptionStyles_unstable;
    },
    useOption_unstable: function() {
        return _reactcombobox.useOption_unstable;
    },
    useOverflowCount: function() {
        return _reactoverflow.useOverflowCount;
    },
    useOverflowMenu: function() {
        return _reactoverflow.useOverflowMenu;
    },
    useOverflowVisibility: function() {
        return _reactoverflow.useOverflowVisibility;
    },
    useOverlayDrawerStyles_unstable: function() {
        return _reactdrawer.useOverlayDrawerStyles_unstable;
    },
    useOverlayDrawer_unstable: function() {
        return _reactdrawer.useOverlayDrawer_unstable;
    },
    usePersonaStyles_unstable: function() {
        return _reactpersona.usePersonaStyles_unstable;
    },
    usePersona_unstable: function() {
        return _reactpersona.usePersona_unstable;
    },
    usePopoverContext_unstable: function() {
        return _reactpopover.usePopoverContext_unstable;
    },
    usePopoverSurfaceStyles_unstable: function() {
        return _reactpopover.usePopoverSurfaceStyles_unstable;
    },
    usePopoverSurface_unstable: function() {
        return _reactpopover.usePopoverSurface_unstable;
    },
    usePopoverTrigger_unstable: function() {
        return _reactpopover.usePopoverTrigger_unstable;
    },
    usePopover_unstable: function() {
        return _reactpopover.usePopover_unstable;
    },
    usePortalMountNode: function() {
        return _reactsharedcontexts.usePortalMountNode;
    },
    usePortal_unstable: function() {
        return _reactportal.usePortal_unstable;
    },
    usePositioning: function() {
        return _reactpositioning.usePositioning;
    },
    usePresenceBadgeStyles_unstable: function() {
        return _reactbadge.usePresenceBadgeStyles_unstable;
    },
    usePresenceBadge_unstable: function() {
        return _reactbadge.usePresenceBadge_unstable;
    },
    useProgressBarStyles_unstable: function() {
        return _reactprogress.useProgressBarStyles_unstable;
    },
    useProgressBar_unstable: function() {
        return _reactprogress.useProgressBar_unstable;
    },
    useRadioGroupContextValue_unstable: function() {
        return _reactradio.useRadioGroupContextValue_unstable;
    },
    useRadioGroupContextValues: function() {
        return _reactradio.useRadioGroupContextValues;
    },
    useRadioGroupContext_unstable: function() {
        return _reactradio.useRadioGroupContext_unstable;
    },
    useRadioGroupStyles_unstable: function() {
        return _reactradio.useRadioGroupStyles_unstable;
    },
    useRadioGroup_unstable: function() {
        return _reactradio.useRadioGroup_unstable;
    },
    useRadioStyles_unstable: function() {
        return _reactradio.useRadioStyles_unstable;
    },
    useRadio_unstable: function() {
        return _reactradio.useRadio_unstable;
    },
    useRatingContextValues: function() {
        return _reactrating.useRatingContextValues;
    },
    useRatingDisplayContextValues: function() {
        return _reactrating.useRatingDisplayContextValues;
    },
    useRatingDisplayStyles_unstable: function() {
        return _reactrating.useRatingDisplayStyles_unstable;
    },
    useRatingDisplay_unstable: function() {
        return _reactrating.useRatingDisplay_unstable;
    },
    useRatingItemContextValue_unstable: function() {
        return _reactrating.useRatingItemContextValue_unstable;
    },
    useRatingItemStyles_unstable: function() {
        return _reactrating.useRatingItemStyles_unstable;
    },
    useRatingItem_unstable: function() {
        return _reactrating.useRatingItem_unstable;
    },
    useRatingStyles_unstable: function() {
        return _reactrating.useRatingStyles_unstable;
    },
    useRating_unstable: function() {
        return _reactrating.useRating_unstable;
    },
    useRestoreFocusSource: function() {
        return _reacttabster.useRestoreFocusSource;
    },
    useRestoreFocusTarget: function() {
        return _reacttabster.useRestoreFocusTarget;
    },
    useSafeZoneArea: function() {
        return _reactpositioning.useSafeZoneArea;
    },
    useScrollbarWidth: function() {
        return _reactutilities.useScrollbarWidth;
    },
    useSearchBoxStyles_unstable: function() {
        return _reactsearch.useSearchBoxStyles_unstable;
    },
    useSearchBox_unstable: function() {
        return _reactsearch.useSearchBox_unstable;
    },
    useSelectStyles_unstable: function() {
        return _reactselect.useSelectStyles_unstable;
    },
    useSelect_unstable: function() {
        return _reactselect.useSelect_unstable;
    },
    useSelection: function() {
        return _reactutilities.useSelection;
    },
    useSkeletonContext: function() {
        return _reactskeleton.useSkeletonContext;
    },
    useSkeletonItemStyles_unstable: function() {
        return _reactskeleton.useSkeletonItemStyles_unstable;
    },
    useSkeletonItem_unstable: function() {
        return _reactskeleton.useSkeletonItem_unstable;
    },
    useSkeletonStyles_unstable: function() {
        return _reactskeleton.useSkeletonStyles_unstable;
    },
    useSkeleton_unstable: function() {
        return _reactskeleton.useSkeleton_unstable;
    },
    useSliderState_unstable: function() {
        return _reactslider.useSliderState_unstable;
    },
    useSliderStyles_unstable: function() {
        return _reactslider.useSliderStyles_unstable;
    },
    useSlider_unstable: function() {
        return _reactslider.useSlider_unstable;
    },
    useSpinButtonStyles_unstable: function() {
        return _reactspinbutton.useSpinButtonStyles_unstable;
    },
    useSpinButton_unstable: function() {
        return _reactspinbutton.useSpinButton_unstable;
    },
    useSpinnerStyles_unstable: function() {
        return _reactspinner.useSpinnerStyles_unstable;
    },
    useSpinner_unstable: function() {
        return _reactspinner.useSpinner_unstable;
    },
    useSplitButtonStyles_unstable: function() {
        return _reactbutton.useSplitButtonStyles_unstable;
    },
    useSplitButton_unstable: function() {
        return _reactbutton.useSplitButton_unstable;
    },
    useSplitNavItemStyles_unstable: function() {
        return _reactnav.useSplitNavItemStyles_unstable;
    },
    useSplitNavItem_unstable: function() {
        return _reactnav.useSplitNavItem_unstable;
    },
    useSubtreeContext_unstable: function() {
        return _reacttree.useSubtreeContext_unstable;
    },
    useSwatchPickerContextValue_unstable: function() {
        return _reactswatchpicker.useSwatchPickerContextValue_unstable;
    },
    useSwatchPickerContextValues: function() {
        return _reactswatchpicker.useSwatchPickerContextValues;
    },
    useSwatchPickerRowStyles_unstable: function() {
        return _reactswatchpicker.useSwatchPickerRowStyles_unstable;
    },
    useSwatchPickerRow_unstable: function() {
        return _reactswatchpicker.useSwatchPickerRow_unstable;
    },
    useSwatchPickerStyles_unstable: function() {
        return _reactswatchpicker.useSwatchPickerStyles_unstable;
    },
    useSwatchPicker_unstable: function() {
        return _reactswatchpicker.useSwatchPicker_unstable;
    },
    useSwitchStyles_unstable: function() {
        return _reactswitch.useSwitchStyles_unstable;
    },
    useSwitch_unstable: function() {
        return _reactswitch.useSwitch_unstable;
    },
    useTabListContextValues_unstable: function() {
        return _reacttabs.useTabListContextValues_unstable;
    },
    useTabListContext_unstable: function() {
        return _reacttabs.useTabListContext_unstable;
    },
    useTabListStyles_unstable: function() {
        return _reacttabs.useTabListStyles_unstable;
    },
    useTabList_unstable: function() {
        return _reacttabs.useTabList_unstable;
    },
    useTabStyles_unstable: function() {
        return _reacttabs.useTabStyles_unstable;
    },
    useTab_unstable: function() {
        return _reacttabs.useTab_unstable;
    },
    useTableBodyStyles_unstable: function() {
        return _reacttable.useTableBodyStyles_unstable;
    },
    useTableBody_unstable: function() {
        return _reacttable.useTableBody_unstable;
    },
    useTableCellActionsStyles_unstable: function() {
        return _reacttable.useTableCellActionsStyles_unstable;
    },
    useTableCellActions_unstable: function() {
        return _reacttable.useTableCellActions_unstable;
    },
    useTableCellLayoutStyles_unstable: function() {
        return _reacttable.useTableCellLayoutStyles_unstable;
    },
    useTableCellLayout_unstable: function() {
        return _reacttable.useTableCellLayout_unstable;
    },
    useTableCellStyles_unstable: function() {
        return _reacttable.useTableCellStyles_unstable;
    },
    useTableCell_unstable: function() {
        return _reacttable.useTableCell_unstable;
    },
    useTableColumnSizing_unstable: function() {
        return _reacttable.useTableColumnSizing_unstable;
    },
    useTableCompositeNavigation: function() {
        return _reacttable.useTableCompositeNavigation;
    },
    useTableContext: function() {
        return _reacttable.useTableContext;
    },
    useTableFeatures: function() {
        return _reacttable.useTableFeatures;
    },
    useTableHeaderCellStyles_unstable: function() {
        return _reacttable.useTableHeaderCellStyles_unstable;
    },
    useTableHeaderCell_unstable: function() {
        return _reacttable.useTableHeaderCell_unstable;
    },
    useTableHeaderStyles_unstable: function() {
        return _reacttable.useTableHeaderStyles_unstable;
    },
    useTableHeader_unstable: function() {
        return _reacttable.useTableHeader_unstable;
    },
    useTableResizeHandleStyles_unstable: function() {
        return _reacttable.useTableResizeHandleStyles_unstable;
    },
    useTableResizeHandle_unstable: function() {
        return _reacttable.useTableResizeHandle_unstable;
    },
    useTableRowIdContext: function() {
        return _reacttable.useTableRowIdContext;
    },
    useTableRowStyles_unstable: function() {
        return _reacttable.useTableRowStyles_unstable;
    },
    useTableRow_unstable: function() {
        return _reacttable.useTableRow_unstable;
    },
    useTableSelection: function() {
        return _reacttable.useTableSelection;
    },
    useTableSelectionCellStyles_unstable: function() {
        return _reacttable.useTableSelectionCellStyles_unstable;
    },
    useTableSelectionCell_unstable: function() {
        return _reacttable.useTableSelectionCell_unstable;
    },
    useTableSort: function() {
        return _reacttable.useTableSort;
    },
    useTableStyles_unstable: function() {
        return _reacttable.useTableStyles_unstable;
    },
    useTable_unstable: function() {
        return _reacttable.useTable_unstable;
    },
    useTagAvatarContextValues_unstable: function() {
        return _reacttags.useTagAvatarContextValues_unstable;
    },
    useTagGroupContextValues_unstable: function() {
        return _reacttags.useTagGroupContextValues_unstable;
    },
    useTagGroupStyles_unstable: function() {
        return _reacttags.useTagGroupStyles_unstable;
    },
    useTagGroup_unstable: function() {
        return _reacttags.useTagGroup_unstable;
    },
    useTagPickerButtonStyles_unstable: function() {
        return _reacttagpicker.useTagPickerButtonStyles_unstable;
    },
    useTagPickerButton_unstable: function() {
        return _reacttagpicker.useTagPickerButton_unstable;
    },
    useTagPickerContext_unstable: function() {
        return _reacttagpicker.useTagPickerContext_unstable;
    },
    useTagPickerControlStyles_unstable: function() {
        return _reacttagpicker.useTagPickerControlStyles_unstable;
    },
    useTagPickerControl_unstable: function() {
        return _reacttagpicker.useTagPickerControl_unstable;
    },
    useTagPickerFilter: function() {
        return _reacttagpicker.useTagPickerFilter;
    },
    useTagPickerGroupStyles_unstable: function() {
        return _reacttagpicker.useTagPickerGroupStyles_unstable;
    },
    useTagPickerGroup_unstable: function() {
        return _reacttagpicker.useTagPickerGroup_unstable;
    },
    useTagPickerInputStyles_unstable: function() {
        return _reacttagpicker.useTagPickerInputStyles_unstable;
    },
    useTagPickerInput_unstable: function() {
        return _reacttagpicker.useTagPickerInput_unstable;
    },
    useTagPickerListStyles_unstable: function() {
        return _reacttagpicker.useTagPickerListStyles_unstable;
    },
    useTagPickerList_unstable: function() {
        return _reacttagpicker.useTagPickerList_unstable;
    },
    useTagPickerOptionGroup: function() {
        return _reacttagpicker.useTagPickerOptionGroup;
    },
    useTagPickerOptionGroupStyles: function() {
        return _reacttagpicker.useTagPickerOptionGroupStyles;
    },
    useTagPickerOptionStyles_unstable: function() {
        return _reacttagpicker.useTagPickerOptionStyles_unstable;
    },
    useTagPickerOption_unstable: function() {
        return _reacttagpicker.useTagPickerOption_unstable;
    },
    useTagPicker_unstable: function() {
        return _reacttagpicker.useTagPicker_unstable;
    },
    useTagStyles_unstable: function() {
        return _reacttags.useTagStyles_unstable;
    },
    useTag_unstable: function() {
        return _reacttags.useTag_unstable;
    },
    useTeachingPopoverBodyStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverBodyStyles_unstable;
    },
    useTeachingPopoverBody_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverBody_unstable;
    },
    useTeachingPopoverCarouselCardStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselCardStyles_unstable;
    },
    useTeachingPopoverCarouselCard_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselCard_unstable;
    },
    useTeachingPopoverCarouselContextValues_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselContextValues_unstable;
    },
    useTeachingPopoverCarouselFooterStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselFooterStyles_unstable;
    },
    useTeachingPopoverCarouselFooter_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselFooter_unstable;
    },
    useTeachingPopoverCarouselNavButtonStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselNavButtonStyles_unstable;
    },
    useTeachingPopoverCarouselNavButton_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselNavButton_unstable;
    },
    useTeachingPopoverCarouselNavStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselNavStyles_unstable;
    },
    useTeachingPopoverCarouselNav_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselNav_unstable;
    },
    useTeachingPopoverCarouselPageCountStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselPageCountStyles_unstable;
    },
    useTeachingPopoverCarouselPageCount_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselPageCount_unstable;
    },
    useTeachingPopoverCarouselStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarouselStyles_unstable;
    },
    useTeachingPopoverCarousel_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverCarousel_unstable;
    },
    useTeachingPopoverFooter_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverFooter_unstable;
    },
    useTeachingPopoverHeaderStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverHeaderStyles_unstable;
    },
    useTeachingPopoverHeader_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverHeader_unstable;
    },
    useTeachingPopoverSurfaceStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverSurfaceStyles_unstable;
    },
    useTeachingPopoverSurface_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverSurface_unstable;
    },
    useTeachingPopoverTitleStyles_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverTitleStyles_unstable;
    },
    useTeachingPopoverTitle_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverTitle_unstable;
    },
    useTeachingPopoverTrigger_unstable: function() {
        return _reactteachingpopover.useTeachingPopoverTrigger_unstable;
    },
    useTeachingPopover_unstable: function() {
        return _reactteachingpopover.useTeachingPopover_unstable;
    },
    useTextStyles_unstable: function() {
        return _reacttext.useTextStyles_unstable;
    },
    useText_unstable: function() {
        return _reacttext.useText_unstable;
    },
    useTextareaStyles_unstable: function() {
        return _reacttextarea.useTextareaStyles_unstable;
    },
    useTextarea_unstable: function() {
        return _reacttextarea.useTextarea_unstable;
    },
    useThemeClassName: function() {
        return _reactsharedcontexts.useThemeClassName_unstable;
    },
    useTimeout: function() {
        return _reactutilities.useTimeout;
    },
    useToastBodyStyles_unstable: function() {
        return _reacttoast.useToastBodyStyles_unstable;
    },
    useToastBody_unstable: function() {
        return _reacttoast.useToastBody_unstable;
    },
    useToastController: function() {
        return _reacttoast.useToastController;
    },
    useToastFooterStyles_unstable: function() {
        return _reacttoast.useToastFooterStyles_unstable;
    },
    useToastFooter_unstable: function() {
        return _reacttoast.useToastFooter_unstable;
    },
    useToastStyles_unstable: function() {
        return _reacttoast.useToastStyles_unstable;
    },
    useToastTitleStyles_unstable: function() {
        return _reacttoast.useToastTitleStyles_unstable;
    },
    useToastTitle_unstable: function() {
        return _reacttoast.useToastTitle_unstable;
    },
    useToastTrigger_unstable: function() {
        return _reacttoast.useToastTrigger_unstable;
    },
    useToast_unstable: function() {
        return _reacttoast.useToast_unstable;
    },
    useToasterStyles_unstable: function() {
        return _reacttoast.useToasterStyles_unstable;
    },
    useToaster_unstable: function() {
        return _reacttoast.useToaster_unstable;
    },
    useToggleButtonStyles_unstable: function() {
        return _reactbutton.useToggleButtonStyles_unstable;
    },
    useToggleButton_unstable: function() {
        return _reactbutton.useToggleButton_unstable;
    },
    useToggleState: function() {
        return _reactbutton.useToggleState;
    },
    useToolbarButtonStyles_unstable: function() {
        return _reacttoolbar.useToolbarButtonStyles_unstable;
    },
    useToolbarButton_unstable: function() {
        return _reacttoolbar.useToolbarButton_unstable;
    },
    useToolbarDividerStyles_unstable: function() {
        return _reacttoolbar.useToolbarDividerStyles_unstable;
    },
    useToolbarDivider_unstable: function() {
        return _reacttoolbar.useToolbarDivider_unstable;
    },
    useToolbarGroupStyles_unstable: function() {
        return _reacttoolbar.useToolbarGroupStyles_unstable;
    },
    useToolbarGroup_unstable: function() {
        return _reacttoolbar.useToolbarGroup_unstable;
    },
    useToolbarRadioButtonStyles_unstable: function() {
        return _reacttoolbar.useToolbarRadioButtonStyles_unstable;
    },
    useToolbarRadioButton_unstable: function() {
        return _reacttoolbar.useToolbarRadioButton_unstable;
    },
    useToolbarStyles_unstable: function() {
        return _reacttoolbar.useToolbarStyles_unstable;
    },
    useToolbarToggleButtonStyles_unstable: function() {
        return _reacttoolbar.useToolbarToggleButtonStyles_unstable;
    },
    useToolbarToggleButton_unstable: function() {
        return _reacttoolbar.useToolbarToggleButton_unstable;
    },
    useToolbar_unstable: function() {
        return _reacttoolbar.useToolbar_unstable;
    },
    useTooltipStyles_unstable: function() {
        return _reacttooltip.useTooltipStyles_unstable;
    },
    useTooltipVisibility: function() {
        return _reactsharedcontexts.useTooltipVisibility_unstable;
    },
    useTooltip_unstable: function() {
        return _reacttooltip.useTooltip_unstable;
    },
    useTreeContextValues_unstable: function() {
        return _reacttree.useTreeContextValues_unstable;
    },
    useTreeContext_unstable: function() {
        return _reacttree.useTreeContext_unstable;
    },
    useTreeItemContextValues_unstable: function() {
        return _reacttree.useTreeItemContextValues_unstable;
    },
    useTreeItemContext_unstable: function() {
        return _reacttree.useTreeItemContext_unstable;
    },
    useTreeItemLayoutStyles_unstable: function() {
        return _reacttree.useTreeItemLayoutStyles_unstable;
    },
    useTreeItemLayout_unstable: function() {
        return _reacttree.useTreeItemLayout_unstable;
    },
    useTreeItemPersonaLayoutStyles_unstable: function() {
        return _reacttree.useTreeItemPersonaLayoutStyles_unstable;
    },
    useTreeItemPersonaLayout_unstable: function() {
        return _reacttree.useTreeItemPersonaLayout_unstable;
    },
    useTreeItemStyles_unstable: function() {
        return _reacttree.useTreeItemStyles_unstable;
    },
    useTreeItem_unstable: function() {
        return _reacttree.useTreeItem_unstable;
    },
    useTreeNavigation: function() {
        return _reacttree.useTreeNavigation;
    },
    useTreeStyles_unstable: function() {
        return _reacttree.useTreeStyles_unstable;
    },
    useTree_unstable: function() {
        return _reacttree.useTree_unstable;
    },
    useTypingAnnounce: function() {
        return _reactaria.useTypingAnnounce;
    },
    useUncontrolledFocus: function() {
        return _reacttabster.useUncontrolledFocus;
    },
    webDarkTheme: function() {
        return _reacttheme.webDarkTheme;
    },
    webLightTheme: function() {
        return _reacttheme.webLightTheme;
    }
});
const _react = require("@griffel/react");
const _reactprovider = require("@fluentui/react-provider");
const _reacttabster = require("@fluentui/react-tabster");
const _reacttheme = require("@fluentui/react-theme");
const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
const _reactutilities = require("@fluentui/react-utilities");
const _reactaccordion = require("@fluentui/react-accordion");
const _reactavatar = require("@fluentui/react-avatar");
const _reactbadge = require("@fluentui/react-badge");
const _reactbutton = require("@fluentui/react-button");
const _reactcheckbox = require("@fluentui/react-checkbox");
const _reactcombobox = require("@fluentui/react-combobox");
const _reactdivider = require("@fluentui/react-divider");
const _reactinput = require("@fluentui/react-input");
const _reactimage = require("@fluentui/react-image");
const _reactlabel = require("@fluentui/react-label");
const _reactlink = require("@fluentui/react-link");
const _reactmenu = require("@fluentui/react-menu");
const _reactpersona = require("@fluentui/react-persona");
const _reactpopover = require("@fluentui/react-popover");
const _reactportal = require("@fluentui/react-portal");
const _reactradio = require("@fluentui/react-radio");
const _reactselect = require("@fluentui/react-select");
const _reactskeleton = require("@fluentui/react-skeleton");
const _reactslider = require("@fluentui/react-slider");
const _reactspinbutton = require("@fluentui/react-spinbutton");
const _reactspinner = require("@fluentui/react-spinner");
const _reactswitch = require("@fluentui/react-switch");
const _reacttabs = require("@fluentui/react-tabs");
const _reacttext = require("@fluentui/react-text");
const _reacttextarea = require("@fluentui/react-textarea");
const _reacttooltip = require("@fluentui/react-tooltip");
const _reactpositioning = require("@fluentui/react-positioning");
const _reactdialog = require("@fluentui/react-dialog");
const _reactprogress = require("@fluentui/react-progress");
const _reactoverflow = require("@fluentui/react-overflow");
const _reacttoolbar = require("@fluentui/react-toolbar");
const _reacttable = require("@fluentui/react-table");
const _reactcard = require("@fluentui/react-card");
const _reactfield = require("@fluentui/react-field");
const _reacttoast = require("@fluentui/react-toast");
const _reacttree = require("@fluentui/react-tree");
const _reacttags = require("@fluentui/react-tags");
const _reactmessagebar = require("@fluentui/react-message-bar");
const _reactinfolabel = require("@fluentui/react-infolabel");
const _reactdrawer = require("@fluentui/react-drawer");
const _reactbreadcrumb = require("@fluentui/react-breadcrumb");
const _reactaria = require("@fluentui/react-aria");
const _reactrating = require("@fluentui/react-rating");
const _reactsearch = require("@fluentui/react-search");
const _reactteachingpopover = require("@fluentui/react-teaching-popover");
const _reacttagpicker = require("@fluentui/react-tag-picker");
const _reactswatchpicker = require("@fluentui/react-swatch-picker");
const _reactmotion = require("@fluentui/react-motion");
const _reactcarousel = require("@fluentui/react-carousel");
const _reactlist = require("@fluentui/react-list");
const _reactcolorpicker = require("@fluentui/react-color-picker");
const _reactnav = require("@fluentui/react-nav");
