/**
 * AUTO-GENERATED FILE - DO NOT EDIT.
 * Generated from custom-elements manifest.
 */

import type React from 'react';
import type { AccordionItem as AccordionItemWC } from './accordion-item/accordion-item';
import type { Accordion as AccordionWC } from './accordion/accordion';
import type { ActionsMenu as ActionsMenuWC } from './actions-menu/actions-menu';
import type { AiCriteriaSearch as AiCriteriaSearchWC } from './ai-criteria-search/ai-criteria-search';
import type { AiIndicator as AiIndicatorWC } from './ai-indicator/ai-indicator';
import type { Anchor as AnchorWC } from './anchor/anchor';
import type { AnchoredRegion as AnchoredRegionWC } from './anchored-region/anchored-region';
import type { Avatar as AvatarWC } from './avatar/avatar';
import type { Badge as BadgeWC } from './badge/badge';
import type { Banner as BannerWC } from './banner/banner';
import type { BreadcrumbItem as BreadcrumbItemWC } from './breadcrumb-item/breadcrumb-item';
import type { Breadcrumb as BreadcrumbWC } from './breadcrumb/breadcrumb';
import type { Button as ButtonWC } from './button/button';
import type { Calendar as CalendarWC } from './calendar/calendar';
import type { Card as CardWC } from './card/card';
import type { CategorizedMultiselect as CategorizedMultiselectWC } from './categorized-multiselect/categorized-multiselect';
import type { Checkbox as CheckboxWC } from './checkbox/checkbox';
import type { Combobox as ComboboxWC } from './combobox/combobox';
import type { ConnectionIndicator as ConnectionIndicatorWC } from './connection-indicator/connection-indicator';
import type { DataGridCell as DataGridCellWC } from './data-grid-cell/data-grid.cell';
import type { DataGridRow as DataGridRowWC } from './data-grid-row/data-grid.row';
import type { DataGrid as DataGridWC } from './data-grid/data-grid';
import type { DatePicker as DatePickerWC } from './date-picker/date-picker';
import type { FoundationDesignSystemProvider as FoundationDesignSystemProviderWC } from './design-system-provider/design-system-provider';
import type { Dialog as DialogWC } from './dialog/dialog';
import type { Disclosure as DisclosureWC } from './disclosure/disclosure';
import type { Divider as DividerWC } from './divider/divider';
import type { DropdownMenu as DropdownMenuWC } from './dropdown-menu/dropdown-menu';
import type { EnvironmentIndicator as EnvironmentIndicatorWC } from './environment-indicator/environment-indicator';
import type { ErrorBanner as ErrorBannerWC } from './error-banner/error-banner';
import type { ErrorBoundary as ErrorBoundaryWC } from './error-boundary/error-boundary';
import type { ErrorDialog as ErrorDialogWC } from './error-dialog/error-dialog';
import type { FileReader as FileReaderWC } from './file-reader/file-reader';
import type { FileUpload as FileUploadWC } from './file-upload/file-upload';
import type { FilterBar as FilterBarWC } from './filter-bar/filter-bar';
import type { Filter as FilterWC } from './filter/filter';
import type { FlexLayout as FlexLayoutWC } from './flex-layout/flex-layout';
import type { Flipper as FlipperWC } from './flipper/flipper';
import type { Flyout as FlyoutWC } from './flyout/flyout';
import type { GridLayoutItem as GridLayoutItemWC } from './grid-layout-item/grid-layout-item';
import type { GridLayout as GridLayoutWC } from './grid-layout/grid-layout';
import type { HorizontalScroll as HorizontalScrollWC } from './horizontal-scroll/horizontal-scroll';
import type { Icon as IconWC } from './icon/icon';
import type { ListboxOption as ListboxOptionWC } from './listbox-option/listbox-option';
import type { Listbox as ListboxWC } from './listbox/listbox';
import type { MenuItem as MenuItemWC } from './menu-item/menu-item';
import type { Menu as MenuWC } from './menu/menu';
import type { Modal as ModalWC } from './modal/modal';
import type { Multiselect as MultiselectWC } from './multiselect/multiselect';
import type { NotificationListener as NotificationListenerWC } from './notification-listener/notification-listener';
import type { NumberField as NumberFieldWC } from './number-field/number-field';
import type { Optgroup as OptgroupWC } from './optgroup/optgroup';
import type { Popper as PopperWC } from './popper/popper';
import type { ProgressRing as ProgressRingWC } from './progress-ring/progress-ring';
import type { Progress as ProgressWC } from './progress/progress';
import type { RadioGroup as RadioGroupWC } from './radio-group/radio-group';
import type { Radio as RadioWC } from './radio/radio';
import type { SchedulerCronBuilder as SchedulerCronBuilderWC } from './scheduler-cron-builder/scheduler-cron-builder';
import type { SchedulerTimezone as SchedulerTimezoneWC } from './scheduler-timezone/scheduler-timezone';
import type { Scheduler as SchedulerWC } from './scheduler/scheduler';
import type { SearchBarCombobox as SearchBarComboboxWC } from './search-bar/search-bar-combobox';
import type { SearchBar as SearchBarWC } from './search-bar/search-bar';
import type { SectionNavigator as SectionNavigatorWC } from './section-navigator/section-navigator';
import type { SegmentedControl as SegmentedControlWC } from './segmented-control/segmented-control';
import type { SegmentedItem as SegmentedItemWC } from './segmented-item/segmented-item';
import type { Select as SelectWC } from './select/select';
import type { Skeleton as SkeletonWC } from './skeleton/skeleton';
import type { SliderLabel as SliderLabelWC } from './slider-label/slider-label';
import type { Slider as SliderWC } from './slider/slider';
import type { Snackbar as SnackbarWC } from './snackbar/snackbar';
import type { StackingIcons as StackingIconsWC } from './stacking-icons/stacking-icons';
import type { StatusPill as StatusPillWC } from './status-pill/status-pill';
import type { StepperTabPanel as StepperTabPanelWC } from './stepper-tab-panel/stepper-tab-panel';
import type { StepperTab as StepperTabWC } from './stepper-tab/stepper-tab';
import type { Stepper as StepperWC } from './stepper/stepper';
import type { Switch as SwitchWC } from './switch/switch';
import type { TabPanel as TabPanelWC } from './tab-panel/tab-panel';
import type { Tab as TabWC } from './tab/tab';
import type { Tabs as TabsWC } from './tabs/tabs';
import type { TextArea as TextAreaWC } from './text-area/text-area';
import type { TextField as TextFieldWC } from './text-field/text-field';
import type { Toast as ToastWC } from './toast/toast';
import type { Toolbar as ToolbarWC } from './toolbar/toolbar';
import type { Tooltip as TooltipWC } from './tooltip/tooltip';
import type { TreeView as TreeViewWC } from './tree-view/tree-view';
import type { UrlInput as UrlInputWC } from './url-input/url-input';

/** @internal Maps a web component class to its public props only.
 * keyof T skips private/protected members, so this avoids the TS error
 * "property may not be private or protected" on exported anonymous types. */
type PublicOf<T> = { [K in keyof T]?: T[K] };

/** @internal Safe React HTML attributes for web component wrappers.
 * onChange/onInput use method signatures for bivariant parameter checking so both
 * native Event and CustomEvent callbacks are accepted. */
interface HTMLWCProps extends React.AriaAttributes {
  className?: string; style?: React.CSSProperties; id?: string; slot?: string;
  tabIndex?: number; dir?: string; lang?: string; title?: string;
  onClick?: React.MouseEventHandler<HTMLElement>;
  onDoubleClick?: React.MouseEventHandler<HTMLElement>;
  onContextMenu?: React.MouseEventHandler<HTMLElement>;
  onMouseEnter?: React.MouseEventHandler<HTMLElement>;
  onMouseLeave?: React.MouseEventHandler<HTMLElement>;
  onMouseDown?: React.MouseEventHandler<HTMLElement>;
  onMouseUp?: React.MouseEventHandler<HTMLElement>;
  onMouseMove?: React.MouseEventHandler<HTMLElement>;
  onKeyDown?: React.KeyboardEventHandler<HTMLElement>;
  onKeyUp?: React.KeyboardEventHandler<HTMLElement>;
  onFocus?: React.FocusEventHandler<HTMLElement>;
  onBlur?: React.FocusEventHandler<HTMLElement>;
  onScroll?: React.UIEventHandler<HTMLElement>;
  onWheel?: React.WheelEventHandler<HTMLElement>;
  onChange?(e: Event): void;
  onInput?(e: Event): void;
}

export declare const AccordionItem: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<AccordionItemWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<AccordionItemWC>
>;
export type AccordionItemRef = AccordionItemWC;

export declare const Accordion: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<AccordionWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<AccordionWC>
>;
export type AccordionRef = AccordionWC;

export declare const ActionsMenu: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ActionsMenuWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ActionsMenuWC>
>;
export type ActionsMenuRef = ActionsMenuWC;

export declare const AiCriteriaSearch: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<AiCriteriaSearchWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onCriteriaChanged?: (event: CustomEvent<unknown>) => void;
      onValidationErrors?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<AiCriteriaSearchWC>
>;
export type AiCriteriaSearchRef = AiCriteriaSearchWC;

export declare const AiIndicator: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<AiIndicatorWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<AiIndicatorWC>
>;
export type AiIndicatorRef = AiIndicatorWC;

export declare const Anchor: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<AnchorWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<AnchorWC>
>;
export type AnchorRef = AnchorWC;

export declare const AnchoredRegion: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<AnchoredRegionWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onLoaded?: (event: CustomEvent<unknown>) => void;
      onPositionchange?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<AnchoredRegionWC>
>;
export type AnchoredRegionRef = AnchoredRegionWC;

export declare const Avatar: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<AvatarWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<AvatarWC>
>;
export type AvatarRef = AvatarWC;

export declare const Badge: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<BadgeWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<BadgeWC>
>;
export type BadgeRef = BadgeWC;

export declare const Banner: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<BannerWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<BannerWC>
>;
export type BannerRef = BannerWC;

export declare const Breadcrumb: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<BreadcrumbWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<BreadcrumbWC>
>;
export type BreadcrumbRef = BreadcrumbWC;

export declare const BreadcrumbItem: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<BreadcrumbItemWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<BreadcrumbItemWC>
>;
export type BreadcrumbItemRef = BreadcrumbItemWC;

export declare const Button: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ButtonWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ButtonWC>
>;
export type ButtonRef = ButtonWC;

export declare const Calendar: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<CalendarWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onDateselected?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<CalendarWC>
>;
export type CalendarRef = CalendarWC;

export declare const Card: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<CardWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<CardWC>
>;
export type CardRef = CardWC;

export declare const CategorizedMultiselect: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<CategorizedMultiselectWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onSelectionChange?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<CategorizedMultiselectWC>
>;
export type CategorizedMultiselectRef = CategorizedMultiselectWC;

export declare const Checkbox: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<CheckboxWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<CheckboxWC>
>;
export type CheckboxRef = CheckboxWC;

export declare const Combobox: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ComboboxWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ComboboxWC>
>;
export type ComboboxRef = ComboboxWC;

export declare const ConnectionIndicator: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ConnectionIndicatorWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ConnectionIndicatorWC>
>;
export type ConnectionIndicatorRef = ConnectionIndicatorWC;

export declare const DataGrid: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DataGridWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<DataGridWC>
>;
export type DataGridRef = DataGridWC;

export declare const DataGridCell: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DataGridCellWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onCellFocused?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<DataGridCellWC>
>;
export type DataGridCellRef = DataGridCellWC;

export declare const DataGridRow: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DataGridRowWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onRowFocused?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<DataGridRowWC>
>;
export type DataGridRowRef = DataGridRowWC;

export declare const DatePicker: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DatePickerWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onValueChanged?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<DatePickerWC>
>;
export type DatePickerRef = DatePickerWC;

export declare const FoundationDesignSystemProvider: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FoundationDesignSystemProviderWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<FoundationDesignSystemProviderWC>
>;
export type FoundationDesignSystemProviderRef = FoundationDesignSystemProviderWC;

export declare const Dialog: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DialogWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onClose?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<DialogWC>
>;
export type DialogRef = DialogWC;

export declare const Disclosure: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DisclosureWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<DisclosureWC>
>;
export type DisclosureRef = DisclosureWC;

export declare const Divider: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DividerWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<DividerWC>
>;
export type DividerRef = DividerWC;

export declare const DropdownMenu: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<DropdownMenuWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<DropdownMenuWC>
>;
export type DropdownMenuRef = DropdownMenuWC;

export declare const EnvironmentIndicator: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<EnvironmentIndicatorWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<EnvironmentIndicatorWC>
>;
export type EnvironmentIndicatorRef = EnvironmentIndicatorWC;

export declare const ErrorBanner: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ErrorBannerWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ErrorBannerWC>
>;
export type ErrorBannerRef = ErrorBannerWC;

export declare const ErrorBoundary: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ErrorBoundaryWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ErrorBoundaryWC>
>;
export type ErrorBoundaryRef = ErrorBoundaryWC;

export declare const ErrorDialog: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ErrorDialogWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ErrorDialogWC>
>;
export type ErrorDialogRef = ErrorDialogWC;

export declare const FileReader: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FileReaderWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onFileRead?: (event: CustomEvent<unknown>) => void;
      onClear?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<FileReaderWC>
>;
export type FileReaderRef = FileReaderWC;

export declare const FileUpload: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FileUploadWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onFileSelected?: (event: CustomEvent<unknown>) => void;
      onSuccess?: (event: CustomEvent<unknown>) => void;
      onErrorOut?: (event: CustomEvent<unknown>) => void;
      onClear?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<FileUploadWC>
>;
export type FileUploadRef = FileUploadWC;

export declare const Filter: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FilterWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onFilterChanged?: (event: CustomEvent<unknown>) => void;
      onFilterCleared?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<FilterWC>
>;
export type FilterRef = FilterWC;

export declare const FilterBar: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FilterBarWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<FilterBarWC>
>;
export type FilterBarRef = FilterBarWC;

export declare const FlexLayout: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FlexLayoutWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<FlexLayoutWC>
>;
export type FlexLayoutRef = FlexLayoutWC;

export declare const Flipper: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FlipperWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<FlipperWC>
>;
export type FlipperRef = FlipperWC;

export declare const Flyout: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<FlyoutWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onClosed?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<FlyoutWC>
>;
export type FlyoutRef = FlyoutWC;

export declare const GridLayout: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<GridLayoutWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<GridLayoutWC>
>;
export type GridLayoutRef = GridLayoutWC;

export declare const GridLayoutItem: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<GridLayoutItemWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<GridLayoutItemWC>
>;
export type GridLayoutItemRef = GridLayoutItemWC;

export declare const HorizontalScroll: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<HorizontalScrollWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onScrollstart?: (event: CustomEvent<unknown>) => void;
      onScrollend?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<HorizontalScrollWC>
>;
export type HorizontalScrollRef = HorizontalScrollWC;

export declare const Icon: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<IconWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<IconWC>
>;
export type IconRef = IconWC;

export declare const Listbox: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ListboxWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ListboxWC>
>;
export type ListboxRef = ListboxWC;

export declare const ListboxOption: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ListboxOptionWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ListboxOptionWC>
>;
export type ListboxOptionRef = ListboxOptionWC;

export declare const Menu: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<MenuWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<MenuWC>
>;
export type MenuRef = MenuWC;

export declare const MenuItem: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<MenuItemWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onOnMenuClick?: (event: CustomEvent<unknown>) => void;
      onExpandedChange?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<MenuItemWC>
>;
export type MenuItemRef = MenuItemWC;

export declare const Modal: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ModalWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ModalWC>
>;
export type ModalRef = ModalWC;

export declare const Multiselect: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<MultiselectWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onSelectionChange?: (event: CustomEvent<unknown>) => void;
      onClear?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<MultiselectWC>
>;
export type MultiselectRef = MultiselectWC;

export declare const NotificationListener: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<NotificationListenerWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<NotificationListenerWC>
>;
export type NotificationListenerRef = NotificationListenerWC;

export declare const NumberField: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<NumberFieldWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<NumberFieldWC>
>;
export type NumberFieldRef = NumberFieldWC;

export declare const Optgroup: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<OptgroupWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<OptgroupWC>
>;
export type OptgroupRef = OptgroupWC;

export declare const Popper: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<PopperWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<PopperWC>
>;
export type PopperRef = PopperWC;

export declare const Progress: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ProgressWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ProgressWC>
>;
export type ProgressRef = ProgressWC;

export declare const ProgressRing: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ProgressRingWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ProgressRingWC>
>;
export type ProgressRingRef = ProgressRingWC;

export declare const Radio: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<RadioWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<RadioWC>
>;
export type RadioRef = RadioWC;

export declare const RadioGroup: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<RadioGroupWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<RadioGroupWC>
>;
export type RadioGroupRef = RadioGroupWC;

export declare const Scheduler: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SchedulerWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SchedulerWC>
>;
export type SchedulerRef = SchedulerWC;

export declare const SchedulerCronBuilder: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SchedulerCronBuilderWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SchedulerCronBuilderWC>
>;
export type SchedulerCronBuilderRef = SchedulerCronBuilderWC;

export declare const SchedulerTimezone: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SchedulerTimezoneWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SchedulerTimezoneWC>
>;
export type SchedulerTimezoneRef = SchedulerTimezoneWC;

export declare const SearchBarCombobox: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SearchBarComboboxWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onInputdeleted?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<SearchBarComboboxWC>
>;
export type SearchBarComboboxRef = SearchBarComboboxWC;

export declare const SearchBar: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SearchBarWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onSelectionChange?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<SearchBarWC>
>;
export type SearchBarRef = SearchBarWC;

export declare const SectionNavigator: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SectionNavigatorWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onSectionNavigatorSetState?: (event: CustomEvent<unknown>) => void;
      onSectionNavigatorSetStates?: (event: CustomEvent<unknown>) => void;
      onSectionNavigatorClearState?: (event: CustomEvent<unknown>) => void;
      onSectionNavigatorClearAllStates?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<SectionNavigatorWC>
>;
export type SectionNavigatorRef = SectionNavigatorWC;

export declare const SegmentedControl: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SegmentedControlWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SegmentedControlWC>
>;
export type SegmentedControlRef = SegmentedControlWC;

export declare const SegmentedItem: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SegmentedItemWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SegmentedItemWC>
>;
export type SegmentedItemRef = SegmentedItemWC;

export declare const Select: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SelectWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SelectWC>
>;
export type SelectRef = SelectWC;

export declare const Skeleton: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SkeletonWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SkeletonWC>
>;
export type SkeletonRef = SkeletonWC;

export declare const Slider: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SliderWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SliderWC>
>;
export type SliderRef = SliderWC;

export declare const SliderLabel: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SliderLabelWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SliderLabelWC>
>;
export type SliderLabelRef = SliderLabelWC;

export declare const Snackbar: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SnackbarWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onAutoDismiss?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<SnackbarWC>
>;
export type SnackbarRef = SnackbarWC;

export declare const StackingIcons: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<StackingIconsWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<StackingIconsWC>
>;
export type StackingIconsRef = StackingIconsWC;

export declare const StatusPill: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<StatusPillWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<StatusPillWC>
>;
export type StatusPillRef = StatusPillWC;

export declare const Stepper: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<StepperWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onStepClick?: (event: CustomEvent<unknown>) => void;
      onValidationFailure?: (event: CustomEvent<unknown>) => void;
      onNextStep?: (event: CustomEvent<unknown>) => void;
      onValidationSuccess?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<StepperWC>
>;
export type StepperRef = StepperWC;

export declare const StepperTab: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<StepperTabWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onTabClicked?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<StepperTabWC>
>;
export type StepperTabRef = StepperTabWC;

export declare const StepperTabPanel: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<StepperTabPanelWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<StepperTabPanelWC>
>;
export type StepperTabPanelRef = StepperTabPanelWC;

export declare const Switch: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<SwitchWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<SwitchWC>
>;
export type SwitchRef = SwitchWC;

export declare const Tab: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<TabWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<TabWC>
>;
export type TabRef = TabWC;

export declare const TabPanel: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<TabPanelWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<TabPanelWC>
>;
export type TabPanelRef = TabPanelWC;

export declare const Tabs: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<TabsWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<TabsWC>
>;
export type TabsRef = TabsWC;

export declare const TextArea: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<TextAreaWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<TextAreaWC>
>;
export type TextAreaRef = TextAreaWC;

export declare const TextField: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<TextFieldWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<TextFieldWC>
>;
export type TextFieldRef = TextFieldWC;

export declare const Toast: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ToastWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ToastWC>
>;
export type ToastRef = ToastWC;

export declare const Toolbar: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<ToolbarWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<ToolbarWC>
>;
export type ToolbarRef = ToolbarWC;

export declare const Tooltip: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<TooltipWC>, 'children' | 'style'> &
    HTMLWCProps & {
      onDismiss?: (event: CustomEvent<unknown>) => void;
    }
  > & React.RefAttributes<TooltipWC>
>;
export type TooltipRef = TooltipWC;

export declare const TreeView: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<TreeViewWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<TreeViewWC>
>;
export type TreeViewRef = TreeViewWC;

export declare const UrlInput: React.ForwardRefExoticComponent<
  React.PropsWithChildren<
    Omit<PublicOf<UrlInputWC>, 'children' | 'style'> &
    HTMLWCProps & {
    }
  > & React.RefAttributes<UrlInputWC>
>;
export type UrlInputRef = UrlInputWC;

export {};