Types.tsx

/*************************************************************
THIS FILE WAS AUTOMATICALLY GENERATED, DO NOT MODIFY MANUALLY
SOURCE WINMDS USED:
  - %USERPROFILE%\.nuget\packages\microsoft.ui.xaml\2.8.0\lib\uap10.0\Microsoft.UI.Xaml.winmd
**************************************************************/

import type {
    // Controls
    NativeContentControlProps,
    NativeAppBarProps,
    NativeButtonProps,
    NativeAppBarButtonProps,
    NativeAppBarElementContainerProps,
    NativeAppBarSeparatorProps,
    NativeToggleButtonProps,
    NativeAppBarToggleButtonProps,
    NativeItemsControlProps,
    NativeAutoSuggestBoxProps,
    NativeBitmapIconProps,
    NativeBorderProps,
    NativeCalendarDatePickerProps,
    NativeCalendarViewProps,
    NativeCalendarViewDayItemProps,
    NativeCanvasProps,
    NativeCaptureElementProps,
    NativeCheckBoxProps,
    NativeColorPickerProps,
    NativeComboBoxProps,
    NativeComboBoxItemProps,
    NativeCommandBarProps,
    NativeCommandBarFlyoutProps,
    NativeCommandBarOverflowPresenterProps,
    NativeContentDialogProps,
    NativeContentPresenterProps,
    NativeDatePickerProps,
    NativeDatePickerFlyoutProps,
    NativeDropDownButtonProps,
    NativeFlipViewProps,
    NativeFlipViewItemProps,
    NativeFlyoutProps,
    NativeFlyoutPresenterProps,
    NativeFontIconProps,
    NativeFrameProps,
    NativeGridProps,
    NativeGridViewProps,
    NativeGridViewHeaderItemProps,
    NativeGridViewItemProps,
    NativeGroupItemProps,
    NativeHandwritingViewProps,
    NativeHubProps,
    NativeHubSectionProps,
    NativeHyperlinkButtonProps,
    NativeIconSourceElementProps,
    NativeImageProps,
    NativeInkCanvasProps,
    NativeInkToolbarProps,
    NativeRadioButtonProps,
    NativeInkToolbarBallpointPenButtonProps,
    NativeInkToolbarCustomPenButtonProps,
    NativeInkToolbarCustomToggleButtonProps,
    NativeInkToolbarCustomToolButtonProps,
    NativeInkToolbarEraserButtonProps,
    NativeInkToolbarFlyoutItemProps,
    NativeInkToolbarHighlighterButtonProps,
    NativeInkToolbarPenConfigurationControlProps,
    NativeInkToolbarPencilButtonProps,
    NativeInkToolbarRulerButtonProps,
    NativeInkToolbarStencilButtonProps,
    NativeItemsPresenterProps,
    NativeItemsStackPanelProps,
    NativeItemsWrapGridProps,
    NativeListBoxProps,
    NativeListBoxItemProps,
    NativeListPickerFlyoutProps,
    NativeListViewProps,
    NativeListViewHeaderItemProps,
    NativeListViewItemProps,
    NativeMapControlProps,
    NativeMediaElementProps,
    NativeMediaPlayerElementProps,
    NativeMediaPlayerPresenterProps,
    NativeMediaTransportControlsProps,
    NativeMenuBarProps,
    NativeMenuBarItemProps,
    NativeMenuFlyoutProps,
    NativeMenuBarItemFlyoutProps,
    NativeMenuFlyoutItemProps,
    NativeMenuFlyoutPresenterProps,
    NativeMenuFlyoutSeparatorProps,
    NativeMenuFlyoutSubItemProps,
    NativeNavigationViewProps,
    NativeNavigationViewItemProps,
    NativeNavigationViewItemHeaderProps,
    NativeNavigationViewItemSeparatorProps,
    NativeNavigationViewListProps,
    NativeUserControlProps,
    NativePageProps,
    NativeParallaxViewProps,
    NativePasswordBoxProps,
    NativePathIconProps,
    NativePersonPictureProps,
    NativePickerFlyoutProps,
    NativePivotProps,
    NativePivotItemProps,
    NativeCalendarPanelProps,
    NativeCarouselPanelProps,
    NativeSliderProps,
    NativeColorPickerSliderProps,
    NativeColorSpectrumProps,
    NativeCommandBarFlyoutCommandBarProps,
    NativeGridViewItemPresenterProps,
    NativeListViewItemPresenterProps,
    NativeNavigationViewItemPresenterProps,
    NativePivotHeaderItemProps,
    NativePivotHeaderPanelProps,
    NativePivotPanelProps,
    NativePopupProps,
    NativeRepeatButtonProps,
    NativeScrollBarProps,
    NativeThumbProps,
    NativeTickBarProps,
    NativeProgressBarProps,
    NativeProgressRingProps,
    NativeRatingControlProps,
    NativeRefreshContainerProps,
    NativeRefreshVisualizerProps,
    NativeRelativePanelProps,
    NativeRichEditBoxProps,
    NativeRichTextBlockProps,
    NativeRichTextBlockOverflowProps,
    NativeScrollContentPresenterProps,
    NativeScrollViewerProps,
    NativeSearchBoxProps,
    NativeSemanticZoomProps,
    NativeSettingsFlyoutProps,
    NativeSplitButtonProps,
    NativeSplitViewProps,
    NativeStackPanelProps,
    NativeSwapChainBackgroundPanelProps,
    NativeSwapChainPanelProps,
    NativeSwipeControlProps,
    NativeSymbolIconProps,
    NativeTextBlockProps,
    NativeTextBoxProps,
    NativeTextCommandBarFlyoutProps,
    NativeTimePickerProps,
    NativeTimePickerFlyoutProps,
    NativeToggleMenuFlyoutItemProps,
    NativeToggleSplitButtonProps,
    NativeToggleSwitchProps,
    NativeToolTipProps,
    NativeTreeViewProps,
    NativeTreeViewItemProps,
    NativeTreeViewListProps,
    NativeTwoPaneViewProps,
    NativeVariableSizedWrapGridProps,
    NativeViewboxProps,
    NativeVirtualizingStackPanelProps,
    NativeWebViewProps,
    NativeWrapGridProps,
    NativeSpanProps,
    NativeBoldProps,
    NativeContentLinkProps,
    NativeGlyphsProps,
    NativeHyperlinkProps,
    NativeInlineUIContainerProps,
    NativeItalicProps,
    NativeLineBreakProps,
    NativeParagraphProps,
    NativeRunProps,
    NativeUnderlineProps,
    NativeKeyboardAcceleratorProps,
    NativeEllipseProps,
    NativeLineProps,
    NativePathProps,
    NativePolygonProps,
    NativePolylineProps,
    NativeRectangleProps,

    // EventArgs
    NativeSelectionChangedEventArgs,
    NativeIVectorChangedEventArgs,
    NativeDragEventArgs,
    NativeDoubleTappedRoutedEventArgs,
    NativeRoutedEventArgs,
    NativeHoldingRoutedEventArgs,
    NativeManipulationCompletedRoutedEventArgs,
    NativeManipulationDeltaRoutedEventArgs,
    NativeManipulationInertiaStartingRoutedEventArgs,
    NativeManipulationStartedRoutedEventArgs,
    NativeManipulationStartingRoutedEventArgs,
    NativePointerRoutedEventArgs,
    NativeRightTappedRoutedEventArgs,
    NativeTappedRoutedEventArgs,
    NativeDragStartingEventArgs,
    NativeDropCompletedEventArgs,
    NativeAccessKeyDisplayDismissedEventArgs,
    NativeAccessKeyDisplayRequestedEventArgs,
    NativeAccessKeyInvokedEventArgs,
    NativeContextRequestedEventArgs,
    NativeGettingFocusEventArgs,
    NativeLosingFocusEventArgs,
    NativeNoFocusCandidateFoundEventArgs,
    NativeCharacterReceivedRoutedEventArgs,
    NativeKeyRoutedEventArgs,
    NativeProcessKeyboardAcceleratorEventArgs,
    NativeBringIntoViewRequestedEventArgs,
    NativeSizeChangedEventArgs,
    NativeDataContextChangedEventArgs,
    NativeEffectiveViewportChangedEventArgs,
    NativeDependencyPropertyChangedEventArgs,
    NativeFocusDisengagedEventArgs,
    NativeFocusEngagedEventArgs,
    NativeAutoSuggestBoxSuggestionChosenEventArgs,
    NativeAutoSuggestBoxTextChangedEventArgs,
    NativeAutoSuggestBoxQuerySubmittedEventArgs,
    NativeCalendarViewDayItemChangingEventArgs,
    NativeCalendarDatePickerDateChangedEventArgs,
    NativeCalendarViewSelectedDatesChangedEventArgs,
    NativeColorChangedEventArgs,
    NativeComboBoxTextSubmittedEventArgs,
    NativeDynamicOverflowItemsChangingEventArgs,
    NativeFlyoutBaseClosingEventArgs,
    NativeContentDialogClosedEventArgs,
    NativeContentDialogClosingEventArgs,
    NativeContentDialogOpenedEventArgs,
    NativeContentDialogButtonClickEventArgs,
    NativeDatePickerValueChangedEventArgs,
    NativeDatePickerSelectedValueChangedEventArgs,
    NativeDatePickedEventArgs,
    NativeNavigationEventArgs,
    NativeNavigatingCancelEventArgs,
    NativeNavigationFailedEventArgs,
    NativeDragItemsStartingEventArgs,
    NativeItemClickEventArgs,
    NativeContainerContentChangingEventArgs,
    NativeChoosingGroupHeaderContainerEventArgs,
    NativeChoosingItemContainerEventArgs,
    NativeDragItemsCompletedEventArgs,
    NativeHandwritingPanelClosedEventArgs,
    NativeHandwritingPanelOpenedEventArgs,
    NativeHubSectionHeaderClickEventArgs,
    NativeSectionsInViewChangedEventArgs,
    NativeExceptionRoutedEventArgs,
    NativeInkToolbarIsStencilButtonCheckedChangedEventArgs,
    NativeItemsPickedEventArgs,
    NativeMapInputEventArgs,
    NativeMapActualCameraChangedEventArgs,
    NativeMapActualCameraChangingEventArgs,
    NativeMapCustomExperienceChangedEventArgs,
    NativeMapElementClickEventArgs,
    NativeMapElementPointerEnteredEventArgs,
    NativeMapElementPointerExitedEventArgs,
    NativeMapTargetCameraChangedEventArgs,
    NativeMapRightTappedEventArgs,
    NativeMapContextRequestedEventArgs,
    NativeTimelineMarkerRoutedEventArgs,
    NativeRateChangedRoutedEventArgs,
    NativePartialMediaFailureDetectedEventArgs,
    NativeMediaTransportControlsThumbnailRequestedEventArgs,
    NativeNavigationViewDisplayModeChangedEventArgs,
    NativeNavigationViewItemInvokedEventArgs,
    NativeNavigationViewSelectionChangedEventArgs,
    NativeNavigationViewBackRequestedEventArgs,
    NativeNavigationViewPaneClosingEventArgs,
    NativeContextMenuEventArgs,
    NativeTextControlPasteEventArgs,
    NativePasswordBoxPasswordChangingEventArgs,
    NativePickerConfirmedEventArgs,
    NativePivotItemEventArgs,
    NativeRangeBaseValueChangedEventArgs,
    NativeScrollEventArgs,
    NativeDragCompletedEventArgs,
    NativeDragDeltaEventArgs,
    NativeDragStartedEventArgs,
    NativeRefreshRequestedEventArgs,
    NativeRefreshStateChangedEventArgs,
    NativeCandidateWindowBoundsChangedEventArgs,
    NativeRichEditBoxTextChangingEventArgs,
    NativeTextCompositionChangedEventArgs,
    NativeTextCompositionEndedEventArgs,
    NativeTextCompositionStartedEventArgs,
    NativeTextControlCopyingToClipboardEventArgs,
    NativeTextControlCuttingToClipboardEventArgs,
    NativeContentLinkChangedEventArgs,
    NativeContentLinkInvokedEventArgs,
    NativeRichEditBoxSelectionChangingEventArgs,
    NativeIsTextTrimmedChangedEventArgs,
    NativeScrollViewerViewChangedEventArgs,
    NativeScrollViewerViewChangingEventArgs,
    NativeAnchorRequestedEventArgs,
    NativeSearchBoxQueryChangedEventArgs,
    NativeSearchBoxQuerySubmittedEventArgs,
    NativeSearchBoxResultSuggestionChosenEventArgs,
    NativeSearchBoxSuggestionsRequestedEventArgs,
    NativeSemanticZoomViewChangedEventArgs,
    NativeBackClickEventArgs,
    NativeSplitButtonClickEventArgs,
    NativeSplitViewPaneClosingEventArgs,
    NativeTextChangedEventArgs,
    NativeTextBoxTextChangingEventArgs,
    NativeTextBoxBeforeTextChangingEventArgs,
    NativeTextBoxSelectionChangingEventArgs,
    NativeTimePickerValueChangedEventArgs,
    NativeTimePickerSelectedValueChangedEventArgs,
    NativeTimePickedEventArgs,
    NativeToggleSplitButtonIsCheckedChangedEventArgs,
    NativeTreeViewCollapsedEventArgs,
    NativeTreeViewExpandingEventArgs,
    NativeTreeViewItemInvokedEventArgs,
    NativeTreeViewDragItemsCompletedEventArgs,
    NativeTreeViewDragItemsStartingEventArgs,
    NativeCleanUpVirtualizedItemEventArgs,
    NativeWebViewNavigationFailedEventArgs,
    NativeNotifyEventArgs,
    NativeWebViewContentLoadingEventArgs,
    NativeWebViewDOMContentLoadedEventArgs,
    NativeWebViewNavigationCompletedEventArgs,
    NativeWebViewNavigationStartingEventArgs,
    NativeWebViewLongRunningScriptDetectedEventArgs,
    NativeWebViewUnviewableContentIdentifiedEventArgs,
    NativeWebViewNewWindowRequestedEventArgs,
    NativeWebViewPermissionRequestedEventArgs,
    NativeWebViewUnsupportedUriSchemeIdentifiedEventArgs,
    NativeWebViewSeparateProcessLostEventArgs,
    NativeWebViewWebResourceRequestedEventArgs,
    NativeHyperlinkClickEventArgs,
    NativeKeyboardAcceleratorInvokedEventArgs,
} from './Props';

import type { NativeWinUI } from './Props';
import type { NativeWebView2 } from './Props';

import React, { ForwardRefExoticComponent, RefAttributes } from 'react';
import { NativeXamlControl } from './NativeXamlControl';
import { findNodeHandle, NativeMethods, UIManager } from 'react-native';

import type { Point, Color } from './Props';

export type { Point, Color };

export namespace WinUI {
export type AnimatedIconProps = Omit<NativeWinUI.NativeAnimatedIconProps, 'type'>;
export type AnimatedIconRef = React.Component<NativeWinUI.NativeAnimatedIconProps> & Readonly<NativeMethods>;
const _AnimatedIcon : (ForwardRefExoticComponent<React.PropsWithChildren<AnimatedIconProps> & RefAttributes<AnimatedIconRef>>) = React.forwardRef((props: React.PropsWithChildren<AnimatedIconProps>, ref: React.ForwardedRef<AnimatedIconRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.AnimatedIcon' ref={ref} />);
export const AnimatedIcon = (_AnimatedIcon as (ForwardRefExoticComponent<React.PropsWithChildren<AnimatedIconProps> & RefAttributes<AnimatedIconRef>>));

}
export namespace WinUI {
export type AnimatedVisualPlayerProps = Omit<NativeWinUI.NativeAnimatedVisualPlayerProps, 'type'>;
export type AnimatedVisualPlayerRef = React.Component<NativeWinUI.NativeAnimatedVisualPlayerProps> & Readonly<NativeMethods>;
const _AnimatedVisualPlayer : (ForwardRefExoticComponent<React.PropsWithChildren<AnimatedVisualPlayerProps> & RefAttributes<AnimatedVisualPlayerRef>>) = React.forwardRef((props: React.PropsWithChildren<AnimatedVisualPlayerProps>, ref: React.ForwardedRef<AnimatedVisualPlayerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer' ref={ref} />);
export const AnimatedVisualPlayer = (_AnimatedVisualPlayer as (ForwardRefExoticComponent<React.PropsWithChildren<AnimatedVisualPlayerProps> & RefAttributes<AnimatedVisualPlayerRef>>));

}
export namespace WinUI {
export type BreadcrumbBarProps = Omit<NativeWinUI.NativeBreadcrumbBarProps, 'type'>;
export type BreadcrumbBarRef = React.Component<NativeWinUI.NativeBreadcrumbBarProps> & Readonly<NativeMethods>;
const _BreadcrumbBar : (ForwardRefExoticComponent<React.PropsWithChildren<BreadcrumbBarProps> & RefAttributes<BreadcrumbBarRef>>) = React.forwardRef((props: React.PropsWithChildren<BreadcrumbBarProps>, ref: React.ForwardedRef<BreadcrumbBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.BreadcrumbBar' ref={ref} />);
export const BreadcrumbBar = (_BreadcrumbBar as (ForwardRefExoticComponent<React.PropsWithChildren<BreadcrumbBarProps> & RefAttributes<BreadcrumbBarRef>>));

}
export namespace WinUI {
export type BreadcrumbBarItemProps = Omit<NativeWinUI.NativeBreadcrumbBarItemProps, 'type'>;
export type BreadcrumbBarItemRef = React.Component<NativeWinUI.NativeBreadcrumbBarItemProps> & Readonly<NativeMethods>;
const _BreadcrumbBarItem : (ForwardRefExoticComponent<React.PropsWithChildren<BreadcrumbBarItemProps> & RefAttributes<BreadcrumbBarItemRef>>) = React.forwardRef((props: React.PropsWithChildren<BreadcrumbBarItemProps>, ref: React.ForwardedRef<BreadcrumbBarItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.BreadcrumbBarItem' ref={ref} />);
export const BreadcrumbBarItem = (_BreadcrumbBarItem as (ForwardRefExoticComponent<React.PropsWithChildren<BreadcrumbBarItemProps> & RefAttributes<BreadcrumbBarItemRef>>));

}
export namespace WinUI {
export type ColorPickerProps = Omit<NativeWinUI.NativeColorPickerProps, 'type'>;
export type ColorPickerRef = React.Component<NativeWinUI.NativeColorPickerProps> & Readonly<NativeMethods>;
const _ColorPicker : (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerProps> & RefAttributes<ColorPickerRef>>) = React.forwardRef((props: React.PropsWithChildren<ColorPickerProps>, ref: React.ForwardedRef<ColorPickerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ColorPicker' ref={ref} />);
export const ColorPicker = (_ColorPicker as (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerProps> & RefAttributes<ColorPickerRef>>));

}
export namespace WinUI {
export type CommandBarFlyoutProps = Omit<NativeWinUI.NativeCommandBarFlyoutProps, 'type'>;
export type CommandBarFlyoutRef = React.Component<NativeWinUI.NativeCommandBarFlyoutProps> & Readonly<NativeMethods>;
const _CommandBarFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutProps> & RefAttributes<CommandBarFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<CommandBarFlyoutProps>, ref: React.ForwardedRef<CommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.CommandBarFlyout' ref={ref} />);
export const CommandBarFlyout = (_CommandBarFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutProps> & RefAttributes<CommandBarFlyoutRef>>));

}
export namespace WinUI {
export type DropDownButtonProps = Omit<NativeWinUI.NativeDropDownButtonProps, 'type'>;
export type DropDownButtonRef = React.Component<NativeWinUI.NativeDropDownButtonProps> & Readonly<NativeMethods>;
const _DropDownButton : (ForwardRefExoticComponent<React.PropsWithChildren<DropDownButtonProps> & RefAttributes<DropDownButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<DropDownButtonProps>, ref: React.ForwardedRef<DropDownButtonRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.DropDownButton' ref={ref} />);
export const DropDownButton = (_DropDownButton as (ForwardRefExoticComponent<React.PropsWithChildren<DropDownButtonProps> & RefAttributes<DropDownButtonRef>>));

}
export namespace WinUI {
export type ExpanderProps = Omit<NativeWinUI.NativeExpanderProps, 'type'>;
export type ExpanderRef = React.Component<NativeWinUI.NativeExpanderProps> & Readonly<NativeMethods>;
const _Expander : (ForwardRefExoticComponent<React.PropsWithChildren<ExpanderProps> & RefAttributes<ExpanderRef>>) = React.forwardRef((props: React.PropsWithChildren<ExpanderProps>, ref: React.ForwardedRef<ExpanderRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Expander' ref={ref} />);
export const Expander = (_Expander as (ForwardRefExoticComponent<React.PropsWithChildren<ExpanderProps> & RefAttributes<ExpanderRef>>));

}
export namespace WinUI {
export type ImageIconProps = Omit<NativeWinUI.NativeImageIconProps, 'type'>;
export type ImageIconRef = React.Component<NativeWinUI.NativeImageIconProps> & Readonly<NativeMethods>;
const _ImageIcon : (ForwardRefExoticComponent<React.PropsWithChildren<ImageIconProps> & RefAttributes<ImageIconRef>>) = React.forwardRef((props: React.PropsWithChildren<ImageIconProps>, ref: React.ForwardedRef<ImageIconRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ImageIcon' ref={ref} />);
export const ImageIcon = (_ImageIcon as (ForwardRefExoticComponent<React.PropsWithChildren<ImageIconProps> & RefAttributes<ImageIconRef>>));

}
export namespace WinUI {
export type InfoBadgeProps = Omit<NativeWinUI.NativeInfoBadgeProps, 'type'>;
export type InfoBadgeRef = React.Component<NativeWinUI.NativeInfoBadgeProps> & Readonly<NativeMethods>;
const _InfoBadge : (ForwardRefExoticComponent<React.PropsWithChildren<InfoBadgeProps> & RefAttributes<InfoBadgeRef>>) = React.forwardRef((props: React.PropsWithChildren<InfoBadgeProps>, ref: React.ForwardedRef<InfoBadgeRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.InfoBadge' ref={ref} />);
export const InfoBadge = (_InfoBadge as (ForwardRefExoticComponent<React.PropsWithChildren<InfoBadgeProps> & RefAttributes<InfoBadgeRef>>));

}
export namespace WinUI {
export type InfoBarProps = Omit<NativeWinUI.NativeInfoBarProps, 'type'>;
export type InfoBarRef = React.Component<NativeWinUI.NativeInfoBarProps> & Readonly<NativeMethods>;
const _InfoBar : (ForwardRefExoticComponent<React.PropsWithChildren<InfoBarProps> & RefAttributes<InfoBarRef>>) = React.forwardRef((props: React.PropsWithChildren<InfoBarProps>, ref: React.ForwardedRef<InfoBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.InfoBar' ref={ref} />);
export const InfoBar = (_InfoBar as (ForwardRefExoticComponent<React.PropsWithChildren<InfoBarProps> & RefAttributes<InfoBarRef>>));

}
export namespace WinUI {
export type ItemsRepeaterProps = Omit<NativeWinUI.NativeItemsRepeaterProps, 'type'>;
export type ItemsRepeaterRef = React.Component<NativeWinUI.NativeItemsRepeaterProps> & Readonly<NativeMethods>;
const _ItemsRepeater : (ForwardRefExoticComponent<React.PropsWithChildren<ItemsRepeaterProps> & RefAttributes<ItemsRepeaterRef>>) = React.forwardRef((props: React.PropsWithChildren<ItemsRepeaterProps>, ref: React.ForwardedRef<ItemsRepeaterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ItemsRepeater' ref={ref} />);
export const ItemsRepeater = (_ItemsRepeater as (ForwardRefExoticComponent<React.PropsWithChildren<ItemsRepeaterProps> & RefAttributes<ItemsRepeaterRef>>));

}
export namespace WinUI {
export type ItemsRepeaterScrollHostProps = Omit<NativeWinUI.NativeItemsRepeaterScrollHostProps, 'type'>;
export type ItemsRepeaterScrollHostRef = React.Component<NativeWinUI.NativeItemsRepeaterScrollHostProps> & Readonly<NativeMethods>;
const _ItemsRepeaterScrollHost : (ForwardRefExoticComponent<React.PropsWithChildren<ItemsRepeaterScrollHostProps> & RefAttributes<ItemsRepeaterScrollHostRef>>) = React.forwardRef((props: React.PropsWithChildren<ItemsRepeaterScrollHostProps>, ref: React.ForwardedRef<ItemsRepeaterScrollHostRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost' ref={ref} />);
export const ItemsRepeaterScrollHost = (_ItemsRepeaterScrollHost as (ForwardRefExoticComponent<React.PropsWithChildren<ItemsRepeaterScrollHostProps> & RefAttributes<ItemsRepeaterScrollHostRef>>));

}
export namespace WinUI {
export type MenuBarProps = Omit<NativeWinUI.NativeMenuBarProps, 'type'>;
export type MenuBarRef = React.Component<NativeWinUI.NativeMenuBarProps> & Readonly<NativeMethods>;
const _MenuBar : (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarProps> & RefAttributes<MenuBarRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuBarProps>, ref: React.ForwardedRef<MenuBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBar' ref={ref} />);
export const MenuBar = (_MenuBar as (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarProps> & RefAttributes<MenuBarRef>>));

}
export namespace WinUI {
export type MenuBarItemProps = Omit<NativeWinUI.NativeMenuBarItemProps, 'type'>;
export type MenuBarItemRef = React.Component<NativeWinUI.NativeMenuBarItemProps> & Readonly<NativeMethods>;
const _MenuBarItem : (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemProps> & RefAttributes<MenuBarItemRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuBarItemProps>, ref: React.ForwardedRef<MenuBarItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBarItem' ref={ref} />);
export const MenuBarItem = (_MenuBarItem as (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemProps> & RefAttributes<MenuBarItemRef>>));

}
export namespace WinUI {
export type MenuBarItemFlyoutProps = Omit<NativeWinUI.NativeMenuBarItemFlyoutProps, 'type'>;
export type MenuBarItemFlyoutRef = React.Component<NativeWinUI.NativeMenuBarItemFlyoutProps> & Readonly<NativeMethods>;
const _MenuBarItemFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemFlyoutProps> & RefAttributes<MenuBarItemFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuBarItemFlyoutProps>, ref: React.ForwardedRef<MenuBarItemFlyoutRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBarItemFlyout' ref={ref} />);
export const MenuBarItemFlyout = (_MenuBarItemFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemFlyoutProps> & RefAttributes<MenuBarItemFlyoutRef>>));

}
export namespace WinUI {
export type NavigationViewProps = Omit<NativeWinUI.NativeNavigationViewProps, 'type'>;
export type NavigationViewRef = React.Component<NativeWinUI.NativeNavigationViewProps> & Readonly<NativeMethods>;
const _NavigationView : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewProps> & RefAttributes<NavigationViewRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewProps>, ref: React.ForwardedRef<NavigationViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationView' ref={ref} />);
export const NavigationView = (_NavigationView as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewProps> & RefAttributes<NavigationViewRef>>));

}
export namespace WinUI {
export type NavigationViewItemProps = Omit<NativeWinUI.NativeNavigationViewItemProps, 'type'>;
export type NavigationViewItemRef = React.Component<NativeWinUI.NativeNavigationViewItemProps> & Readonly<NativeMethods>;
const _NavigationViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemProps> & RefAttributes<NavigationViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemProps>, ref: React.ForwardedRef<NavigationViewItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItem' ref={ref} />);
export const NavigationViewItem = (_NavigationViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemProps> & RefAttributes<NavigationViewItemRef>>));

}
export namespace WinUI {
export type NavigationViewItemHeaderProps = Omit<NativeWinUI.NativeNavigationViewItemHeaderProps, 'type'>;
export type NavigationViewItemHeaderRef = React.Component<NativeWinUI.NativeNavigationViewItemHeaderProps> & Readonly<NativeMethods>;
const _NavigationViewItemHeader : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemHeaderProps> & RefAttributes<NavigationViewItemHeaderRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemHeaderProps>, ref: React.ForwardedRef<NavigationViewItemHeaderRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItemHeader' ref={ref} />);
export const NavigationViewItemHeader = (_NavigationViewItemHeader as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemHeaderProps> & RefAttributes<NavigationViewItemHeaderRef>>));

}
export namespace WinUI {
export type NavigationViewItemSeparatorProps = Omit<NativeWinUI.NativeNavigationViewItemSeparatorProps, 'type'>;
export type NavigationViewItemSeparatorRef = React.Component<NativeWinUI.NativeNavigationViewItemSeparatorProps> & Readonly<NativeMethods>;
const _NavigationViewItemSeparator : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemSeparatorProps> & RefAttributes<NavigationViewItemSeparatorRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemSeparatorProps>, ref: React.ForwardedRef<NavigationViewItemSeparatorRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItemSeparator' ref={ref} />);
export const NavigationViewItemSeparator = (_NavigationViewItemSeparator as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemSeparatorProps> & RefAttributes<NavigationViewItemSeparatorRef>>));

}
export namespace WinUI {
export type NumberBoxProps = Omit<NativeWinUI.NativeNumberBoxProps, 'type'>;
export type NumberBoxRef = React.Component<NativeWinUI.NativeNumberBoxProps> & Readonly<NativeMethods>;
const _NumberBox : (ForwardRefExoticComponent<React.PropsWithChildren<NumberBoxProps> & RefAttributes<NumberBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<NumberBoxProps>, ref: React.ForwardedRef<NumberBoxRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NumberBox' ref={ref} />);
export const NumberBox = (_NumberBox as (ForwardRefExoticComponent<React.PropsWithChildren<NumberBoxProps> & RefAttributes<NumberBoxRef>>));

}
export namespace WinUI {
export type ParallaxViewProps = Omit<NativeWinUI.NativeParallaxViewProps, 'type'>;
export type ParallaxViewRef = React.Component<NativeWinUI.NativeParallaxViewProps> & Readonly<NativeMethods>;
const _ParallaxView : (ForwardRefExoticComponent<React.PropsWithChildren<ParallaxViewProps> & RefAttributes<ParallaxViewRef>>) = React.forwardRef((props: React.PropsWithChildren<ParallaxViewProps>, ref: React.ForwardedRef<ParallaxViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ParallaxView' ref={ref} />);
export const ParallaxView = (_ParallaxView as (ForwardRefExoticComponent<React.PropsWithChildren<ParallaxViewProps> & RefAttributes<ParallaxViewRef>>));

}
export namespace WinUI {
export type PersonPictureProps = Omit<NativeWinUI.NativePersonPictureProps, 'type'>;
export type PersonPictureRef = React.Component<NativeWinUI.NativePersonPictureProps> & Readonly<NativeMethods>;
const _PersonPicture : (ForwardRefExoticComponent<React.PropsWithChildren<PersonPictureProps> & RefAttributes<PersonPictureRef>>) = React.forwardRef((props: React.PropsWithChildren<PersonPictureProps>, ref: React.ForwardedRef<PersonPictureRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.PersonPicture' ref={ref} />);
export const PersonPicture = (_PersonPicture as (ForwardRefExoticComponent<React.PropsWithChildren<PersonPictureProps> & RefAttributes<PersonPictureRef>>));

}
export namespace WinUI {
export type PipsPagerProps = Omit<NativeWinUI.NativePipsPagerProps, 'type'>;
export type PipsPagerRef = React.Component<NativeWinUI.NativePipsPagerProps> & Readonly<NativeMethods>;
const _PipsPager : (ForwardRefExoticComponent<React.PropsWithChildren<PipsPagerProps> & RefAttributes<PipsPagerRef>>) = React.forwardRef((props: React.PropsWithChildren<PipsPagerProps>, ref: React.ForwardedRef<PipsPagerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.PipsPager' ref={ref} />);
export const PipsPager = (_PipsPager as (ForwardRefExoticComponent<React.PropsWithChildren<PipsPagerProps> & RefAttributes<PipsPagerRef>>));

}
export namespace WinUI {
export type ColorPickerSliderProps = Omit<NativeWinUI.NativeColorPickerSliderProps, 'type'>;
export type ColorPickerSliderRef = React.Component<NativeWinUI.NativeColorPickerSliderProps> & Readonly<NativeMethods>;
const _ColorPickerSlider : (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerSliderProps> & RefAttributes<ColorPickerSliderRef>>) = React.forwardRef((props: React.PropsWithChildren<ColorPickerSliderProps>, ref: React.ForwardedRef<ColorPickerSliderRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.ColorPickerSlider' ref={ref} />);
export const ColorPickerSlider = (_ColorPickerSlider as (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerSliderProps> & RefAttributes<ColorPickerSliderRef>>));

}
export namespace WinUI {
export type ColorSpectrumProps = Omit<NativeWinUI.NativeColorSpectrumProps, 'type'>;
export type ColorSpectrumRef = React.Component<NativeWinUI.NativeColorSpectrumProps> & Readonly<NativeMethods>;
const _ColorSpectrum : (ForwardRefExoticComponent<React.PropsWithChildren<ColorSpectrumProps> & RefAttributes<ColorSpectrumRef>>) = React.forwardRef((props: React.PropsWithChildren<ColorSpectrumProps>, ref: React.ForwardedRef<ColorSpectrumRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.ColorSpectrum' ref={ref} />);
export const ColorSpectrum = (_ColorSpectrum as (ForwardRefExoticComponent<React.PropsWithChildren<ColorSpectrumProps> & RefAttributes<ColorSpectrumRef>>));

}
export namespace WinUI {
export type CommandBarFlyoutCommandBarProps = Omit<NativeWinUI.NativeCommandBarFlyoutCommandBarProps, 'type'>;
export type CommandBarFlyoutCommandBarRef = React.Component<NativeWinUI.NativeCommandBarFlyoutCommandBarProps> & Readonly<NativeMethods>;
const _CommandBarFlyoutCommandBar : (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutCommandBarProps> & RefAttributes<CommandBarFlyoutCommandBarRef>>) = React.forwardRef((props: React.PropsWithChildren<CommandBarFlyoutCommandBarProps>, ref: React.ForwardedRef<CommandBarFlyoutCommandBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBar' ref={ref} />);
export const CommandBarFlyoutCommandBar = (_CommandBarFlyoutCommandBar as (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutCommandBarProps> & RefAttributes<CommandBarFlyoutCommandBarRef>>));

}
export namespace WinUI {
export type InfoBarPanelProps = Omit<NativeWinUI.NativeInfoBarPanelProps, 'type'>;
export type InfoBarPanelRef = React.Component<NativeWinUI.NativeInfoBarPanelProps> & Readonly<NativeMethods>;
const _InfoBarPanel : (ForwardRefExoticComponent<React.PropsWithChildren<InfoBarPanelProps> & RefAttributes<InfoBarPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<InfoBarPanelProps>, ref: React.ForwardedRef<InfoBarPanelRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.InfoBarPanel' ref={ref} />);
export const InfoBarPanel = (_InfoBarPanel as (ForwardRefExoticComponent<React.PropsWithChildren<InfoBarPanelProps> & RefAttributes<InfoBarPanelRef>>));

}
export namespace WinUI {
export type MonochromaticOverlayPresenterProps = Omit<NativeWinUI.NativeMonochromaticOverlayPresenterProps, 'type'>;
export type MonochromaticOverlayPresenterRef = React.Component<NativeWinUI.NativeMonochromaticOverlayPresenterProps> & Readonly<NativeMethods>;
const _MonochromaticOverlayPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<MonochromaticOverlayPresenterProps> & RefAttributes<MonochromaticOverlayPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<MonochromaticOverlayPresenterProps>, ref: React.ForwardedRef<MonochromaticOverlayPresenterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.MonochromaticOverlayPresenter' ref={ref} />);
export const MonochromaticOverlayPresenter = (_MonochromaticOverlayPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<MonochromaticOverlayPresenterProps> & RefAttributes<MonochromaticOverlayPresenterRef>>));

}
export namespace WinUI {
export type NavigationViewItemPresenterProps = Omit<NativeWinUI.NativeNavigationViewItemPresenterProps, 'type'>;
export type NavigationViewItemPresenterRef = React.Component<NativeWinUI.NativeNavigationViewItemPresenterProps> & Readonly<NativeMethods>;
const _NavigationViewItemPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemPresenterProps> & RefAttributes<NavigationViewItemPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemPresenterProps>, ref: React.ForwardedRef<NavigationViewItemPresenterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.NavigationViewItemPresenter' ref={ref} />);
export const NavigationViewItemPresenter = (_NavigationViewItemPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemPresenterProps> & RefAttributes<NavigationViewItemPresenterRef>>));

}
export namespace WinUI {
export type TabViewListViewProps = Omit<NativeWinUI.NativeTabViewListViewProps, 'type'>;
export type TabViewListViewRef = React.Component<NativeWinUI.NativeTabViewListViewProps> & Readonly<NativeMethods>;
const _TabViewListView : (ForwardRefExoticComponent<React.PropsWithChildren<TabViewListViewProps> & RefAttributes<TabViewListViewRef>>) = React.forwardRef((props: React.PropsWithChildren<TabViewListViewProps>, ref: React.ForwardedRef<TabViewListViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.TabViewListView' ref={ref} />);
export const TabViewListView = (_TabViewListView as (ForwardRefExoticComponent<React.PropsWithChildren<TabViewListViewProps> & RefAttributes<TabViewListViewRef>>));

}
export namespace WinUI {
export type ProgressBarProps = Omit<NativeWinUI.NativeProgressBarProps, 'type'>;
export type ProgressBarRef = React.Component<NativeWinUI.NativeProgressBarProps> & Readonly<NativeMethods>;
const _ProgressBar : (ForwardRefExoticComponent<React.PropsWithChildren<ProgressBarProps> & RefAttributes<ProgressBarRef>>) = React.forwardRef((props: React.PropsWithChildren<ProgressBarProps>, ref: React.ForwardedRef<ProgressBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ProgressBar' ref={ref} />);
export const ProgressBar = (_ProgressBar as (ForwardRefExoticComponent<React.PropsWithChildren<ProgressBarProps> & RefAttributes<ProgressBarRef>>));

}
export namespace WinUI {
export type ProgressRingProps = Omit<NativeWinUI.NativeProgressRingProps, 'type'>;
export type ProgressRingRef = React.Component<NativeWinUI.NativeProgressRingProps> & Readonly<NativeMethods>;
const _ProgressRing : (ForwardRefExoticComponent<React.PropsWithChildren<ProgressRingProps> & RefAttributes<ProgressRingRef>>) = React.forwardRef((props: React.PropsWithChildren<ProgressRingProps>, ref: React.ForwardedRef<ProgressRingRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ProgressRing' ref={ref} />);
export const ProgressRing = (_ProgressRing as (ForwardRefExoticComponent<React.PropsWithChildren<ProgressRingProps> & RefAttributes<ProgressRingRef>>));

}
export namespace WinUI {
export type RadioButtonsProps = Omit<NativeWinUI.NativeRadioButtonsProps, 'type'>;
export type RadioButtonsRef = React.Component<NativeWinUI.NativeRadioButtonsProps> & Readonly<NativeMethods>;
const _RadioButtons : (ForwardRefExoticComponent<React.PropsWithChildren<RadioButtonsProps> & RefAttributes<RadioButtonsRef>>) = React.forwardRef((props: React.PropsWithChildren<RadioButtonsProps>, ref: React.ForwardedRef<RadioButtonsRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RadioButtons' ref={ref} />);
export const RadioButtons = (_RadioButtons as (ForwardRefExoticComponent<React.PropsWithChildren<RadioButtonsProps> & RefAttributes<RadioButtonsRef>>));

}
export namespace WinUI {
export type RadioMenuFlyoutItemProps = Omit<NativeWinUI.NativeRadioMenuFlyoutItemProps, 'type'>;
export type RadioMenuFlyoutItemRef = React.Component<NativeWinUI.NativeRadioMenuFlyoutItemProps> & Readonly<NativeMethods>;
const _RadioMenuFlyoutItem : (ForwardRefExoticComponent<React.PropsWithChildren<RadioMenuFlyoutItemProps> & RefAttributes<RadioMenuFlyoutItemRef>>) = React.forwardRef((props: React.PropsWithChildren<RadioMenuFlyoutItemProps>, ref: React.ForwardedRef<RadioMenuFlyoutItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem' ref={ref} />);
export const RadioMenuFlyoutItem = (_RadioMenuFlyoutItem as (ForwardRefExoticComponent<React.PropsWithChildren<RadioMenuFlyoutItemProps> & RefAttributes<RadioMenuFlyoutItemRef>>));

}
export namespace WinUI {
export type RatingControlProps = Omit<NativeWinUI.NativeRatingControlProps, 'type'>;
export type RatingControlRef = React.Component<NativeWinUI.NativeRatingControlProps> & Readonly<NativeMethods>;
const _RatingControl : (ForwardRefExoticComponent<React.PropsWithChildren<RatingControlProps> & RefAttributes<RatingControlRef>>) = React.forwardRef((props: React.PropsWithChildren<RatingControlProps>, ref: React.ForwardedRef<RatingControlRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RatingControl' ref={ref} />);
export const RatingControl = (_RatingControl as (ForwardRefExoticComponent<React.PropsWithChildren<RatingControlProps> & RefAttributes<RatingControlRef>>));

}
export namespace WinUI {
export type RefreshContainerProps = Omit<NativeWinUI.NativeRefreshContainerProps, 'type'>;
export type RefreshContainerRef = React.Component<NativeWinUI.NativeRefreshContainerProps> & Readonly<NativeMethods>;
const _RefreshContainer : (ForwardRefExoticComponent<React.PropsWithChildren<RefreshContainerProps> & RefAttributes<RefreshContainerRef>>) = React.forwardRef((props: React.PropsWithChildren<RefreshContainerProps>, ref: React.ForwardedRef<RefreshContainerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RefreshContainer' ref={ref} />);
export const RefreshContainer = (_RefreshContainer as (ForwardRefExoticComponent<React.PropsWithChildren<RefreshContainerProps> & RefAttributes<RefreshContainerRef>>));

}
export namespace WinUI {
export type RefreshVisualizerProps = Omit<NativeWinUI.NativeRefreshVisualizerProps, 'type'>;
export type RefreshVisualizerRef = React.Component<NativeWinUI.NativeRefreshVisualizerProps> & Readonly<NativeMethods>;
const _RefreshVisualizer : (ForwardRefExoticComponent<React.PropsWithChildren<RefreshVisualizerProps> & RefAttributes<RefreshVisualizerRef>>) = React.forwardRef((props: React.PropsWithChildren<RefreshVisualizerProps>, ref: React.ForwardedRef<RefreshVisualizerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RefreshVisualizer' ref={ref} />);
export const RefreshVisualizer = (_RefreshVisualizer as (ForwardRefExoticComponent<React.PropsWithChildren<RefreshVisualizerProps> & RefAttributes<RefreshVisualizerRef>>));

}
export namespace WinUI {
export type RevealListViewItemPresenterProps = Omit<NativeWinUI.NativeRevealListViewItemPresenterProps, 'type'>;
export type RevealListViewItemPresenterRef = React.Component<NativeWinUI.NativeRevealListViewItemPresenterProps> & Readonly<NativeMethods>;
const _RevealListViewItemPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<RevealListViewItemPresenterProps> & RefAttributes<RevealListViewItemPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<RevealListViewItemPresenterProps>, ref: React.ForwardedRef<RevealListViewItemPresenterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RevealListViewItemPresenter' ref={ref} />);
export const RevealListViewItemPresenter = (_RevealListViewItemPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<RevealListViewItemPresenterProps> & RefAttributes<RevealListViewItemPresenterRef>>));

}
export namespace WinUI {
export type SplitButtonProps = Omit<NativeWinUI.NativeSplitButtonProps, 'type'>;
export type SplitButtonRef = React.Component<NativeWinUI.NativeSplitButtonProps> & Readonly<NativeMethods>;
const _SplitButton : (ForwardRefExoticComponent<React.PropsWithChildren<SplitButtonProps> & RefAttributes<SplitButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<SplitButtonProps>, ref: React.ForwardedRef<SplitButtonRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.SplitButton' ref={ref} />);
export const SplitButton = (_SplitButton as (ForwardRefExoticComponent<React.PropsWithChildren<SplitButtonProps> & RefAttributes<SplitButtonRef>>));

}
export namespace WinUI {
export type SwipeControlProps = Omit<NativeWinUI.NativeSwipeControlProps, 'type'>;
export type SwipeControlRef = React.Component<NativeWinUI.NativeSwipeControlProps> & Readonly<NativeMethods>;
const _SwipeControl : (ForwardRefExoticComponent<React.PropsWithChildren<SwipeControlProps> & RefAttributes<SwipeControlRef>>) = React.forwardRef((props: React.PropsWithChildren<SwipeControlProps>, ref: React.ForwardedRef<SwipeControlRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.SwipeControl' ref={ref} />);
export const SwipeControl = (_SwipeControl as (ForwardRefExoticComponent<React.PropsWithChildren<SwipeControlProps> & RefAttributes<SwipeControlRef>>));

}
export namespace WinUI {
export type TabViewProps = Omit<NativeWinUI.NativeTabViewProps, 'type'>;
export type TabViewRef = React.Component<NativeWinUI.NativeTabViewProps> & Readonly<NativeMethods>;
const _TabView : (ForwardRefExoticComponent<React.PropsWithChildren<TabViewProps> & RefAttributes<TabViewRef>>) = React.forwardRef((props: React.PropsWithChildren<TabViewProps>, ref: React.ForwardedRef<TabViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TabView' ref={ref} />);
export const TabView = (_TabView as (ForwardRefExoticComponent<React.PropsWithChildren<TabViewProps> & RefAttributes<TabViewRef>>));

}
export namespace WinUI {
export type TabViewItemProps = Omit<NativeWinUI.NativeTabViewItemProps, 'type'>;
export type TabViewItemRef = React.Component<NativeWinUI.NativeTabViewItemProps> & Readonly<NativeMethods>;
const _TabViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<TabViewItemProps> & RefAttributes<TabViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<TabViewItemProps>, ref: React.ForwardedRef<TabViewItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TabViewItem' ref={ref} />);
export const TabViewItem = (_TabViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<TabViewItemProps> & RefAttributes<TabViewItemRef>>));

}
export namespace WinUI {
export type TeachingTipProps = Omit<NativeWinUI.NativeTeachingTipProps, 'type'>;
export type TeachingTipRef = React.Component<NativeWinUI.NativeTeachingTipProps> & Readonly<NativeMethods>;
const _TeachingTip : (ForwardRefExoticComponent<React.PropsWithChildren<TeachingTipProps> & RefAttributes<TeachingTipRef>>) = React.forwardRef((props: React.PropsWithChildren<TeachingTipProps>, ref: React.ForwardedRef<TeachingTipRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TeachingTip' ref={ref} />);
export const TeachingTip = (_TeachingTip as (ForwardRefExoticComponent<React.PropsWithChildren<TeachingTipProps> & RefAttributes<TeachingTipRef>>));

}
export namespace WinUI {
export type TextCommandBarFlyoutProps = Omit<NativeWinUI.NativeTextCommandBarFlyoutProps, 'type'>;
export type TextCommandBarFlyoutRef = React.Component<NativeWinUI.NativeTextCommandBarFlyoutProps> & Readonly<NativeMethods>;
const _TextCommandBarFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<TextCommandBarFlyoutProps> & RefAttributes<TextCommandBarFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<TextCommandBarFlyoutProps>, ref: React.ForwardedRef<TextCommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TextCommandBarFlyout' ref={ref} />);
export const TextCommandBarFlyout = (_TextCommandBarFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<TextCommandBarFlyoutProps> & RefAttributes<TextCommandBarFlyoutRef>>));

}
export namespace WinUI {
export type ToggleSplitButtonProps = Omit<NativeWinUI.NativeToggleSplitButtonProps, 'type'>;
export type ToggleSplitButtonRef = React.Component<NativeWinUI.NativeToggleSplitButtonProps> & Readonly<NativeMethods>;
const _ToggleSplitButton : (ForwardRefExoticComponent<React.PropsWithChildren<ToggleSplitButtonProps> & RefAttributes<ToggleSplitButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<ToggleSplitButtonProps>, ref: React.ForwardedRef<ToggleSplitButtonRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ToggleSplitButton' ref={ref} />);
export const ToggleSplitButton = (_ToggleSplitButton as (ForwardRefExoticComponent<React.PropsWithChildren<ToggleSplitButtonProps> & RefAttributes<ToggleSplitButtonRef>>));

}
export namespace WinUI {
export type TreeViewProps = Omit<NativeWinUI.NativeTreeViewProps, 'type'>;
export type TreeViewRef = React.Component<NativeWinUI.NativeTreeViewProps> & Readonly<NativeMethods>;
const _TreeView : (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewProps> & RefAttributes<TreeViewRef>>) = React.forwardRef((props: React.PropsWithChildren<TreeViewProps>, ref: React.ForwardedRef<TreeViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeView' ref={ref} />);
export const TreeView = (_TreeView as (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewProps> & RefAttributes<TreeViewRef>>));

}
export namespace WinUI {
export type TreeViewItemProps = Omit<NativeWinUI.NativeTreeViewItemProps, 'type'>;
export type TreeViewItemRef = React.Component<NativeWinUI.NativeTreeViewItemProps> & Readonly<NativeMethods>;
const _TreeViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewItemProps> & RefAttributes<TreeViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<TreeViewItemProps>, ref: React.ForwardedRef<TreeViewItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeViewItem' ref={ref} />);
export const TreeViewItem = (_TreeViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewItemProps> & RefAttributes<TreeViewItemRef>>));

}
export namespace WinUI {
export type TreeViewListProps = Omit<NativeWinUI.NativeTreeViewListProps, 'type'>;
export type TreeViewListRef = React.Component<NativeWinUI.NativeTreeViewListProps> & Readonly<NativeMethods>;
const _TreeViewList : (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewListProps> & RefAttributes<TreeViewListRef>>) = React.forwardRef((props: React.PropsWithChildren<TreeViewListProps>, ref: React.ForwardedRef<TreeViewListRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeViewList' ref={ref} />);
export const TreeViewList = (_TreeViewList as (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewListProps> & RefAttributes<TreeViewListRef>>));

}
export namespace WinUI {
export type TwoPaneViewProps = Omit<NativeWinUI.NativeTwoPaneViewProps, 'type'>;
export type TwoPaneViewRef = React.Component<NativeWinUI.NativeTwoPaneViewProps> & Readonly<NativeMethods>;
const _TwoPaneView : (ForwardRefExoticComponent<React.PropsWithChildren<TwoPaneViewProps> & RefAttributes<TwoPaneViewRef>>) = React.forwardRef((props: React.PropsWithChildren<TwoPaneViewProps>, ref: React.ForwardedRef<TwoPaneViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TwoPaneView' ref={ref} />);
export const TwoPaneView = (_TwoPaneView as (ForwardRefExoticComponent<React.PropsWithChildren<TwoPaneViewProps> & RefAttributes<TwoPaneViewRef>>));

}
export namespace WinUI {
export type WebView2Props = Omit<NativeWinUI.NativeWebView2Props, 'type'>;
export type WebView2Ref = React.Component<NativeWinUI.NativeWebView2Props> & Readonly<NativeMethods>;
const _WebView2 : (ForwardRefExoticComponent<React.PropsWithChildren<WebView2Props> & RefAttributes<WebView2Ref>>) = React.forwardRef((props: React.PropsWithChildren<WebView2Props>, ref: React.ForwardedRef<WebView2Ref>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.WebView2' ref={ref} />);
export const WebView2 = (_WebView2 as (ForwardRefExoticComponent<React.PropsWithChildren<WebView2Props> & RefAttributes<WebView2Ref>>));

}
export type ContentControlProps = Omit<NativeContentControlProps, 'type'>;
export type ContentControlRef = React.Component<NativeContentControlProps> & Readonly<NativeMethods>;
const _ContentControl : (ForwardRefExoticComponent<React.PropsWithChildren<ContentControlProps> & RefAttributes<ContentControlRef>>) = React.forwardRef((props: React.PropsWithChildren<ContentControlProps>, ref: React.ForwardedRef<ContentControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentControl' ref={ref} />);
export const ContentControl = (_ContentControl as (ForwardRefExoticComponent<React.PropsWithChildren<ContentControlProps> & RefAttributes<ContentControlRef>>));

export type AppBarProps = Omit<NativeAppBarProps, 'type'>;
export type AppBarRef = React.Component<NativeAppBarProps> & Readonly<NativeMethods>;
const _AppBar : (ForwardRefExoticComponent<React.PropsWithChildren<AppBarProps> & RefAttributes<AppBarRef>>) = React.forwardRef((props: React.PropsWithChildren<AppBarProps>, ref: React.ForwardedRef<AppBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBar' ref={ref} />);
export const AppBar = (_AppBar as (ForwardRefExoticComponent<React.PropsWithChildren<AppBarProps> & RefAttributes<AppBarRef>>));

export type ButtonProps = Omit<NativeButtonProps, 'type'>;
export type ButtonRef = React.Component<NativeButtonProps> & Readonly<NativeMethods>;
const _Button : (ForwardRefExoticComponent<React.PropsWithChildren<ButtonProps> & RefAttributes<ButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<ButtonProps>, ref: React.ForwardedRef<ButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Button' ref={ref} />);
export const Button = (_Button as (ForwardRefExoticComponent<React.PropsWithChildren<ButtonProps> & RefAttributes<ButtonRef>>));

export type AppBarButtonProps = Omit<NativeAppBarButtonProps, 'type'>;
export type AppBarButtonRef = React.Component<NativeAppBarButtonProps> & Readonly<NativeMethods>;
const _AppBarButton : (ForwardRefExoticComponent<React.PropsWithChildren<AppBarButtonProps> & RefAttributes<AppBarButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<AppBarButtonProps>, ref: React.ForwardedRef<AppBarButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarButton' ref={ref} />);
export const AppBarButton = (_AppBarButton as (ForwardRefExoticComponent<React.PropsWithChildren<AppBarButtonProps> & RefAttributes<AppBarButtonRef>>));

export type AppBarElementContainerProps = Omit<NativeAppBarElementContainerProps, 'type'>;
export type AppBarElementContainerRef = React.Component<NativeAppBarElementContainerProps> & Readonly<NativeMethods>;
const _AppBarElementContainer : (ForwardRefExoticComponent<React.PropsWithChildren<AppBarElementContainerProps> & RefAttributes<AppBarElementContainerRef>>) = React.forwardRef((props: React.PropsWithChildren<AppBarElementContainerProps>, ref: React.ForwardedRef<AppBarElementContainerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarElementContainer' ref={ref} />);
export const AppBarElementContainer = (_AppBarElementContainer as (ForwardRefExoticComponent<React.PropsWithChildren<AppBarElementContainerProps> & RefAttributes<AppBarElementContainerRef>>));

export type AppBarSeparatorProps = Omit<NativeAppBarSeparatorProps, 'type'>;
export type AppBarSeparatorRef = React.Component<NativeAppBarSeparatorProps> & Readonly<NativeMethods>;
const _AppBarSeparator : (ForwardRefExoticComponent<React.PropsWithChildren<AppBarSeparatorProps> & RefAttributes<AppBarSeparatorRef>>) = React.forwardRef((props: React.PropsWithChildren<AppBarSeparatorProps>, ref: React.ForwardedRef<AppBarSeparatorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarSeparator' ref={ref} />);
export const AppBarSeparator = (_AppBarSeparator as (ForwardRefExoticComponent<React.PropsWithChildren<AppBarSeparatorProps> & RefAttributes<AppBarSeparatorRef>>));

export type ToggleButtonProps = Omit<NativeToggleButtonProps, 'type'>;
export type ToggleButtonRef = React.Component<NativeToggleButtonProps> & Readonly<NativeMethods>;
const _ToggleButton : (ForwardRefExoticComponent<React.PropsWithChildren<ToggleButtonProps> & RefAttributes<ToggleButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<ToggleButtonProps>, ref: React.ForwardedRef<ToggleButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ToggleButton' ref={ref} />);
export const ToggleButton = (_ToggleButton as (ForwardRefExoticComponent<React.PropsWithChildren<ToggleButtonProps> & RefAttributes<ToggleButtonRef>>));

export type AppBarToggleButtonProps = Omit<NativeAppBarToggleButtonProps, 'type'>;
export type AppBarToggleButtonRef = React.Component<NativeAppBarToggleButtonProps> & Readonly<NativeMethods>;
const _AppBarToggleButton : (ForwardRefExoticComponent<React.PropsWithChildren<AppBarToggleButtonProps> & RefAttributes<AppBarToggleButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<AppBarToggleButtonProps>, ref: React.ForwardedRef<AppBarToggleButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarToggleButton' ref={ref} />);
export const AppBarToggleButton = (_AppBarToggleButton as (ForwardRefExoticComponent<React.PropsWithChildren<AppBarToggleButtonProps> & RefAttributes<AppBarToggleButtonRef>>));

export type ItemsControlProps = Omit<NativeItemsControlProps, 'type'>;
export type ItemsControlRef = React.Component<NativeItemsControlProps> & Readonly<NativeMethods>;
const _ItemsControl : (ForwardRefExoticComponent<React.PropsWithChildren<ItemsControlProps> & RefAttributes<ItemsControlRef>>) = React.forwardRef((props: React.PropsWithChildren<ItemsControlProps>, ref: React.ForwardedRef<ItemsControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsControl' ref={ref} />);
export const ItemsControl = (_ItemsControl as (ForwardRefExoticComponent<React.PropsWithChildren<ItemsControlProps> & RefAttributes<ItemsControlRef>>));

export type AutoSuggestBoxProps = Omit<NativeAutoSuggestBoxProps, 'type'>;
export type AutoSuggestBoxRef = React.Component<NativeAutoSuggestBoxProps> & Readonly<NativeMethods>;
const _AutoSuggestBox : (ForwardRefExoticComponent<React.PropsWithChildren<AutoSuggestBoxProps> & RefAttributes<AutoSuggestBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<AutoSuggestBoxProps>, ref: React.ForwardedRef<AutoSuggestBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AutoSuggestBox' ref={ref} />);
export const AutoSuggestBox = (_AutoSuggestBox as (ForwardRefExoticComponent<React.PropsWithChildren<AutoSuggestBoxProps> & RefAttributes<AutoSuggestBoxRef>>));

export type BitmapIconProps = Omit<NativeBitmapIconProps, 'type'>;
export type BitmapIconRef = React.Component<NativeBitmapIconProps> & Readonly<NativeMethods>;
const _BitmapIcon : (ForwardRefExoticComponent<React.PropsWithChildren<BitmapIconProps> & RefAttributes<BitmapIconRef>>) = React.forwardRef((props: React.PropsWithChildren<BitmapIconProps>, ref: React.ForwardedRef<BitmapIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.BitmapIcon' ref={ref} />);
export const BitmapIcon = (_BitmapIcon as (ForwardRefExoticComponent<React.PropsWithChildren<BitmapIconProps> & RefAttributes<BitmapIconRef>>));

export type BorderProps = Omit<NativeBorderProps, 'type'>;
export type BorderRef = React.Component<NativeBorderProps> & Readonly<NativeMethods>;
const _Border : (ForwardRefExoticComponent<React.PropsWithChildren<BorderProps> & RefAttributes<BorderRef>>) = React.forwardRef((props: React.PropsWithChildren<BorderProps>, ref: React.ForwardedRef<BorderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Border' ref={ref} />);
export const Border = (_Border as (ForwardRefExoticComponent<React.PropsWithChildren<BorderProps> & RefAttributes<BorderRef>>));

export type CalendarDatePickerProps = Omit<NativeCalendarDatePickerProps, 'type'>;
export type CalendarDatePickerRef = React.Component<NativeCalendarDatePickerProps> & Readonly<NativeMethods>;
const _CalendarDatePicker : (ForwardRefExoticComponent<React.PropsWithChildren<CalendarDatePickerProps> & RefAttributes<CalendarDatePickerRef>>) = React.forwardRef((props: React.PropsWithChildren<CalendarDatePickerProps>, ref: React.ForwardedRef<CalendarDatePickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarDatePicker' ref={ref} />);
export const CalendarDatePicker = (_CalendarDatePicker as (ForwardRefExoticComponent<React.PropsWithChildren<CalendarDatePickerProps> & RefAttributes<CalendarDatePickerRef>>));

export type CalendarViewProps = Omit<NativeCalendarViewProps, 'type'>;
export type CalendarViewRef = React.Component<NativeCalendarViewProps> & Readonly<NativeMethods>;
const _CalendarView : (ForwardRefExoticComponent<React.PropsWithChildren<CalendarViewProps> & RefAttributes<CalendarViewRef>>) = React.forwardRef((props: React.PropsWithChildren<CalendarViewProps>, ref: React.ForwardedRef<CalendarViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarView' ref={ref} />);
export const CalendarView = (_CalendarView as (ForwardRefExoticComponent<React.PropsWithChildren<CalendarViewProps> & RefAttributes<CalendarViewRef>>));

export type CalendarViewDayItemProps = Omit<NativeCalendarViewDayItemProps, 'type'>;
export type CalendarViewDayItemRef = React.Component<NativeCalendarViewDayItemProps> & Readonly<NativeMethods>;
const _CalendarViewDayItem : (ForwardRefExoticComponent<React.PropsWithChildren<CalendarViewDayItemProps> & RefAttributes<CalendarViewDayItemRef>>) = React.forwardRef((props: React.PropsWithChildren<CalendarViewDayItemProps>, ref: React.ForwardedRef<CalendarViewDayItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarViewDayItem' ref={ref} />);
export const CalendarViewDayItem = (_CalendarViewDayItem as (ForwardRefExoticComponent<React.PropsWithChildren<CalendarViewDayItemProps> & RefAttributes<CalendarViewDayItemRef>>));

export type CanvasProps = Omit<NativeCanvasProps, 'type'>;
export type CanvasRef = React.Component<NativeCanvasProps> & Readonly<NativeMethods>;
const _Canvas : (ForwardRefExoticComponent<React.PropsWithChildren<CanvasProps> & RefAttributes<CanvasRef>>) = React.forwardRef((props: React.PropsWithChildren<CanvasProps>, ref: React.ForwardedRef<CanvasRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Canvas' ref={ref} />);
export const Canvas = (_Canvas as (ForwardRefExoticComponent<React.PropsWithChildren<CanvasProps> & RefAttributes<CanvasRef>>));

export type CaptureElementProps = Omit<NativeCaptureElementProps, 'type'>;
export type CaptureElementRef = React.Component<NativeCaptureElementProps> & Readonly<NativeMethods>;
const _CaptureElement : (ForwardRefExoticComponent<React.PropsWithChildren<CaptureElementProps> & RefAttributes<CaptureElementRef>>) = React.forwardRef((props: React.PropsWithChildren<CaptureElementProps>, ref: React.ForwardedRef<CaptureElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CaptureElement' ref={ref} />);
export const CaptureElement = (_CaptureElement as (ForwardRefExoticComponent<React.PropsWithChildren<CaptureElementProps> & RefAttributes<CaptureElementRef>>));

export type CheckBoxProps = Omit<NativeCheckBoxProps, 'type'>;
export type CheckBoxRef = React.Component<NativeCheckBoxProps> & Readonly<NativeMethods>;
const _CheckBox : (ForwardRefExoticComponent<React.PropsWithChildren<CheckBoxProps> & RefAttributes<CheckBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<CheckBoxProps>, ref: React.ForwardedRef<CheckBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CheckBox' ref={ref} />);
export const CheckBox = (_CheckBox as (ForwardRefExoticComponent<React.PropsWithChildren<CheckBoxProps> & RefAttributes<CheckBoxRef>>));

export type ColorPickerProps = Omit<NativeColorPickerProps, 'type'>;
export type ColorPickerRef = React.Component<NativeColorPickerProps> & Readonly<NativeMethods>;
const _ColorPicker : (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerProps> & RefAttributes<ColorPickerRef>>) = React.forwardRef((props: React.PropsWithChildren<ColorPickerProps>, ref: React.ForwardedRef<ColorPickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ColorPicker' ref={ref} />);
export const ColorPicker = (_ColorPicker as (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerProps> & RefAttributes<ColorPickerRef>>));

export type ComboBoxProps = Omit<NativeComboBoxProps, 'type'>;
export type ComboBoxRef = React.Component<NativeComboBoxProps> & Readonly<NativeMethods>;
const _ComboBox : (ForwardRefExoticComponent<React.PropsWithChildren<ComboBoxProps> & RefAttributes<ComboBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<ComboBoxProps>, ref: React.ForwardedRef<ComboBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ComboBox' ref={ref} />);
export const ComboBox = (_ComboBox as (ForwardRefExoticComponent<React.PropsWithChildren<ComboBoxProps> & RefAttributes<ComboBoxRef>>));

export type ComboBoxItemProps = Omit<NativeComboBoxItemProps, 'type'>;
export type ComboBoxItemRef = React.Component<NativeComboBoxItemProps> & Readonly<NativeMethods>;
const _ComboBoxItem : (ForwardRefExoticComponent<React.PropsWithChildren<ComboBoxItemProps> & RefAttributes<ComboBoxItemRef>>) = React.forwardRef((props: React.PropsWithChildren<ComboBoxItemProps>, ref: React.ForwardedRef<ComboBoxItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ComboBoxItem' ref={ref} />);
export const ComboBoxItem = (_ComboBoxItem as (ForwardRefExoticComponent<React.PropsWithChildren<ComboBoxItemProps> & RefAttributes<ComboBoxItemRef>>));

export type CommandBarProps = Omit<NativeCommandBarProps, 'type'>;
export type CommandBarRef = React.Component<NativeCommandBarProps> & Readonly<NativeMethods>;
const _CommandBar : (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarProps> & RefAttributes<CommandBarRef>>) = React.forwardRef((props: React.PropsWithChildren<CommandBarProps>, ref: React.ForwardedRef<CommandBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBar' ref={ref} />);
export const CommandBar = (_CommandBar as (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarProps> & RefAttributes<CommandBarRef>>));

export type CommandBarFlyoutProps = Omit<NativeCommandBarFlyoutProps, 'type'>;
export type CommandBarFlyoutRef = React.Component<NativeCommandBarFlyoutProps> & Readonly<NativeMethods>;
const _CommandBarFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutProps> & RefAttributes<CommandBarFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<CommandBarFlyoutProps>, ref: React.ForwardedRef<CommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBarFlyout' ref={ref} />);
export const CommandBarFlyout = (_CommandBarFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutProps> & RefAttributes<CommandBarFlyoutRef>>));

export type CommandBarOverflowPresenterProps = Omit<NativeCommandBarOverflowPresenterProps, 'type'>;
export type CommandBarOverflowPresenterRef = React.Component<NativeCommandBarOverflowPresenterProps> & Readonly<NativeMethods>;
const _CommandBarOverflowPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarOverflowPresenterProps> & RefAttributes<CommandBarOverflowPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<CommandBarOverflowPresenterProps>, ref: React.ForwardedRef<CommandBarOverflowPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBarOverflowPresenter' ref={ref} />);
export const CommandBarOverflowPresenter = (_CommandBarOverflowPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarOverflowPresenterProps> & RefAttributes<CommandBarOverflowPresenterRef>>));

export type ContentDialogProps = Omit<NativeContentDialogProps, 'type'>;
export type ContentDialogRef = React.Component<NativeContentDialogProps> & Readonly<NativeMethods>;
const _ContentDialog : (ForwardRefExoticComponent<React.PropsWithChildren<ContentDialogProps> & RefAttributes<ContentDialogRef>>) = React.forwardRef((props: React.PropsWithChildren<ContentDialogProps>, ref: React.ForwardedRef<ContentDialogRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentDialog' ref={ref} />);
export const ContentDialog = (_ContentDialog as (ForwardRefExoticComponent<React.PropsWithChildren<ContentDialogProps> & RefAttributes<ContentDialogRef>>));

export type ContentPresenterProps = Omit<NativeContentPresenterProps, 'type'>;
export type ContentPresenterRef = React.Component<NativeContentPresenterProps> & Readonly<NativeMethods>;
const _ContentPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<ContentPresenterProps> & RefAttributes<ContentPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<ContentPresenterProps>, ref: React.ForwardedRef<ContentPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentPresenter' ref={ref} />);
export const ContentPresenter = (_ContentPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<ContentPresenterProps> & RefAttributes<ContentPresenterRef>>));

export type DatePickerProps = Omit<NativeDatePickerProps, 'type'>;
export type DatePickerRef = React.Component<NativeDatePickerProps> & Readonly<NativeMethods>;
const _DatePicker : (ForwardRefExoticComponent<React.PropsWithChildren<DatePickerProps> & RefAttributes<DatePickerRef>>) = React.forwardRef((props: React.PropsWithChildren<DatePickerProps>, ref: React.ForwardedRef<DatePickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DatePicker' ref={ref} />);
export const DatePicker = (_DatePicker as (ForwardRefExoticComponent<React.PropsWithChildren<DatePickerProps> & RefAttributes<DatePickerRef>>));

export type DatePickerFlyoutProps = Omit<NativeDatePickerFlyoutProps, 'type'>;
export type DatePickerFlyoutRef = React.Component<NativeDatePickerFlyoutProps> & Readonly<NativeMethods>;
const _DatePickerFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<DatePickerFlyoutProps> & RefAttributes<DatePickerFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<DatePickerFlyoutProps>, ref: React.ForwardedRef<DatePickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DatePickerFlyout' ref={ref} />);
export const DatePickerFlyout = (_DatePickerFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<DatePickerFlyoutProps> & RefAttributes<DatePickerFlyoutRef>>));

export type DropDownButtonProps = Omit<NativeDropDownButtonProps, 'type'>;
export type DropDownButtonRef = React.Component<NativeDropDownButtonProps> & Readonly<NativeMethods>;
const _DropDownButton : (ForwardRefExoticComponent<React.PropsWithChildren<DropDownButtonProps> & RefAttributes<DropDownButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<DropDownButtonProps>, ref: React.ForwardedRef<DropDownButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DropDownButton' ref={ref} />);
export const DropDownButton = (_DropDownButton as (ForwardRefExoticComponent<React.PropsWithChildren<DropDownButtonProps> & RefAttributes<DropDownButtonRef>>));

export type FlipViewProps = Omit<NativeFlipViewProps, 'type'>;
export type FlipViewRef = React.Component<NativeFlipViewProps> & Readonly<NativeMethods>;
const _FlipView : (ForwardRefExoticComponent<React.PropsWithChildren<FlipViewProps> & RefAttributes<FlipViewRef>>) = React.forwardRef((props: React.PropsWithChildren<FlipViewProps>, ref: React.ForwardedRef<FlipViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlipView' ref={ref} />);
export const FlipView = (_FlipView as (ForwardRefExoticComponent<React.PropsWithChildren<FlipViewProps> & RefAttributes<FlipViewRef>>));

export type FlipViewItemProps = Omit<NativeFlipViewItemProps, 'type'>;
export type FlipViewItemRef = React.Component<NativeFlipViewItemProps> & Readonly<NativeMethods>;
const _FlipViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<FlipViewItemProps> & RefAttributes<FlipViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<FlipViewItemProps>, ref: React.ForwardedRef<FlipViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlipViewItem' ref={ref} />);
export const FlipViewItem = (_FlipViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<FlipViewItemProps> & RefAttributes<FlipViewItemRef>>));

export type FlyoutProps = Omit<NativeFlyoutProps, 'type'>;
export type FlyoutRef = React.Component<NativeFlyoutProps> & Readonly<NativeMethods>;
const _Flyout : (ForwardRefExoticComponent<React.PropsWithChildren<FlyoutProps> & RefAttributes<FlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<FlyoutProps>, ref: React.ForwardedRef<FlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Flyout' ref={ref} />);
export const Flyout = (_Flyout as (ForwardRefExoticComponent<React.PropsWithChildren<FlyoutProps> & RefAttributes<FlyoutRef>>));

export type FlyoutPresenterProps = Omit<NativeFlyoutPresenterProps, 'type'>;
export type FlyoutPresenterRef = React.Component<NativeFlyoutPresenterProps> & Readonly<NativeMethods>;
const _FlyoutPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<FlyoutPresenterProps> & RefAttributes<FlyoutPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<FlyoutPresenterProps>, ref: React.ForwardedRef<FlyoutPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlyoutPresenter' ref={ref} />);
export const FlyoutPresenter = (_FlyoutPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<FlyoutPresenterProps> & RefAttributes<FlyoutPresenterRef>>));

export type FontIconProps = Omit<NativeFontIconProps, 'type'>;
export type FontIconRef = React.Component<NativeFontIconProps> & Readonly<NativeMethods>;
const _FontIcon : (ForwardRefExoticComponent<React.PropsWithChildren<FontIconProps> & RefAttributes<FontIconRef>>) = React.forwardRef((props: React.PropsWithChildren<FontIconProps>, ref: React.ForwardedRef<FontIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FontIcon' ref={ref} />);
export const FontIcon = (_FontIcon as (ForwardRefExoticComponent<React.PropsWithChildren<FontIconProps> & RefAttributes<FontIconRef>>));

export type FrameProps = Omit<NativeFrameProps, 'type'>;
export type FrameRef = React.Component<NativeFrameProps> & Readonly<NativeMethods>;
const _Frame : (ForwardRefExoticComponent<React.PropsWithChildren<FrameProps> & RefAttributes<FrameRef>>) = React.forwardRef((props: React.PropsWithChildren<FrameProps>, ref: React.ForwardedRef<FrameRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Frame' ref={ref} />);
export const Frame = (_Frame as (ForwardRefExoticComponent<React.PropsWithChildren<FrameProps> & RefAttributes<FrameRef>>));

export type GridProps = Omit<NativeGridProps, 'type'>;
export type GridRef = React.Component<NativeGridProps> & Readonly<NativeMethods>;
const _Grid : (ForwardRefExoticComponent<React.PropsWithChildren<GridProps> & RefAttributes<GridRef>>) = React.forwardRef((props: React.PropsWithChildren<GridProps>, ref: React.ForwardedRef<GridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Grid' ref={ref} />);
export const Grid = (_Grid as (ForwardRefExoticComponent<React.PropsWithChildren<GridProps> & RefAttributes<GridRef>>));

export type GridViewProps = Omit<NativeGridViewProps, 'type'>;
export type GridViewRef = React.Component<NativeGridViewProps> & Readonly<NativeMethods>;
const _GridView : (ForwardRefExoticComponent<React.PropsWithChildren<GridViewProps> & RefAttributes<GridViewRef>>) = React.forwardRef((props: React.PropsWithChildren<GridViewProps>, ref: React.ForwardedRef<GridViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridView' ref={ref} />);
export const GridView = (_GridView as (ForwardRefExoticComponent<React.PropsWithChildren<GridViewProps> & RefAttributes<GridViewRef>>));

export type GridViewHeaderItemProps = Omit<NativeGridViewHeaderItemProps, 'type'>;
export type GridViewHeaderItemRef = React.Component<NativeGridViewHeaderItemProps> & Readonly<NativeMethods>;
const _GridViewHeaderItem : (ForwardRefExoticComponent<React.PropsWithChildren<GridViewHeaderItemProps> & RefAttributes<GridViewHeaderItemRef>>) = React.forwardRef((props: React.PropsWithChildren<GridViewHeaderItemProps>, ref: React.ForwardedRef<GridViewHeaderItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridViewHeaderItem' ref={ref} />);
export const GridViewHeaderItem = (_GridViewHeaderItem as (ForwardRefExoticComponent<React.PropsWithChildren<GridViewHeaderItemProps> & RefAttributes<GridViewHeaderItemRef>>));

export type GridViewItemProps = Omit<NativeGridViewItemProps, 'type'>;
export type GridViewItemRef = React.Component<NativeGridViewItemProps> & Readonly<NativeMethods>;
const _GridViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<GridViewItemProps> & RefAttributes<GridViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<GridViewItemProps>, ref: React.ForwardedRef<GridViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridViewItem' ref={ref} />);
export const GridViewItem = (_GridViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<GridViewItemProps> & RefAttributes<GridViewItemRef>>));

export type GroupItemProps = Omit<NativeGroupItemProps, 'type'>;
export type GroupItemRef = React.Component<NativeGroupItemProps> & Readonly<NativeMethods>;
const _GroupItem : (ForwardRefExoticComponent<React.PropsWithChildren<GroupItemProps> & RefAttributes<GroupItemRef>>) = React.forwardRef((props: React.PropsWithChildren<GroupItemProps>, ref: React.ForwardedRef<GroupItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GroupItem' ref={ref} />);
export const GroupItem = (_GroupItem as (ForwardRefExoticComponent<React.PropsWithChildren<GroupItemProps> & RefAttributes<GroupItemRef>>));

export type HandwritingViewProps = Omit<NativeHandwritingViewProps, 'type'>;
export type HandwritingViewRef = React.Component<NativeHandwritingViewProps> & Readonly<NativeMethods>;
const _HandwritingView : (ForwardRefExoticComponent<React.PropsWithChildren<HandwritingViewProps> & RefAttributes<HandwritingViewRef>>) = React.forwardRef((props: React.PropsWithChildren<HandwritingViewProps>, ref: React.ForwardedRef<HandwritingViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HandwritingView' ref={ref} />);
export const HandwritingView = (_HandwritingView as (ForwardRefExoticComponent<React.PropsWithChildren<HandwritingViewProps> & RefAttributes<HandwritingViewRef>>));

export type HubProps = Omit<NativeHubProps, 'type'>;
export type HubRef = React.Component<NativeHubProps> & Readonly<NativeMethods>;
const _Hub : (ForwardRefExoticComponent<React.PropsWithChildren<HubProps> & RefAttributes<HubRef>>) = React.forwardRef((props: React.PropsWithChildren<HubProps>, ref: React.ForwardedRef<HubRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Hub' ref={ref} />);
export const Hub = (_Hub as (ForwardRefExoticComponent<React.PropsWithChildren<HubProps> & RefAttributes<HubRef>>));

export type HubSectionProps = Omit<NativeHubSectionProps, 'type'>;
export type HubSectionRef = React.Component<NativeHubSectionProps> & Readonly<NativeMethods>;
const _HubSection : (ForwardRefExoticComponent<React.PropsWithChildren<HubSectionProps> & RefAttributes<HubSectionRef>>) = React.forwardRef((props: React.PropsWithChildren<HubSectionProps>, ref: React.ForwardedRef<HubSectionRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HubSection' ref={ref} />);
export const HubSection = (_HubSection as (ForwardRefExoticComponent<React.PropsWithChildren<HubSectionProps> & RefAttributes<HubSectionRef>>));

export type HyperlinkButtonProps = Omit<NativeHyperlinkButtonProps, 'type'>;
export type HyperlinkButtonRef = React.Component<NativeHyperlinkButtonProps> & Readonly<NativeMethods>;
const _HyperlinkButton : (ForwardRefExoticComponent<React.PropsWithChildren<HyperlinkButtonProps> & RefAttributes<HyperlinkButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<HyperlinkButtonProps>, ref: React.ForwardedRef<HyperlinkButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HyperlinkButton' ref={ref} />);
export const HyperlinkButton = (_HyperlinkButton as (ForwardRefExoticComponent<React.PropsWithChildren<HyperlinkButtonProps> & RefAttributes<HyperlinkButtonRef>>));

export type IconSourceElementProps = Omit<NativeIconSourceElementProps, 'type'>;
export type IconSourceElementRef = React.Component<NativeIconSourceElementProps> & Readonly<NativeMethods>;
const _IconSourceElement : (ForwardRefExoticComponent<React.PropsWithChildren<IconSourceElementProps> & RefAttributes<IconSourceElementRef>>) = React.forwardRef((props: React.PropsWithChildren<IconSourceElementProps>, ref: React.ForwardedRef<IconSourceElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.IconSourceElement' ref={ref} />);
export const IconSourceElement = (_IconSourceElement as (ForwardRefExoticComponent<React.PropsWithChildren<IconSourceElementProps> & RefAttributes<IconSourceElementRef>>));

export type ImageProps = Omit<NativeImageProps, 'type'>;
export type ImageRef = React.Component<NativeImageProps> & Readonly<NativeMethods>;
const _Image : (ForwardRefExoticComponent<React.PropsWithChildren<ImageProps> & RefAttributes<ImageRef>>) = React.forwardRef((props: React.PropsWithChildren<ImageProps>, ref: React.ForwardedRef<ImageRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Image' ref={ref} />);
export const Image = (_Image as (ForwardRefExoticComponent<React.PropsWithChildren<ImageProps> & RefAttributes<ImageRef>>));

export type InkCanvasProps = Omit<NativeInkCanvasProps, 'type'>;
export type InkCanvasRef = React.Component<NativeInkCanvasProps> & Readonly<NativeMethods>;
const _InkCanvas : (ForwardRefExoticComponent<React.PropsWithChildren<InkCanvasProps> & RefAttributes<InkCanvasRef>>) = React.forwardRef((props: React.PropsWithChildren<InkCanvasProps>, ref: React.ForwardedRef<InkCanvasRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkCanvas' ref={ref} />);
export const InkCanvas = (_InkCanvas as (ForwardRefExoticComponent<React.PropsWithChildren<InkCanvasProps> & RefAttributes<InkCanvasRef>>));

export type InkToolbarProps = Omit<NativeInkToolbarProps, 'type'>;
export type InkToolbarRef = React.Component<NativeInkToolbarProps> & Readonly<NativeMethods>;
const _InkToolbar : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarProps> & RefAttributes<InkToolbarRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarProps>, ref: React.ForwardedRef<InkToolbarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbar' ref={ref} />);
export const InkToolbar = (_InkToolbar as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarProps> & RefAttributes<InkToolbarRef>>));

export type RadioButtonProps = Omit<NativeRadioButtonProps, 'type'>;
export type RadioButtonRef = React.Component<NativeRadioButtonProps> & Readonly<NativeMethods>;
const _RadioButton : (ForwardRefExoticComponent<React.PropsWithChildren<RadioButtonProps> & RefAttributes<RadioButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<RadioButtonProps>, ref: React.ForwardedRef<RadioButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RadioButton' ref={ref} />);
export const RadioButton = (_RadioButton as (ForwardRefExoticComponent<React.PropsWithChildren<RadioButtonProps> & RefAttributes<RadioButtonRef>>));

export type InkToolbarBallpointPenButtonProps = Omit<NativeInkToolbarBallpointPenButtonProps, 'type'>;
export type InkToolbarBallpointPenButtonRef = React.Component<NativeInkToolbarBallpointPenButtonProps> & Readonly<NativeMethods>;
const _InkToolbarBallpointPenButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarBallpointPenButtonProps> & RefAttributes<InkToolbarBallpointPenButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarBallpointPenButtonProps>, ref: React.ForwardedRef<InkToolbarBallpointPenButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarBallpointPenButton' ref={ref} />);
export const InkToolbarBallpointPenButton = (_InkToolbarBallpointPenButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarBallpointPenButtonProps> & RefAttributes<InkToolbarBallpointPenButtonRef>>));

export type InkToolbarCustomPenButtonProps = Omit<NativeInkToolbarCustomPenButtonProps, 'type'>;
export type InkToolbarCustomPenButtonRef = React.Component<NativeInkToolbarCustomPenButtonProps> & Readonly<NativeMethods>;
const _InkToolbarCustomPenButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarCustomPenButtonProps> & RefAttributes<InkToolbarCustomPenButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarCustomPenButtonProps>, ref: React.ForwardedRef<InkToolbarCustomPenButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomPenButton' ref={ref} />);
export const InkToolbarCustomPenButton = (_InkToolbarCustomPenButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarCustomPenButtonProps> & RefAttributes<InkToolbarCustomPenButtonRef>>));

export type InkToolbarCustomToggleButtonProps = Omit<NativeInkToolbarCustomToggleButtonProps, 'type'>;
export type InkToolbarCustomToggleButtonRef = React.Component<NativeInkToolbarCustomToggleButtonProps> & Readonly<NativeMethods>;
const _InkToolbarCustomToggleButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarCustomToggleButtonProps> & RefAttributes<InkToolbarCustomToggleButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarCustomToggleButtonProps>, ref: React.ForwardedRef<InkToolbarCustomToggleButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomToggleButton' ref={ref} />);
export const InkToolbarCustomToggleButton = (_InkToolbarCustomToggleButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarCustomToggleButtonProps> & RefAttributes<InkToolbarCustomToggleButtonRef>>));

export type InkToolbarCustomToolButtonProps = Omit<NativeInkToolbarCustomToolButtonProps, 'type'>;
export type InkToolbarCustomToolButtonRef = React.Component<NativeInkToolbarCustomToolButtonProps> & Readonly<NativeMethods>;
const _InkToolbarCustomToolButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarCustomToolButtonProps> & RefAttributes<InkToolbarCustomToolButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarCustomToolButtonProps>, ref: React.ForwardedRef<InkToolbarCustomToolButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomToolButton' ref={ref} />);
export const InkToolbarCustomToolButton = (_InkToolbarCustomToolButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarCustomToolButtonProps> & RefAttributes<InkToolbarCustomToolButtonRef>>));

export type InkToolbarEraserButtonProps = Omit<NativeInkToolbarEraserButtonProps, 'type'>;
export type InkToolbarEraserButtonRef = React.Component<NativeInkToolbarEraserButtonProps> & Readonly<NativeMethods>;
const _InkToolbarEraserButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarEraserButtonProps> & RefAttributes<InkToolbarEraserButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarEraserButtonProps>, ref: React.ForwardedRef<InkToolbarEraserButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarEraserButton' ref={ref} />);
export const InkToolbarEraserButton = (_InkToolbarEraserButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarEraserButtonProps> & RefAttributes<InkToolbarEraserButtonRef>>));

export type InkToolbarFlyoutItemProps = Omit<NativeInkToolbarFlyoutItemProps, 'type'>;
export type InkToolbarFlyoutItemRef = React.Component<NativeInkToolbarFlyoutItemProps> & Readonly<NativeMethods>;
const _InkToolbarFlyoutItem : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarFlyoutItemProps> & RefAttributes<InkToolbarFlyoutItemRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarFlyoutItemProps>, ref: React.ForwardedRef<InkToolbarFlyoutItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarFlyoutItem' ref={ref} />);
export const InkToolbarFlyoutItem = (_InkToolbarFlyoutItem as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarFlyoutItemProps> & RefAttributes<InkToolbarFlyoutItemRef>>));

export type InkToolbarHighlighterButtonProps = Omit<NativeInkToolbarHighlighterButtonProps, 'type'>;
export type InkToolbarHighlighterButtonRef = React.Component<NativeInkToolbarHighlighterButtonProps> & Readonly<NativeMethods>;
const _InkToolbarHighlighterButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarHighlighterButtonProps> & RefAttributes<InkToolbarHighlighterButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarHighlighterButtonProps>, ref: React.ForwardedRef<InkToolbarHighlighterButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarHighlighterButton' ref={ref} />);
export const InkToolbarHighlighterButton = (_InkToolbarHighlighterButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarHighlighterButtonProps> & RefAttributes<InkToolbarHighlighterButtonRef>>));

export type InkToolbarPenConfigurationControlProps = Omit<NativeInkToolbarPenConfigurationControlProps, 'type'>;
export type InkToolbarPenConfigurationControlRef = React.Component<NativeInkToolbarPenConfigurationControlProps> & Readonly<NativeMethods>;
const _InkToolbarPenConfigurationControl : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarPenConfigurationControlProps> & RefAttributes<InkToolbarPenConfigurationControlRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarPenConfigurationControlProps>, ref: React.ForwardedRef<InkToolbarPenConfigurationControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarPenConfigurationControl' ref={ref} />);
export const InkToolbarPenConfigurationControl = (_InkToolbarPenConfigurationControl as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarPenConfigurationControlProps> & RefAttributes<InkToolbarPenConfigurationControlRef>>));

export type InkToolbarPencilButtonProps = Omit<NativeInkToolbarPencilButtonProps, 'type'>;
export type InkToolbarPencilButtonRef = React.Component<NativeInkToolbarPencilButtonProps> & Readonly<NativeMethods>;
const _InkToolbarPencilButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarPencilButtonProps> & RefAttributes<InkToolbarPencilButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarPencilButtonProps>, ref: React.ForwardedRef<InkToolbarPencilButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarPencilButton' ref={ref} />);
export const InkToolbarPencilButton = (_InkToolbarPencilButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarPencilButtonProps> & RefAttributes<InkToolbarPencilButtonRef>>));

export type InkToolbarRulerButtonProps = Omit<NativeInkToolbarRulerButtonProps, 'type'>;
export type InkToolbarRulerButtonRef = React.Component<NativeInkToolbarRulerButtonProps> & Readonly<NativeMethods>;
const _InkToolbarRulerButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarRulerButtonProps> & RefAttributes<InkToolbarRulerButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarRulerButtonProps>, ref: React.ForwardedRef<InkToolbarRulerButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarRulerButton' ref={ref} />);
export const InkToolbarRulerButton = (_InkToolbarRulerButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarRulerButtonProps> & RefAttributes<InkToolbarRulerButtonRef>>));

export type InkToolbarStencilButtonProps = Omit<NativeInkToolbarStencilButtonProps, 'type'>;
export type InkToolbarStencilButtonRef = React.Component<NativeInkToolbarStencilButtonProps> & Readonly<NativeMethods>;
const _InkToolbarStencilButton : (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarStencilButtonProps> & RefAttributes<InkToolbarStencilButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<InkToolbarStencilButtonProps>, ref: React.ForwardedRef<InkToolbarStencilButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarStencilButton' ref={ref} />);
export const InkToolbarStencilButton = (_InkToolbarStencilButton as (ForwardRefExoticComponent<React.PropsWithChildren<InkToolbarStencilButtonProps> & RefAttributes<InkToolbarStencilButtonRef>>));

export type ItemsPresenterProps = Omit<NativeItemsPresenterProps, 'type'>;
export type ItemsPresenterRef = React.Component<NativeItemsPresenterProps> & Readonly<NativeMethods>;
const _ItemsPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<ItemsPresenterProps> & RefAttributes<ItemsPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<ItemsPresenterProps>, ref: React.ForwardedRef<ItemsPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsPresenter' ref={ref} />);
export const ItemsPresenter = (_ItemsPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<ItemsPresenterProps> & RefAttributes<ItemsPresenterRef>>));

export type ItemsStackPanelProps = Omit<NativeItemsStackPanelProps, 'type'>;
export type ItemsStackPanelRef = React.Component<NativeItemsStackPanelProps> & Readonly<NativeMethods>;
const _ItemsStackPanel : (ForwardRefExoticComponent<React.PropsWithChildren<ItemsStackPanelProps> & RefAttributes<ItemsStackPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<ItemsStackPanelProps>, ref: React.ForwardedRef<ItemsStackPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsStackPanel' ref={ref} />);
export const ItemsStackPanel = (_ItemsStackPanel as (ForwardRefExoticComponent<React.PropsWithChildren<ItemsStackPanelProps> & RefAttributes<ItemsStackPanelRef>>));

export type ItemsWrapGridProps = Omit<NativeItemsWrapGridProps, 'type'>;
export type ItemsWrapGridRef = React.Component<NativeItemsWrapGridProps> & Readonly<NativeMethods>;
const _ItemsWrapGrid : (ForwardRefExoticComponent<React.PropsWithChildren<ItemsWrapGridProps> & RefAttributes<ItemsWrapGridRef>>) = React.forwardRef((props: React.PropsWithChildren<ItemsWrapGridProps>, ref: React.ForwardedRef<ItemsWrapGridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsWrapGrid' ref={ref} />);
export const ItemsWrapGrid = (_ItemsWrapGrid as (ForwardRefExoticComponent<React.PropsWithChildren<ItemsWrapGridProps> & RefAttributes<ItemsWrapGridRef>>));

export type ListBoxProps = Omit<NativeListBoxProps, 'type'>;
export type ListBoxRef = React.Component<NativeListBoxProps> & Readonly<NativeMethods>;
const _ListBox : (ForwardRefExoticComponent<React.PropsWithChildren<ListBoxProps> & RefAttributes<ListBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<ListBoxProps>, ref: React.ForwardedRef<ListBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListBox' ref={ref} />);
export const ListBox = (_ListBox as (ForwardRefExoticComponent<React.PropsWithChildren<ListBoxProps> & RefAttributes<ListBoxRef>>));

export type ListBoxItemProps = Omit<NativeListBoxItemProps, 'type'>;
export type ListBoxItemRef = React.Component<NativeListBoxItemProps> & Readonly<NativeMethods>;
const _ListBoxItem : (ForwardRefExoticComponent<React.PropsWithChildren<ListBoxItemProps> & RefAttributes<ListBoxItemRef>>) = React.forwardRef((props: React.PropsWithChildren<ListBoxItemProps>, ref: React.ForwardedRef<ListBoxItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListBoxItem' ref={ref} />);
export const ListBoxItem = (_ListBoxItem as (ForwardRefExoticComponent<React.PropsWithChildren<ListBoxItemProps> & RefAttributes<ListBoxItemRef>>));

export type ListPickerFlyoutProps = Omit<NativeListPickerFlyoutProps, 'type'>;
export type ListPickerFlyoutRef = React.Component<NativeListPickerFlyoutProps> & Readonly<NativeMethods>;
const _ListPickerFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<ListPickerFlyoutProps> & RefAttributes<ListPickerFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<ListPickerFlyoutProps>, ref: React.ForwardedRef<ListPickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListPickerFlyout' ref={ref} />);
export const ListPickerFlyout = (_ListPickerFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<ListPickerFlyoutProps> & RefAttributes<ListPickerFlyoutRef>>));

export type ListViewProps = Omit<NativeListViewProps, 'type'>;
export type ListViewRef = React.Component<NativeListViewProps> & Readonly<NativeMethods>;
const _ListView : (ForwardRefExoticComponent<React.PropsWithChildren<ListViewProps> & RefAttributes<ListViewRef>>) = React.forwardRef((props: React.PropsWithChildren<ListViewProps>, ref: React.ForwardedRef<ListViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListView' ref={ref} />);
export const ListView = (_ListView as (ForwardRefExoticComponent<React.PropsWithChildren<ListViewProps> & RefAttributes<ListViewRef>>));

export type ListViewHeaderItemProps = Omit<NativeListViewHeaderItemProps, 'type'>;
export type ListViewHeaderItemRef = React.Component<NativeListViewHeaderItemProps> & Readonly<NativeMethods>;
const _ListViewHeaderItem : (ForwardRefExoticComponent<React.PropsWithChildren<ListViewHeaderItemProps> & RefAttributes<ListViewHeaderItemRef>>) = React.forwardRef((props: React.PropsWithChildren<ListViewHeaderItemProps>, ref: React.ForwardedRef<ListViewHeaderItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListViewHeaderItem' ref={ref} />);
export const ListViewHeaderItem = (_ListViewHeaderItem as (ForwardRefExoticComponent<React.PropsWithChildren<ListViewHeaderItemProps> & RefAttributes<ListViewHeaderItemRef>>));

export type ListViewItemProps = Omit<NativeListViewItemProps, 'type'>;
export type ListViewItemRef = React.Component<NativeListViewItemProps> & Readonly<NativeMethods>;
const _ListViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<ListViewItemProps> & RefAttributes<ListViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<ListViewItemProps>, ref: React.ForwardedRef<ListViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListViewItem' ref={ref} />);
export const ListViewItem = (_ListViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<ListViewItemProps> & RefAttributes<ListViewItemRef>>));

export type MapControlProps = Omit<NativeMapControlProps, 'type'>;
export type MapControlRef = React.Component<NativeMapControlProps> & Readonly<NativeMethods>;
const _MapControl : (ForwardRefExoticComponent<React.PropsWithChildren<MapControlProps> & RefAttributes<MapControlRef>>) = React.forwardRef((props: React.PropsWithChildren<MapControlProps>, ref: React.ForwardedRef<MapControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Maps.MapControl' ref={ref} />);
export const MapControl = (_MapControl as (ForwardRefExoticComponent<React.PropsWithChildren<MapControlProps> & RefAttributes<MapControlRef>>));

export type MediaElementProps = Omit<NativeMediaElementProps, 'type'>;
export type MediaElementRef = React.Component<NativeMediaElementProps> & Readonly<NativeMethods>;
const _MediaElement : (ForwardRefExoticComponent<React.PropsWithChildren<MediaElementProps> & RefAttributes<MediaElementRef>>) = React.forwardRef((props: React.PropsWithChildren<MediaElementProps>, ref: React.ForwardedRef<MediaElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaElement' ref={ref} />);
export const MediaElement = (_MediaElement as (ForwardRefExoticComponent<React.PropsWithChildren<MediaElementProps> & RefAttributes<MediaElementRef>>));

export type MediaPlayerElementProps = Omit<NativeMediaPlayerElementProps, 'type'>;
export type MediaPlayerElementRef = React.Component<NativeMediaPlayerElementProps> & Readonly<NativeMethods>;
const _MediaPlayerElement : (ForwardRefExoticComponent<React.PropsWithChildren<MediaPlayerElementProps> & RefAttributes<MediaPlayerElementRef>>) = React.forwardRef((props: React.PropsWithChildren<MediaPlayerElementProps>, ref: React.ForwardedRef<MediaPlayerElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaPlayerElement' ref={ref} />);
export const MediaPlayerElement = (_MediaPlayerElement as (ForwardRefExoticComponent<React.PropsWithChildren<MediaPlayerElementProps> & RefAttributes<MediaPlayerElementRef>>));

export type MediaPlayerPresenterProps = Omit<NativeMediaPlayerPresenterProps, 'type'>;
export type MediaPlayerPresenterRef = React.Component<NativeMediaPlayerPresenterProps> & Readonly<NativeMethods>;
const _MediaPlayerPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<MediaPlayerPresenterProps> & RefAttributes<MediaPlayerPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<MediaPlayerPresenterProps>, ref: React.ForwardedRef<MediaPlayerPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaPlayerPresenter' ref={ref} />);
export const MediaPlayerPresenter = (_MediaPlayerPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<MediaPlayerPresenterProps> & RefAttributes<MediaPlayerPresenterRef>>));

export type MediaTransportControlsProps = Omit<NativeMediaTransportControlsProps, 'type'>;
export type MediaTransportControlsRef = React.Component<NativeMediaTransportControlsProps> & Readonly<NativeMethods>;
const _MediaTransportControls : (ForwardRefExoticComponent<React.PropsWithChildren<MediaTransportControlsProps> & RefAttributes<MediaTransportControlsRef>>) = React.forwardRef((props: React.PropsWithChildren<MediaTransportControlsProps>, ref: React.ForwardedRef<MediaTransportControlsRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaTransportControls' ref={ref} />);
export const MediaTransportControls = (_MediaTransportControls as (ForwardRefExoticComponent<React.PropsWithChildren<MediaTransportControlsProps> & RefAttributes<MediaTransportControlsRef>>));

export type MenuBarProps = Omit<NativeMenuBarProps, 'type'>;
export type MenuBarRef = React.Component<NativeMenuBarProps> & Readonly<NativeMethods>;
const _MenuBar : (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarProps> & RefAttributes<MenuBarRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuBarProps>, ref: React.ForwardedRef<MenuBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBar' ref={ref} />);
export const MenuBar = (_MenuBar as (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarProps> & RefAttributes<MenuBarRef>>));

export type MenuBarItemProps = Omit<NativeMenuBarItemProps, 'type'>;
export type MenuBarItemRef = React.Component<NativeMenuBarItemProps> & Readonly<NativeMethods>;
const _MenuBarItem : (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemProps> & RefAttributes<MenuBarItemRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuBarItemProps>, ref: React.ForwardedRef<MenuBarItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBarItem' ref={ref} />);
export const MenuBarItem = (_MenuBarItem as (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemProps> & RefAttributes<MenuBarItemRef>>));

export type MenuFlyoutProps = Omit<NativeMenuFlyoutProps, 'type'>;
export type MenuFlyoutRef = React.Component<NativeMenuFlyoutProps> & Readonly<NativeMethods>;
export interface NativeMethodsFor_MenuFlyout {
  ShowAt: (ref: React.RefObject<MenuFlyoutRef>, args: { point: Point,  }) => void;
}
const _MenuFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutProps> & RefAttributes<MenuFlyoutRef>> & Partial<NativeMethodsFor_MenuFlyout>) = React.forwardRef((props: React.PropsWithChildren<MenuFlyoutProps>, ref: React.ForwardedRef<MenuFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyout' ref={ref} />);
_MenuFlyout.ShowAt = (ref: React.RefObject<MenuFlyoutRef>, args: { point: Point,  }) => {
  const tag = findNodeHandle(ref.current);
  UIManager.dispatchViewManagerCommand(tag, UIManager.getViewManagerConfig('XamlControl').Commands.ShowAt, [args]);
};
export const MenuFlyout = (_MenuFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutProps> & RefAttributes<MenuFlyoutRef>> & NativeMethodsFor_MenuFlyout));

export type MenuBarItemFlyoutProps = Omit<NativeMenuBarItemFlyoutProps, 'type'>;
export type MenuBarItemFlyoutRef = React.Component<NativeMenuBarItemFlyoutProps> & Readonly<NativeMethods>;
const _MenuBarItemFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemFlyoutProps> & RefAttributes<MenuBarItemFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuBarItemFlyoutProps>, ref: React.ForwardedRef<MenuBarItemFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBarItemFlyout' ref={ref} />);
export const MenuBarItemFlyout = (_MenuBarItemFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<MenuBarItemFlyoutProps> & RefAttributes<MenuBarItemFlyoutRef>>));

export type MenuFlyoutItemProps = Omit<NativeMenuFlyoutItemProps, 'type'>;
export type MenuFlyoutItemRef = React.Component<NativeMenuFlyoutItemProps> & Readonly<NativeMethods>;
const _MenuFlyoutItem : (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutItemProps> & RefAttributes<MenuFlyoutItemRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuFlyoutItemProps>, ref: React.ForwardedRef<MenuFlyoutItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutItem' ref={ref} />);
export const MenuFlyoutItem = (_MenuFlyoutItem as (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutItemProps> & RefAttributes<MenuFlyoutItemRef>>));

export type MenuFlyoutPresenterProps = Omit<NativeMenuFlyoutPresenterProps, 'type'>;
export type MenuFlyoutPresenterRef = React.Component<NativeMenuFlyoutPresenterProps> & Readonly<NativeMethods>;
const _MenuFlyoutPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutPresenterProps> & RefAttributes<MenuFlyoutPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuFlyoutPresenterProps>, ref: React.ForwardedRef<MenuFlyoutPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutPresenter' ref={ref} />);
export const MenuFlyoutPresenter = (_MenuFlyoutPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutPresenterProps> & RefAttributes<MenuFlyoutPresenterRef>>));

export type MenuFlyoutSeparatorProps = Omit<NativeMenuFlyoutSeparatorProps, 'type'>;
export type MenuFlyoutSeparatorRef = React.Component<NativeMenuFlyoutSeparatorProps> & Readonly<NativeMethods>;
const _MenuFlyoutSeparator : (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutSeparatorProps> & RefAttributes<MenuFlyoutSeparatorRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuFlyoutSeparatorProps>, ref: React.ForwardedRef<MenuFlyoutSeparatorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutSeparator' ref={ref} />);
export const MenuFlyoutSeparator = (_MenuFlyoutSeparator as (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutSeparatorProps> & RefAttributes<MenuFlyoutSeparatorRef>>));

export type MenuFlyoutSubItemProps = Omit<NativeMenuFlyoutSubItemProps, 'type'>;
export type MenuFlyoutSubItemRef = React.Component<NativeMenuFlyoutSubItemProps> & Readonly<NativeMethods>;
const _MenuFlyoutSubItem : (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutSubItemProps> & RefAttributes<MenuFlyoutSubItemRef>>) = React.forwardRef((props: React.PropsWithChildren<MenuFlyoutSubItemProps>, ref: React.ForwardedRef<MenuFlyoutSubItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutSubItem' ref={ref} />);
export const MenuFlyoutSubItem = (_MenuFlyoutSubItem as (ForwardRefExoticComponent<React.PropsWithChildren<MenuFlyoutSubItemProps> & RefAttributes<MenuFlyoutSubItemRef>>));

export type NavigationViewProps = Omit<NativeNavigationViewProps, 'type'>;
export type NavigationViewRef = React.Component<NativeNavigationViewProps> & Readonly<NativeMethods>;
const _NavigationView : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewProps> & RefAttributes<NavigationViewRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewProps>, ref: React.ForwardedRef<NavigationViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationView' ref={ref} />);
export const NavigationView = (_NavigationView as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewProps> & RefAttributes<NavigationViewRef>>));

export type NavigationViewItemProps = Omit<NativeNavigationViewItemProps, 'type'>;
export type NavigationViewItemRef = React.Component<NativeNavigationViewItemProps> & Readonly<NativeMethods>;
const _NavigationViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemProps> & RefAttributes<NavigationViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemProps>, ref: React.ForwardedRef<NavigationViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItem' ref={ref} />);
export const NavigationViewItem = (_NavigationViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemProps> & RefAttributes<NavigationViewItemRef>>));

export type NavigationViewItemHeaderProps = Omit<NativeNavigationViewItemHeaderProps, 'type'>;
export type NavigationViewItemHeaderRef = React.Component<NativeNavigationViewItemHeaderProps> & Readonly<NativeMethods>;
const _NavigationViewItemHeader : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemHeaderProps> & RefAttributes<NavigationViewItemHeaderRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemHeaderProps>, ref: React.ForwardedRef<NavigationViewItemHeaderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItemHeader' ref={ref} />);
export const NavigationViewItemHeader = (_NavigationViewItemHeader as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemHeaderProps> & RefAttributes<NavigationViewItemHeaderRef>>));

export type NavigationViewItemSeparatorProps = Omit<NativeNavigationViewItemSeparatorProps, 'type'>;
export type NavigationViewItemSeparatorRef = React.Component<NativeNavigationViewItemSeparatorProps> & Readonly<NativeMethods>;
const _NavigationViewItemSeparator : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemSeparatorProps> & RefAttributes<NavigationViewItemSeparatorRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemSeparatorProps>, ref: React.ForwardedRef<NavigationViewItemSeparatorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItemSeparator' ref={ref} />);
export const NavigationViewItemSeparator = (_NavigationViewItemSeparator as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemSeparatorProps> & RefAttributes<NavigationViewItemSeparatorRef>>));

export type NavigationViewListProps = Omit<NativeNavigationViewListProps, 'type'>;
export type NavigationViewListRef = React.Component<NativeNavigationViewListProps> & Readonly<NativeMethods>;
const _NavigationViewList : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewListProps> & RefAttributes<NavigationViewListRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewListProps>, ref: React.ForwardedRef<NavigationViewListRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewList' ref={ref} />);
export const NavigationViewList = (_NavigationViewList as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewListProps> & RefAttributes<NavigationViewListRef>>));

export type UserControlProps = Omit<NativeUserControlProps, 'type'>;
export type UserControlRef = React.Component<NativeUserControlProps> & Readonly<NativeMethods>;
const _UserControl : (ForwardRefExoticComponent<React.PropsWithChildren<UserControlProps> & RefAttributes<UserControlRef>>) = React.forwardRef((props: React.PropsWithChildren<UserControlProps>, ref: React.ForwardedRef<UserControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.UserControl' ref={ref} />);
export const UserControl = (_UserControl as (ForwardRefExoticComponent<React.PropsWithChildren<UserControlProps> & RefAttributes<UserControlRef>>));

export type PageProps = Omit<NativePageProps, 'type'>;
export type PageRef = React.Component<NativePageProps> & Readonly<NativeMethods>;
const _Page : (ForwardRefExoticComponent<React.PropsWithChildren<PageProps> & RefAttributes<PageRef>>) = React.forwardRef((props: React.PropsWithChildren<PageProps>, ref: React.ForwardedRef<PageRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Page' ref={ref} />);
export const Page = (_Page as (ForwardRefExoticComponent<React.PropsWithChildren<PageProps> & RefAttributes<PageRef>>));

export type ParallaxViewProps = Omit<NativeParallaxViewProps, 'type'>;
export type ParallaxViewRef = React.Component<NativeParallaxViewProps> & Readonly<NativeMethods>;
const _ParallaxView : (ForwardRefExoticComponent<React.PropsWithChildren<ParallaxViewProps> & RefAttributes<ParallaxViewRef>>) = React.forwardRef((props: React.PropsWithChildren<ParallaxViewProps>, ref: React.ForwardedRef<ParallaxViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ParallaxView' ref={ref} />);
export const ParallaxView = (_ParallaxView as (ForwardRefExoticComponent<React.PropsWithChildren<ParallaxViewProps> & RefAttributes<ParallaxViewRef>>));

export type PasswordBoxProps = Omit<NativePasswordBoxProps, 'type'>;
export type PasswordBoxRef = React.Component<NativePasswordBoxProps> & Readonly<NativeMethods>;
const _PasswordBox : (ForwardRefExoticComponent<React.PropsWithChildren<PasswordBoxProps> & RefAttributes<PasswordBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<PasswordBoxProps>, ref: React.ForwardedRef<PasswordBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PasswordBox' ref={ref} />);
export const PasswordBox = (_PasswordBox as (ForwardRefExoticComponent<React.PropsWithChildren<PasswordBoxProps> & RefAttributes<PasswordBoxRef>>));

export type PathIconProps = Omit<NativePathIconProps, 'type'>;
export type PathIconRef = React.Component<NativePathIconProps> & Readonly<NativeMethods>;
const _PathIcon : (ForwardRefExoticComponent<React.PropsWithChildren<PathIconProps> & RefAttributes<PathIconRef>>) = React.forwardRef((props: React.PropsWithChildren<PathIconProps>, ref: React.ForwardedRef<PathIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PathIcon' ref={ref} />);
export const PathIcon = (_PathIcon as (ForwardRefExoticComponent<React.PropsWithChildren<PathIconProps> & RefAttributes<PathIconRef>>));

export type PersonPictureProps = Omit<NativePersonPictureProps, 'type'>;
export type PersonPictureRef = React.Component<NativePersonPictureProps> & Readonly<NativeMethods>;
const _PersonPicture : (ForwardRefExoticComponent<React.PropsWithChildren<PersonPictureProps> & RefAttributes<PersonPictureRef>>) = React.forwardRef((props: React.PropsWithChildren<PersonPictureProps>, ref: React.ForwardedRef<PersonPictureRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PersonPicture' ref={ref} />);
export const PersonPicture = (_PersonPicture as (ForwardRefExoticComponent<React.PropsWithChildren<PersonPictureProps> & RefAttributes<PersonPictureRef>>));

export type PickerFlyoutProps = Omit<NativePickerFlyoutProps, 'type'>;
export type PickerFlyoutRef = React.Component<NativePickerFlyoutProps> & Readonly<NativeMethods>;
const _PickerFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<PickerFlyoutProps> & RefAttributes<PickerFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<PickerFlyoutProps>, ref: React.ForwardedRef<PickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PickerFlyout' ref={ref} />);
export const PickerFlyout = (_PickerFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<PickerFlyoutProps> & RefAttributes<PickerFlyoutRef>>));

export type PivotProps = Omit<NativePivotProps, 'type'>;
export type PivotRef = React.Component<NativePivotProps> & Readonly<NativeMethods>;
const _Pivot : (ForwardRefExoticComponent<React.PropsWithChildren<PivotProps> & RefAttributes<PivotRef>>) = React.forwardRef((props: React.PropsWithChildren<PivotProps>, ref: React.ForwardedRef<PivotRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Pivot' ref={ref} />);
export const Pivot = (_Pivot as (ForwardRefExoticComponent<React.PropsWithChildren<PivotProps> & RefAttributes<PivotRef>>));

export type PivotItemProps = Omit<NativePivotItemProps, 'type'>;
export type PivotItemRef = React.Component<NativePivotItemProps> & Readonly<NativeMethods>;
const _PivotItem : (ForwardRefExoticComponent<React.PropsWithChildren<PivotItemProps> & RefAttributes<PivotItemRef>>) = React.forwardRef((props: React.PropsWithChildren<PivotItemProps>, ref: React.ForwardedRef<PivotItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PivotItem' ref={ref} />);
export const PivotItem = (_PivotItem as (ForwardRefExoticComponent<React.PropsWithChildren<PivotItemProps> & RefAttributes<PivotItemRef>>));

export type CalendarPanelProps = Omit<NativeCalendarPanelProps, 'type'>;
export type CalendarPanelRef = React.Component<NativeCalendarPanelProps> & Readonly<NativeMethods>;
const _CalendarPanel : (ForwardRefExoticComponent<React.PropsWithChildren<CalendarPanelProps> & RefAttributes<CalendarPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<CalendarPanelProps>, ref: React.ForwardedRef<CalendarPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CalendarPanel' ref={ref} />);
export const CalendarPanel = (_CalendarPanel as (ForwardRefExoticComponent<React.PropsWithChildren<CalendarPanelProps> & RefAttributes<CalendarPanelRef>>));

export type CarouselPanelProps = Omit<NativeCarouselPanelProps, 'type'>;
export type CarouselPanelRef = React.Component<NativeCarouselPanelProps> & Readonly<NativeMethods>;
const _CarouselPanel : (ForwardRefExoticComponent<React.PropsWithChildren<CarouselPanelProps> & RefAttributes<CarouselPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<CarouselPanelProps>, ref: React.ForwardedRef<CarouselPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CarouselPanel' ref={ref} />);
export const CarouselPanel = (_CarouselPanel as (ForwardRefExoticComponent<React.PropsWithChildren<CarouselPanelProps> & RefAttributes<CarouselPanelRef>>));

export type SliderProps = Omit<NativeSliderProps, 'type'>;
export type SliderRef = React.Component<NativeSliderProps> & Readonly<NativeMethods>;
const _Slider : (ForwardRefExoticComponent<React.PropsWithChildren<SliderProps> & RefAttributes<SliderRef>>) = React.forwardRef((props: React.PropsWithChildren<SliderProps>, ref: React.ForwardedRef<SliderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Slider' ref={ref} />);
export const Slider = (_Slider as (ForwardRefExoticComponent<React.PropsWithChildren<SliderProps> & RefAttributes<SliderRef>>));

export type ColorPickerSliderProps = Omit<NativeColorPickerSliderProps, 'type'>;
export type ColorPickerSliderRef = React.Component<NativeColorPickerSliderProps> & Readonly<NativeMethods>;
const _ColorPickerSlider : (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerSliderProps> & RefAttributes<ColorPickerSliderRef>>) = React.forwardRef((props: React.PropsWithChildren<ColorPickerSliderProps>, ref: React.ForwardedRef<ColorPickerSliderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ColorPickerSlider' ref={ref} />);
export const ColorPickerSlider = (_ColorPickerSlider as (ForwardRefExoticComponent<React.PropsWithChildren<ColorPickerSliderProps> & RefAttributes<ColorPickerSliderRef>>));

export type ColorSpectrumProps = Omit<NativeColorSpectrumProps, 'type'>;
export type ColorSpectrumRef = React.Component<NativeColorSpectrumProps> & Readonly<NativeMethods>;
const _ColorSpectrum : (ForwardRefExoticComponent<React.PropsWithChildren<ColorSpectrumProps> & RefAttributes<ColorSpectrumRef>>) = React.forwardRef((props: React.PropsWithChildren<ColorSpectrumProps>, ref: React.ForwardedRef<ColorSpectrumRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ColorSpectrum' ref={ref} />);
export const ColorSpectrum = (_ColorSpectrum as (ForwardRefExoticComponent<React.PropsWithChildren<ColorSpectrumProps> & RefAttributes<ColorSpectrumRef>>));

export type CommandBarFlyoutCommandBarProps = Omit<NativeCommandBarFlyoutCommandBarProps, 'type'>;
export type CommandBarFlyoutCommandBarRef = React.Component<NativeCommandBarFlyoutCommandBarProps> & Readonly<NativeMethods>;
const _CommandBarFlyoutCommandBar : (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutCommandBarProps> & RefAttributes<CommandBarFlyoutCommandBarRef>>) = React.forwardRef((props: React.PropsWithChildren<CommandBarFlyoutCommandBarProps>, ref: React.ForwardedRef<CommandBarFlyoutCommandBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBar' ref={ref} />);
export const CommandBarFlyoutCommandBar = (_CommandBarFlyoutCommandBar as (ForwardRefExoticComponent<React.PropsWithChildren<CommandBarFlyoutCommandBarProps> & RefAttributes<CommandBarFlyoutCommandBarRef>>));

export type GridViewItemPresenterProps = Omit<NativeGridViewItemPresenterProps, 'type'>;
export type GridViewItemPresenterRef = React.Component<NativeGridViewItemPresenterProps> & Readonly<NativeMethods>;
const _GridViewItemPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<GridViewItemPresenterProps> & RefAttributes<GridViewItemPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<GridViewItemPresenterProps>, ref: React.ForwardedRef<GridViewItemPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.GridViewItemPresenter' ref={ref} />);
export const GridViewItemPresenter = (_GridViewItemPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<GridViewItemPresenterProps> & RefAttributes<GridViewItemPresenterRef>>));

export type ListViewItemPresenterProps = Omit<NativeListViewItemPresenterProps, 'type'>;
export type ListViewItemPresenterRef = React.Component<NativeListViewItemPresenterProps> & Readonly<NativeMethods>;
const _ListViewItemPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<ListViewItemPresenterProps> & RefAttributes<ListViewItemPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<ListViewItemPresenterProps>, ref: React.ForwardedRef<ListViewItemPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ListViewItemPresenter' ref={ref} />);
export const ListViewItemPresenter = (_ListViewItemPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<ListViewItemPresenterProps> & RefAttributes<ListViewItemPresenterRef>>));

export type NavigationViewItemPresenterProps = Omit<NativeNavigationViewItemPresenterProps, 'type'>;
export type NavigationViewItemPresenterRef = React.Component<NativeNavigationViewItemPresenterProps> & Readonly<NativeMethods>;
const _NavigationViewItemPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemPresenterProps> & RefAttributes<NavigationViewItemPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<NavigationViewItemPresenterProps>, ref: React.ForwardedRef<NavigationViewItemPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.NavigationViewItemPresenter' ref={ref} />);
export const NavigationViewItemPresenter = (_NavigationViewItemPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<NavigationViewItemPresenterProps> & RefAttributes<NavigationViewItemPresenterRef>>));

export type PivotHeaderItemProps = Omit<NativePivotHeaderItemProps, 'type'>;
export type PivotHeaderItemRef = React.Component<NativePivotHeaderItemProps> & Readonly<NativeMethods>;
const _PivotHeaderItem : (ForwardRefExoticComponent<React.PropsWithChildren<PivotHeaderItemProps> & RefAttributes<PivotHeaderItemRef>>) = React.forwardRef((props: React.PropsWithChildren<PivotHeaderItemProps>, ref: React.ForwardedRef<PivotHeaderItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotHeaderItem' ref={ref} />);
export const PivotHeaderItem = (_PivotHeaderItem as (ForwardRefExoticComponent<React.PropsWithChildren<PivotHeaderItemProps> & RefAttributes<PivotHeaderItemRef>>));

export type PivotHeaderPanelProps = Omit<NativePivotHeaderPanelProps, 'type'>;
export type PivotHeaderPanelRef = React.Component<NativePivotHeaderPanelProps> & Readonly<NativeMethods>;
const _PivotHeaderPanel : (ForwardRefExoticComponent<React.PropsWithChildren<PivotHeaderPanelProps> & RefAttributes<PivotHeaderPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<PivotHeaderPanelProps>, ref: React.ForwardedRef<PivotHeaderPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotHeaderPanel' ref={ref} />);
export const PivotHeaderPanel = (_PivotHeaderPanel as (ForwardRefExoticComponent<React.PropsWithChildren<PivotHeaderPanelProps> & RefAttributes<PivotHeaderPanelRef>>));

export type PivotPanelProps = Omit<NativePivotPanelProps, 'type'>;
export type PivotPanelRef = React.Component<NativePivotPanelProps> & Readonly<NativeMethods>;
const _PivotPanel : (ForwardRefExoticComponent<React.PropsWithChildren<PivotPanelProps> & RefAttributes<PivotPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<PivotPanelProps>, ref: React.ForwardedRef<PivotPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotPanel' ref={ref} />);
export const PivotPanel = (_PivotPanel as (ForwardRefExoticComponent<React.PropsWithChildren<PivotPanelProps> & RefAttributes<PivotPanelRef>>));

export type PopupProps = Omit<NativePopupProps, 'type'>;
export type PopupRef = React.Component<NativePopupProps> & Readonly<NativeMethods>;
const _Popup : (ForwardRefExoticComponent<React.PropsWithChildren<PopupProps> & RefAttributes<PopupRef>>) = React.forwardRef((props: React.PropsWithChildren<PopupProps>, ref: React.ForwardedRef<PopupRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.Popup' ref={ref} />);
export const Popup = (_Popup as (ForwardRefExoticComponent<React.PropsWithChildren<PopupProps> & RefAttributes<PopupRef>>));

export type RepeatButtonProps = Omit<NativeRepeatButtonProps, 'type'>;
export type RepeatButtonRef = React.Component<NativeRepeatButtonProps> & Readonly<NativeMethods>;
const _RepeatButton : (ForwardRefExoticComponent<React.PropsWithChildren<RepeatButtonProps> & RefAttributes<RepeatButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<RepeatButtonProps>, ref: React.ForwardedRef<RepeatButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.RepeatButton' ref={ref} />);
export const RepeatButton = (_RepeatButton as (ForwardRefExoticComponent<React.PropsWithChildren<RepeatButtonProps> & RefAttributes<RepeatButtonRef>>));

export type ScrollBarProps = Omit<NativeScrollBarProps, 'type'>;
export type ScrollBarRef = React.Component<NativeScrollBarProps> & Readonly<NativeMethods>;
const _ScrollBar : (ForwardRefExoticComponent<React.PropsWithChildren<ScrollBarProps> & RefAttributes<ScrollBarRef>>) = React.forwardRef((props: React.PropsWithChildren<ScrollBarProps>, ref: React.ForwardedRef<ScrollBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ScrollBar' ref={ref} />);
export const ScrollBar = (_ScrollBar as (ForwardRefExoticComponent<React.PropsWithChildren<ScrollBarProps> & RefAttributes<ScrollBarRef>>));

export type ThumbProps = Omit<NativeThumbProps, 'type'>;
export type ThumbRef = React.Component<NativeThumbProps> & Readonly<NativeMethods>;
const _Thumb : (ForwardRefExoticComponent<React.PropsWithChildren<ThumbProps> & RefAttributes<ThumbRef>>) = React.forwardRef((props: React.PropsWithChildren<ThumbProps>, ref: React.ForwardedRef<ThumbRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.Thumb' ref={ref} />);
export const Thumb = (_Thumb as (ForwardRefExoticComponent<React.PropsWithChildren<ThumbProps> & RefAttributes<ThumbRef>>));

export type TickBarProps = Omit<NativeTickBarProps, 'type'>;
export type TickBarRef = React.Component<NativeTickBarProps> & Readonly<NativeMethods>;
const _TickBar : (ForwardRefExoticComponent<React.PropsWithChildren<TickBarProps> & RefAttributes<TickBarRef>>) = React.forwardRef((props: React.PropsWithChildren<TickBarProps>, ref: React.ForwardedRef<TickBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.TickBar' ref={ref} />);
export const TickBar = (_TickBar as (ForwardRefExoticComponent<React.PropsWithChildren<TickBarProps> & RefAttributes<TickBarRef>>));

export type ProgressBarProps = Omit<NativeProgressBarProps, 'type'>;
export type ProgressBarRef = React.Component<NativeProgressBarProps> & Readonly<NativeMethods>;
const _ProgressBar : (ForwardRefExoticComponent<React.PropsWithChildren<ProgressBarProps> & RefAttributes<ProgressBarRef>>) = React.forwardRef((props: React.PropsWithChildren<ProgressBarProps>, ref: React.ForwardedRef<ProgressBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ProgressBar' ref={ref} />);
export const ProgressBar = (_ProgressBar as (ForwardRefExoticComponent<React.PropsWithChildren<ProgressBarProps> & RefAttributes<ProgressBarRef>>));

export type ProgressRingProps = Omit<NativeProgressRingProps, 'type'>;
export type ProgressRingRef = React.Component<NativeProgressRingProps> & Readonly<NativeMethods>;
const _ProgressRing : (ForwardRefExoticComponent<React.PropsWithChildren<ProgressRingProps> & RefAttributes<ProgressRingRef>>) = React.forwardRef((props: React.PropsWithChildren<ProgressRingProps>, ref: React.ForwardedRef<ProgressRingRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ProgressRing' ref={ref} />);
export const ProgressRing = (_ProgressRing as (ForwardRefExoticComponent<React.PropsWithChildren<ProgressRingProps> & RefAttributes<ProgressRingRef>>));

export type RatingControlProps = Omit<NativeRatingControlProps, 'type'>;
export type RatingControlRef = React.Component<NativeRatingControlProps> & Readonly<NativeMethods>;
const _RatingControl : (ForwardRefExoticComponent<React.PropsWithChildren<RatingControlProps> & RefAttributes<RatingControlRef>>) = React.forwardRef((props: React.PropsWithChildren<RatingControlProps>, ref: React.ForwardedRef<RatingControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RatingControl' ref={ref} />);
export const RatingControl = (_RatingControl as (ForwardRefExoticComponent<React.PropsWithChildren<RatingControlProps> & RefAttributes<RatingControlRef>>));

export type RefreshContainerProps = Omit<NativeRefreshContainerProps, 'type'>;
export type RefreshContainerRef = React.Component<NativeRefreshContainerProps> & Readonly<NativeMethods>;
const _RefreshContainer : (ForwardRefExoticComponent<React.PropsWithChildren<RefreshContainerProps> & RefAttributes<RefreshContainerRef>>) = React.forwardRef((props: React.PropsWithChildren<RefreshContainerProps>, ref: React.ForwardedRef<RefreshContainerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RefreshContainer' ref={ref} />);
export const RefreshContainer = (_RefreshContainer as (ForwardRefExoticComponent<React.PropsWithChildren<RefreshContainerProps> & RefAttributes<RefreshContainerRef>>));

export type RefreshVisualizerProps = Omit<NativeRefreshVisualizerProps, 'type'>;
export type RefreshVisualizerRef = React.Component<NativeRefreshVisualizerProps> & Readonly<NativeMethods>;
const _RefreshVisualizer : (ForwardRefExoticComponent<React.PropsWithChildren<RefreshVisualizerProps> & RefAttributes<RefreshVisualizerRef>>) = React.forwardRef((props: React.PropsWithChildren<RefreshVisualizerProps>, ref: React.ForwardedRef<RefreshVisualizerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RefreshVisualizer' ref={ref} />);
export const RefreshVisualizer = (_RefreshVisualizer as (ForwardRefExoticComponent<React.PropsWithChildren<RefreshVisualizerProps> & RefAttributes<RefreshVisualizerRef>>));

export type RelativePanelProps = Omit<NativeRelativePanelProps, 'type'>;
export type RelativePanelRef = React.Component<NativeRelativePanelProps> & Readonly<NativeMethods>;
const _RelativePanel : (ForwardRefExoticComponent<React.PropsWithChildren<RelativePanelProps> & RefAttributes<RelativePanelRef>>) = React.forwardRef((props: React.PropsWithChildren<RelativePanelProps>, ref: React.ForwardedRef<RelativePanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RelativePanel' ref={ref} />);
export const RelativePanel = (_RelativePanel as (ForwardRefExoticComponent<React.PropsWithChildren<RelativePanelProps> & RefAttributes<RelativePanelRef>>));

export type RichEditBoxProps = Omit<NativeRichEditBoxProps, 'type'>;
export type RichEditBoxRef = React.Component<NativeRichEditBoxProps> & Readonly<NativeMethods>;
const _RichEditBox : (ForwardRefExoticComponent<React.PropsWithChildren<RichEditBoxProps> & RefAttributes<RichEditBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<RichEditBoxProps>, ref: React.ForwardedRef<RichEditBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichEditBox' ref={ref} />);
export const RichEditBox = (_RichEditBox as (ForwardRefExoticComponent<React.PropsWithChildren<RichEditBoxProps> & RefAttributes<RichEditBoxRef>>));

export type RichTextBlockProps = Omit<NativeRichTextBlockProps, 'type'>;
export type RichTextBlockRef = React.Component<NativeRichTextBlockProps> & Readonly<NativeMethods>;
const _RichTextBlock : (ForwardRefExoticComponent<React.PropsWithChildren<RichTextBlockProps> & RefAttributes<RichTextBlockRef>>) = React.forwardRef((props: React.PropsWithChildren<RichTextBlockProps>, ref: React.ForwardedRef<RichTextBlockRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichTextBlock' ref={ref} />);
export const RichTextBlock = (_RichTextBlock as (ForwardRefExoticComponent<React.PropsWithChildren<RichTextBlockProps> & RefAttributes<RichTextBlockRef>>));

export type RichTextBlockOverflowProps = Omit<NativeRichTextBlockOverflowProps, 'type'>;
export type RichTextBlockOverflowRef = React.Component<NativeRichTextBlockOverflowProps> & Readonly<NativeMethods>;
const _RichTextBlockOverflow : (ForwardRefExoticComponent<React.PropsWithChildren<RichTextBlockOverflowProps> & RefAttributes<RichTextBlockOverflowRef>>) = React.forwardRef((props: React.PropsWithChildren<RichTextBlockOverflowProps>, ref: React.ForwardedRef<RichTextBlockOverflowRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichTextBlockOverflow' ref={ref} />);
export const RichTextBlockOverflow = (_RichTextBlockOverflow as (ForwardRefExoticComponent<React.PropsWithChildren<RichTextBlockOverflowProps> & RefAttributes<RichTextBlockOverflowRef>>));

export type ScrollContentPresenterProps = Omit<NativeScrollContentPresenterProps, 'type'>;
export type ScrollContentPresenterRef = React.Component<NativeScrollContentPresenterProps> & Readonly<NativeMethods>;
const _ScrollContentPresenter : (ForwardRefExoticComponent<React.PropsWithChildren<ScrollContentPresenterProps> & RefAttributes<ScrollContentPresenterRef>>) = React.forwardRef((props: React.PropsWithChildren<ScrollContentPresenterProps>, ref: React.ForwardedRef<ScrollContentPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ScrollContentPresenter' ref={ref} />);
export const ScrollContentPresenter = (_ScrollContentPresenter as (ForwardRefExoticComponent<React.PropsWithChildren<ScrollContentPresenterProps> & RefAttributes<ScrollContentPresenterRef>>));

export type ScrollViewerProps = Omit<NativeScrollViewerProps, 'type'>;
export type ScrollViewerRef = React.Component<NativeScrollViewerProps> & Readonly<NativeMethods>;
const _ScrollViewer : (ForwardRefExoticComponent<React.PropsWithChildren<ScrollViewerProps> & RefAttributes<ScrollViewerRef>>) = React.forwardRef((props: React.PropsWithChildren<ScrollViewerProps>, ref: React.ForwardedRef<ScrollViewerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ScrollViewer' ref={ref} />);
export const ScrollViewer = (_ScrollViewer as (ForwardRefExoticComponent<React.PropsWithChildren<ScrollViewerProps> & RefAttributes<ScrollViewerRef>>));

export type SearchBoxProps = Omit<NativeSearchBoxProps, 'type'>;
export type SearchBoxRef = React.Component<NativeSearchBoxProps> & Readonly<NativeMethods>;
const _SearchBox : (ForwardRefExoticComponent<React.PropsWithChildren<SearchBoxProps> & RefAttributes<SearchBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<SearchBoxProps>, ref: React.ForwardedRef<SearchBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SearchBox' ref={ref} />);
export const SearchBox = (_SearchBox as (ForwardRefExoticComponent<React.PropsWithChildren<SearchBoxProps> & RefAttributes<SearchBoxRef>>));

export type SemanticZoomProps = Omit<NativeSemanticZoomProps, 'type'>;
export type SemanticZoomRef = React.Component<NativeSemanticZoomProps> & Readonly<NativeMethods>;
const _SemanticZoom : (ForwardRefExoticComponent<React.PropsWithChildren<SemanticZoomProps> & RefAttributes<SemanticZoomRef>>) = React.forwardRef((props: React.PropsWithChildren<SemanticZoomProps>, ref: React.ForwardedRef<SemanticZoomRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SemanticZoom' ref={ref} />);
export const SemanticZoom = (_SemanticZoom as (ForwardRefExoticComponent<React.PropsWithChildren<SemanticZoomProps> & RefAttributes<SemanticZoomRef>>));

export type SettingsFlyoutProps = Omit<NativeSettingsFlyoutProps, 'type'>;
export type SettingsFlyoutRef = React.Component<NativeSettingsFlyoutProps> & Readonly<NativeMethods>;
const _SettingsFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<SettingsFlyoutProps> & RefAttributes<SettingsFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<SettingsFlyoutProps>, ref: React.ForwardedRef<SettingsFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SettingsFlyout' ref={ref} />);
export const SettingsFlyout = (_SettingsFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<SettingsFlyoutProps> & RefAttributes<SettingsFlyoutRef>>));

export type SplitButtonProps = Omit<NativeSplitButtonProps, 'type'>;
export type SplitButtonRef = React.Component<NativeSplitButtonProps> & Readonly<NativeMethods>;
const _SplitButton : (ForwardRefExoticComponent<React.PropsWithChildren<SplitButtonProps> & RefAttributes<SplitButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<SplitButtonProps>, ref: React.ForwardedRef<SplitButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SplitButton' ref={ref} />);
export const SplitButton = (_SplitButton as (ForwardRefExoticComponent<React.PropsWithChildren<SplitButtonProps> & RefAttributes<SplitButtonRef>>));

export type SplitViewProps = Omit<NativeSplitViewProps, 'type'>;
export type SplitViewRef = React.Component<NativeSplitViewProps> & Readonly<NativeMethods>;
const _SplitView : (ForwardRefExoticComponent<React.PropsWithChildren<SplitViewProps> & RefAttributes<SplitViewRef>>) = React.forwardRef((props: React.PropsWithChildren<SplitViewProps>, ref: React.ForwardedRef<SplitViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SplitView' ref={ref} />);
export const SplitView = (_SplitView as (ForwardRefExoticComponent<React.PropsWithChildren<SplitViewProps> & RefAttributes<SplitViewRef>>));

export type StackPanelProps = Omit<NativeStackPanelProps, 'type'>;
export type StackPanelRef = React.Component<NativeStackPanelProps> & Readonly<NativeMethods>;
const _StackPanel : (ForwardRefExoticComponent<React.PropsWithChildren<StackPanelProps> & RefAttributes<StackPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<StackPanelProps>, ref: React.ForwardedRef<StackPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.StackPanel' ref={ref} />);
export const StackPanel = (_StackPanel as (ForwardRefExoticComponent<React.PropsWithChildren<StackPanelProps> & RefAttributes<StackPanelRef>>));

export type SwapChainBackgroundPanelProps = Omit<NativeSwapChainBackgroundPanelProps, 'type'>;
export type SwapChainBackgroundPanelRef = React.Component<NativeSwapChainBackgroundPanelProps> & Readonly<NativeMethods>;
const _SwapChainBackgroundPanel : (ForwardRefExoticComponent<React.PropsWithChildren<SwapChainBackgroundPanelProps> & RefAttributes<SwapChainBackgroundPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<SwapChainBackgroundPanelProps>, ref: React.ForwardedRef<SwapChainBackgroundPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwapChainBackgroundPanel' ref={ref} />);
export const SwapChainBackgroundPanel = (_SwapChainBackgroundPanel as (ForwardRefExoticComponent<React.PropsWithChildren<SwapChainBackgroundPanelProps> & RefAttributes<SwapChainBackgroundPanelRef>>));

export type SwapChainPanelProps = Omit<NativeSwapChainPanelProps, 'type'>;
export type SwapChainPanelRef = React.Component<NativeSwapChainPanelProps> & Readonly<NativeMethods>;
const _SwapChainPanel : (ForwardRefExoticComponent<React.PropsWithChildren<SwapChainPanelProps> & RefAttributes<SwapChainPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<SwapChainPanelProps>, ref: React.ForwardedRef<SwapChainPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwapChainPanel' ref={ref} />);
export const SwapChainPanel = (_SwapChainPanel as (ForwardRefExoticComponent<React.PropsWithChildren<SwapChainPanelProps> & RefAttributes<SwapChainPanelRef>>));

export type SwipeControlProps = Omit<NativeSwipeControlProps, 'type'>;
export type SwipeControlRef = React.Component<NativeSwipeControlProps> & Readonly<NativeMethods>;
const _SwipeControl : (ForwardRefExoticComponent<React.PropsWithChildren<SwipeControlProps> & RefAttributes<SwipeControlRef>>) = React.forwardRef((props: React.PropsWithChildren<SwipeControlProps>, ref: React.ForwardedRef<SwipeControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwipeControl' ref={ref} />);
export const SwipeControl = (_SwipeControl as (ForwardRefExoticComponent<React.PropsWithChildren<SwipeControlProps> & RefAttributes<SwipeControlRef>>));

export type SymbolIconProps = Omit<NativeSymbolIconProps, 'type'>;
export type SymbolIconRef = React.Component<NativeSymbolIconProps> & Readonly<NativeMethods>;
const _SymbolIcon : (ForwardRefExoticComponent<React.PropsWithChildren<SymbolIconProps> & RefAttributes<SymbolIconRef>>) = React.forwardRef((props: React.PropsWithChildren<SymbolIconProps>, ref: React.ForwardedRef<SymbolIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SymbolIcon' ref={ref} />);
export const SymbolIcon = (_SymbolIcon as (ForwardRefExoticComponent<React.PropsWithChildren<SymbolIconProps> & RefAttributes<SymbolIconRef>>));

export type TextBlockProps = Omit<NativeTextBlockProps, 'type'>;
export type TextBlockRef = React.Component<NativeTextBlockProps> & Readonly<NativeMethods>;
const _TextBlock : (ForwardRefExoticComponent<React.PropsWithChildren<TextBlockProps> & RefAttributes<TextBlockRef>>) = React.forwardRef((props: React.PropsWithChildren<TextBlockProps>, ref: React.ForwardedRef<TextBlockRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextBlock' ref={ref} />);
export const TextBlock = (_TextBlock as (ForwardRefExoticComponent<React.PropsWithChildren<TextBlockProps> & RefAttributes<TextBlockRef>>));

export type TextBoxProps = Omit<NativeTextBoxProps, 'type'>;
export type TextBoxRef = React.Component<NativeTextBoxProps> & Readonly<NativeMethods>;
const _TextBox : (ForwardRefExoticComponent<React.PropsWithChildren<TextBoxProps> & RefAttributes<TextBoxRef>>) = React.forwardRef((props: React.PropsWithChildren<TextBoxProps>, ref: React.ForwardedRef<TextBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextBox' ref={ref} />);
export const TextBox = (_TextBox as (ForwardRefExoticComponent<React.PropsWithChildren<TextBoxProps> & RefAttributes<TextBoxRef>>));

export type TextCommandBarFlyoutProps = Omit<NativeTextCommandBarFlyoutProps, 'type'>;
export type TextCommandBarFlyoutRef = React.Component<NativeTextCommandBarFlyoutProps> & Readonly<NativeMethods>;
const _TextCommandBarFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<TextCommandBarFlyoutProps> & RefAttributes<TextCommandBarFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<TextCommandBarFlyoutProps>, ref: React.ForwardedRef<TextCommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextCommandBarFlyout' ref={ref} />);
export const TextCommandBarFlyout = (_TextCommandBarFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<TextCommandBarFlyoutProps> & RefAttributes<TextCommandBarFlyoutRef>>));

export type TimePickerProps = Omit<NativeTimePickerProps, 'type'>;
export type TimePickerRef = React.Component<NativeTimePickerProps> & Readonly<NativeMethods>;
const _TimePicker : (ForwardRefExoticComponent<React.PropsWithChildren<TimePickerProps> & RefAttributes<TimePickerRef>>) = React.forwardRef((props: React.PropsWithChildren<TimePickerProps>, ref: React.ForwardedRef<TimePickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TimePicker' ref={ref} />);
export const TimePicker = (_TimePicker as (ForwardRefExoticComponent<React.PropsWithChildren<TimePickerProps> & RefAttributes<TimePickerRef>>));

export type TimePickerFlyoutProps = Omit<NativeTimePickerFlyoutProps, 'type'>;
export type TimePickerFlyoutRef = React.Component<NativeTimePickerFlyoutProps> & Readonly<NativeMethods>;
const _TimePickerFlyout : (ForwardRefExoticComponent<React.PropsWithChildren<TimePickerFlyoutProps> & RefAttributes<TimePickerFlyoutRef>>) = React.forwardRef((props: React.PropsWithChildren<TimePickerFlyoutProps>, ref: React.ForwardedRef<TimePickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TimePickerFlyout' ref={ref} />);
export const TimePickerFlyout = (_TimePickerFlyout as (ForwardRefExoticComponent<React.PropsWithChildren<TimePickerFlyoutProps> & RefAttributes<TimePickerFlyoutRef>>));

export type ToggleMenuFlyoutItemProps = Omit<NativeToggleMenuFlyoutItemProps, 'type'>;
export type ToggleMenuFlyoutItemRef = React.Component<NativeToggleMenuFlyoutItemProps> & Readonly<NativeMethods>;
const _ToggleMenuFlyoutItem : (ForwardRefExoticComponent<React.PropsWithChildren<ToggleMenuFlyoutItemProps> & RefAttributes<ToggleMenuFlyoutItemRef>>) = React.forwardRef((props: React.PropsWithChildren<ToggleMenuFlyoutItemProps>, ref: React.ForwardedRef<ToggleMenuFlyoutItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleMenuFlyoutItem' ref={ref} />);
export const ToggleMenuFlyoutItem = (_ToggleMenuFlyoutItem as (ForwardRefExoticComponent<React.PropsWithChildren<ToggleMenuFlyoutItemProps> & RefAttributes<ToggleMenuFlyoutItemRef>>));

export type ToggleSplitButtonProps = Omit<NativeToggleSplitButtonProps, 'type'>;
export type ToggleSplitButtonRef = React.Component<NativeToggleSplitButtonProps> & Readonly<NativeMethods>;
const _ToggleSplitButton : (ForwardRefExoticComponent<React.PropsWithChildren<ToggleSplitButtonProps> & RefAttributes<ToggleSplitButtonRef>>) = React.forwardRef((props: React.PropsWithChildren<ToggleSplitButtonProps>, ref: React.ForwardedRef<ToggleSplitButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleSplitButton' ref={ref} />);
export const ToggleSplitButton = (_ToggleSplitButton as (ForwardRefExoticComponent<React.PropsWithChildren<ToggleSplitButtonProps> & RefAttributes<ToggleSplitButtonRef>>));

export type ToggleSwitchProps = Omit<NativeToggleSwitchProps, 'type'>;
export type ToggleSwitchRef = React.Component<NativeToggleSwitchProps> & Readonly<NativeMethods>;
const _ToggleSwitch : (ForwardRefExoticComponent<React.PropsWithChildren<ToggleSwitchProps> & RefAttributes<ToggleSwitchRef>>) = React.forwardRef((props: React.PropsWithChildren<ToggleSwitchProps>, ref: React.ForwardedRef<ToggleSwitchRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleSwitch' ref={ref} />);
export const ToggleSwitch = (_ToggleSwitch as (ForwardRefExoticComponent<React.PropsWithChildren<ToggleSwitchProps> & RefAttributes<ToggleSwitchRef>>));

export type ToolTipProps = Omit<NativeToolTipProps, 'type'>;
export type ToolTipRef = React.Component<NativeToolTipProps> & Readonly<NativeMethods>;
const _ToolTip : (ForwardRefExoticComponent<React.PropsWithChildren<ToolTipProps> & RefAttributes<ToolTipRef>>) = React.forwardRef((props: React.PropsWithChildren<ToolTipProps>, ref: React.ForwardedRef<ToolTipRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToolTip' ref={ref} />);
export const ToolTip = (_ToolTip as (ForwardRefExoticComponent<React.PropsWithChildren<ToolTipProps> & RefAttributes<ToolTipRef>>));

export type TreeViewProps = Omit<NativeTreeViewProps, 'type'>;
export type TreeViewRef = React.Component<NativeTreeViewProps> & Readonly<NativeMethods>;
const _TreeView : (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewProps> & RefAttributes<TreeViewRef>>) = React.forwardRef((props: React.PropsWithChildren<TreeViewProps>, ref: React.ForwardedRef<TreeViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeView' ref={ref} />);
export const TreeView = (_TreeView as (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewProps> & RefAttributes<TreeViewRef>>));

export type TreeViewItemProps = Omit<NativeTreeViewItemProps, 'type'>;
export type TreeViewItemRef = React.Component<NativeTreeViewItemProps> & Readonly<NativeMethods>;
const _TreeViewItem : (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewItemProps> & RefAttributes<TreeViewItemRef>>) = React.forwardRef((props: React.PropsWithChildren<TreeViewItemProps>, ref: React.ForwardedRef<TreeViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeViewItem' ref={ref} />);
export const TreeViewItem = (_TreeViewItem as (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewItemProps> & RefAttributes<TreeViewItemRef>>));

export type TreeViewListProps = Omit<NativeTreeViewListProps, 'type'>;
export type TreeViewListRef = React.Component<NativeTreeViewListProps> & Readonly<NativeMethods>;
const _TreeViewList : (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewListProps> & RefAttributes<TreeViewListRef>>) = React.forwardRef((props: React.PropsWithChildren<TreeViewListProps>, ref: React.ForwardedRef<TreeViewListRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeViewList' ref={ref} />);
export const TreeViewList = (_TreeViewList as (ForwardRefExoticComponent<React.PropsWithChildren<TreeViewListProps> & RefAttributes<TreeViewListRef>>));

export type TwoPaneViewProps = Omit<NativeTwoPaneViewProps, 'type'>;
export type TwoPaneViewRef = React.Component<NativeTwoPaneViewProps> & Readonly<NativeMethods>;
const _TwoPaneView : (ForwardRefExoticComponent<React.PropsWithChildren<TwoPaneViewProps> & RefAttributes<TwoPaneViewRef>>) = React.forwardRef((props: React.PropsWithChildren<TwoPaneViewProps>, ref: React.ForwardedRef<TwoPaneViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TwoPaneView' ref={ref} />);
export const TwoPaneView = (_TwoPaneView as (ForwardRefExoticComponent<React.PropsWithChildren<TwoPaneViewProps> & RefAttributes<TwoPaneViewRef>>));

export type VariableSizedWrapGridProps = Omit<NativeVariableSizedWrapGridProps, 'type'>;
export type VariableSizedWrapGridRef = React.Component<NativeVariableSizedWrapGridProps> & Readonly<NativeMethods>;
const _VariableSizedWrapGrid : (ForwardRefExoticComponent<React.PropsWithChildren<VariableSizedWrapGridProps> & RefAttributes<VariableSizedWrapGridRef>>) = React.forwardRef((props: React.PropsWithChildren<VariableSizedWrapGridProps>, ref: React.ForwardedRef<VariableSizedWrapGridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.VariableSizedWrapGrid' ref={ref} />);
export const VariableSizedWrapGrid = (_VariableSizedWrapGrid as (ForwardRefExoticComponent<React.PropsWithChildren<VariableSizedWrapGridProps> & RefAttributes<VariableSizedWrapGridRef>>));

export type ViewboxProps = Omit<NativeViewboxProps, 'type'>;
export type ViewboxRef = React.Component<NativeViewboxProps> & Readonly<NativeMethods>;
const _Viewbox : (ForwardRefExoticComponent<React.PropsWithChildren<ViewboxProps> & RefAttributes<ViewboxRef>>) = React.forwardRef((props: React.PropsWithChildren<ViewboxProps>, ref: React.ForwardedRef<ViewboxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Viewbox' ref={ref} />);
export const Viewbox = (_Viewbox as (ForwardRefExoticComponent<React.PropsWithChildren<ViewboxProps> & RefAttributes<ViewboxRef>>));

export type VirtualizingStackPanelProps = Omit<NativeVirtualizingStackPanelProps, 'type'>;
export type VirtualizingStackPanelRef = React.Component<NativeVirtualizingStackPanelProps> & Readonly<NativeMethods>;
const _VirtualizingStackPanel : (ForwardRefExoticComponent<React.PropsWithChildren<VirtualizingStackPanelProps> & RefAttributes<VirtualizingStackPanelRef>>) = React.forwardRef((props: React.PropsWithChildren<VirtualizingStackPanelProps>, ref: React.ForwardedRef<VirtualizingStackPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.VirtualizingStackPanel' ref={ref} />);
export const VirtualizingStackPanel = (_VirtualizingStackPanel as (ForwardRefExoticComponent<React.PropsWithChildren<VirtualizingStackPanelProps> & RefAttributes<VirtualizingStackPanelRef>>));

export type WebViewProps = Omit<NativeWebViewProps, 'type'>;
export type WebViewRef = React.Component<NativeWebViewProps> & Readonly<NativeMethods>;
const _WebView : (ForwardRefExoticComponent<React.PropsWithChildren<WebViewProps> & RefAttributes<WebViewRef>>) = React.forwardRef((props: React.PropsWithChildren<WebViewProps>, ref: React.ForwardedRef<WebViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.WebView' ref={ref} />);
export const WebView = (_WebView as (ForwardRefExoticComponent<React.PropsWithChildren<WebViewProps> & RefAttributes<WebViewRef>>));

export type WrapGridProps = Omit<NativeWrapGridProps, 'type'>;
export type WrapGridRef = React.Component<NativeWrapGridProps> & Readonly<NativeMethods>;
const _WrapGrid : (ForwardRefExoticComponent<React.PropsWithChildren<WrapGridProps> & RefAttributes<WrapGridRef>>) = React.forwardRef((props: React.PropsWithChildren<WrapGridProps>, ref: React.ForwardedRef<WrapGridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.WrapGrid' ref={ref} />);
export const WrapGrid = (_WrapGrid as (ForwardRefExoticComponent<React.PropsWithChildren<WrapGridProps> & RefAttributes<WrapGridRef>>));

export type SpanProps = Omit<NativeSpanProps, 'type'>;
export type SpanRef = React.Component<NativeSpanProps> & Readonly<NativeMethods>;
const _Span : (ForwardRefExoticComponent<React.PropsWithChildren<SpanProps> & RefAttributes<SpanRef>>) = React.forwardRef((props: React.PropsWithChildren<SpanProps>, ref: React.ForwardedRef<SpanRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Span' ref={ref} />);
export const Span = (_Span as (ForwardRefExoticComponent<React.PropsWithChildren<SpanProps> & RefAttributes<SpanRef>>));

export type BoldProps = Omit<NativeBoldProps, 'type'>;
export type BoldRef = React.Component<NativeBoldProps> & Readonly<NativeMethods>;
const _Bold : (ForwardRefExoticComponent<React.PropsWithChildren<BoldProps> & RefAttributes<BoldRef>>) = React.forwardRef((props: React.PropsWithChildren<BoldProps>, ref: React.ForwardedRef<BoldRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Bold' ref={ref} />);
export const Bold = (_Bold as (ForwardRefExoticComponent<React.PropsWithChildren<BoldProps> & RefAttributes<BoldRef>>));

export type ContentLinkProps = Omit<NativeContentLinkProps, 'type'>;
export type ContentLinkRef = React.Component<NativeContentLinkProps> & Readonly<NativeMethods>;
const _ContentLink : (ForwardRefExoticComponent<React.PropsWithChildren<ContentLinkProps> & RefAttributes<ContentLinkRef>>) = React.forwardRef((props: React.PropsWithChildren<ContentLinkProps>, ref: React.ForwardedRef<ContentLinkRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.ContentLink' ref={ref} />);
export const ContentLink = (_ContentLink as (ForwardRefExoticComponent<React.PropsWithChildren<ContentLinkProps> & RefAttributes<ContentLinkRef>>));

export type GlyphsProps = Omit<NativeGlyphsProps, 'type'>;
export type GlyphsRef = React.Component<NativeGlyphsProps> & Readonly<NativeMethods>;
const _Glyphs : (ForwardRefExoticComponent<React.PropsWithChildren<GlyphsProps> & RefAttributes<GlyphsRef>>) = React.forwardRef((props: React.PropsWithChildren<GlyphsProps>, ref: React.ForwardedRef<GlyphsRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Glyphs' ref={ref} />);
export const Glyphs = (_Glyphs as (ForwardRefExoticComponent<React.PropsWithChildren<GlyphsProps> & RefAttributes<GlyphsRef>>));

export type HyperlinkProps = Omit<NativeHyperlinkProps, 'type'>;
export type HyperlinkRef = React.Component<NativeHyperlinkProps> & Readonly<NativeMethods>;
const _Hyperlink : (ForwardRefExoticComponent<React.PropsWithChildren<HyperlinkProps> & RefAttributes<HyperlinkRef>>) = React.forwardRef((props: React.PropsWithChildren<HyperlinkProps>, ref: React.ForwardedRef<HyperlinkRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Hyperlink' ref={ref} />);
export const Hyperlink = (_Hyperlink as (ForwardRefExoticComponent<React.PropsWithChildren<HyperlinkProps> & RefAttributes<HyperlinkRef>>));

export type InlineUIContainerProps = Omit<NativeInlineUIContainerProps, 'type'>;
export type InlineUIContainerRef = React.Component<NativeInlineUIContainerProps> & Readonly<NativeMethods>;
const _InlineUIContainer : (ForwardRefExoticComponent<React.PropsWithChildren<InlineUIContainerProps> & RefAttributes<InlineUIContainerRef>>) = React.forwardRef((props: React.PropsWithChildren<InlineUIContainerProps>, ref: React.ForwardedRef<InlineUIContainerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.InlineUIContainer' ref={ref} />);
export const InlineUIContainer = (_InlineUIContainer as (ForwardRefExoticComponent<React.PropsWithChildren<InlineUIContainerProps> & RefAttributes<InlineUIContainerRef>>));

export type ItalicProps = Omit<NativeItalicProps, 'type'>;
export type ItalicRef = React.Component<NativeItalicProps> & Readonly<NativeMethods>;
const _Italic : (ForwardRefExoticComponent<React.PropsWithChildren<ItalicProps> & RefAttributes<ItalicRef>>) = React.forwardRef((props: React.PropsWithChildren<ItalicProps>, ref: React.ForwardedRef<ItalicRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Italic' ref={ref} />);
export const Italic = (_Italic as (ForwardRefExoticComponent<React.PropsWithChildren<ItalicProps> & RefAttributes<ItalicRef>>));

export type LineBreakProps = Omit<NativeLineBreakProps, 'type'>;
export type LineBreakRef = React.Component<NativeLineBreakProps> & Readonly<NativeMethods>;
const _LineBreak : (ForwardRefExoticComponent<React.PropsWithChildren<LineBreakProps> & RefAttributes<LineBreakRef>>) = React.forwardRef((props: React.PropsWithChildren<LineBreakProps>, ref: React.ForwardedRef<LineBreakRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.LineBreak' ref={ref} />);
export const LineBreak = (_LineBreak as (ForwardRefExoticComponent<React.PropsWithChildren<LineBreakProps> & RefAttributes<LineBreakRef>>));

export type ParagraphProps = Omit<NativeParagraphProps, 'type'>;
export type ParagraphRef = React.Component<NativeParagraphProps> & Readonly<NativeMethods>;
const _Paragraph : (ForwardRefExoticComponent<React.PropsWithChildren<ParagraphProps> & RefAttributes<ParagraphRef>>) = React.forwardRef((props: React.PropsWithChildren<ParagraphProps>, ref: React.ForwardedRef<ParagraphRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Paragraph' ref={ref} />);
export const Paragraph = (_Paragraph as (ForwardRefExoticComponent<React.PropsWithChildren<ParagraphProps> & RefAttributes<ParagraphRef>>));

export type RunProps = Omit<NativeRunProps, 'type'>;
export type RunRef = React.Component<NativeRunProps> & Readonly<NativeMethods>;
const _Run : (ForwardRefExoticComponent<React.PropsWithChildren<RunProps> & RefAttributes<RunRef>>) = React.forwardRef((props: React.PropsWithChildren<RunProps>, ref: React.ForwardedRef<RunRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Run' ref={ref} />);
export const Run = (_Run as (ForwardRefExoticComponent<React.PropsWithChildren<RunProps> & RefAttributes<RunRef>>));

export type UnderlineProps = Omit<NativeUnderlineProps, 'type'>;
export type UnderlineRef = React.Component<NativeUnderlineProps> & Readonly<NativeMethods>;
const _Underline : (ForwardRefExoticComponent<React.PropsWithChildren<UnderlineProps> & RefAttributes<UnderlineRef>>) = React.forwardRef((props: React.PropsWithChildren<UnderlineProps>, ref: React.ForwardedRef<UnderlineRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Underline' ref={ref} />);
export const Underline = (_Underline as (ForwardRefExoticComponent<React.PropsWithChildren<UnderlineProps> & RefAttributes<UnderlineRef>>));

export type KeyboardAcceleratorProps = Omit<NativeKeyboardAcceleratorProps, 'type'>;
export type KeyboardAcceleratorRef = React.Component<NativeKeyboardAcceleratorProps> & Readonly<NativeMethods>;
const _KeyboardAccelerator : (ForwardRefExoticComponent<React.PropsWithChildren<KeyboardAcceleratorProps> & RefAttributes<KeyboardAcceleratorRef>>) = React.forwardRef((props: React.PropsWithChildren<KeyboardAcceleratorProps>, ref: React.ForwardedRef<KeyboardAcceleratorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Input.KeyboardAccelerator' ref={ref} />);
export const KeyboardAccelerator = (_KeyboardAccelerator as (ForwardRefExoticComponent<React.PropsWithChildren<KeyboardAcceleratorProps> & RefAttributes<KeyboardAcceleratorRef>>));

export type EllipseProps = Omit<NativeEllipseProps, 'type'>;
export type EllipseRef = React.Component<NativeEllipseProps> & Readonly<NativeMethods>;
const _Ellipse : (ForwardRefExoticComponent<React.PropsWithChildren<EllipseProps> & RefAttributes<EllipseRef>>) = React.forwardRef((props: React.PropsWithChildren<EllipseProps>, ref: React.ForwardedRef<EllipseRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Ellipse' ref={ref} />);
export const Ellipse = (_Ellipse as (ForwardRefExoticComponent<React.PropsWithChildren<EllipseProps> & RefAttributes<EllipseRef>>));

export type LineProps = Omit<NativeLineProps, 'type'>;
export type LineRef = React.Component<NativeLineProps> & Readonly<NativeMethods>;
const _Line : (ForwardRefExoticComponent<React.PropsWithChildren<LineProps> & RefAttributes<LineRef>>) = React.forwardRef((props: React.PropsWithChildren<LineProps>, ref: React.ForwardedRef<LineRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Line' ref={ref} />);
export const Line = (_Line as (ForwardRefExoticComponent<React.PropsWithChildren<LineProps> & RefAttributes<LineRef>>));

export type PathProps = Omit<NativePathProps, 'type'>;
export type PathRef = React.Component<NativePathProps> & Readonly<NativeMethods>;
const _Path : (ForwardRefExoticComponent<React.PropsWithChildren<PathProps> & RefAttributes<PathRef>>) = React.forwardRef((props: React.PropsWithChildren<PathProps>, ref: React.ForwardedRef<PathRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Path' ref={ref} />);
export const Path = (_Path as (ForwardRefExoticComponent<React.PropsWithChildren<PathProps> & RefAttributes<PathRef>>));

export type PolygonProps = Omit<NativePolygonProps, 'type'>;
export type PolygonRef = React.Component<NativePolygonProps> & Readonly<NativeMethods>;
const _Polygon : (ForwardRefExoticComponent<React.PropsWithChildren<PolygonProps> & RefAttributes<PolygonRef>>) = React.forwardRef((props: React.PropsWithChildren<PolygonProps>, ref: React.ForwardedRef<PolygonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Polygon' ref={ref} />);
export const Polygon = (_Polygon as (ForwardRefExoticComponent<React.PropsWithChildren<PolygonProps> & RefAttributes<PolygonRef>>));

export type PolylineProps = Omit<NativePolylineProps, 'type'>;
export type PolylineRef = React.Component<NativePolylineProps> & Readonly<NativeMethods>;
const _Polyline : (ForwardRefExoticComponent<React.PropsWithChildren<PolylineProps> & RefAttributes<PolylineRef>>) = React.forwardRef((props: React.PropsWithChildren<PolylineProps>, ref: React.ForwardedRef<PolylineRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Polyline' ref={ref} />);
export const Polyline = (_Polyline as (ForwardRefExoticComponent<React.PropsWithChildren<PolylineProps> & RefAttributes<PolylineRef>>));

export type RectangleProps = Omit<NativeRectangleProps, 'type'>;
export type RectangleRef = React.Component<NativeRectangleProps> & Readonly<NativeMethods>;
const _Rectangle : (ForwardRefExoticComponent<React.PropsWithChildren<RectangleProps> & RefAttributes<RectangleRef>>) = React.forwardRef((props: React.PropsWithChildren<RectangleProps>, ref: React.ForwardedRef<RectangleRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Rectangle' ref={ref} />);
export const Rectangle = (_Rectangle as (ForwardRefExoticComponent<React.PropsWithChildren<RectangleProps> & RefAttributes<RectangleRef>>));


export namespace WinUI {
export type BreadcrumbBarItemClickedEventArgs = NativeWinUI.NativeBreadcrumbBarItemClickedEventArgs;    // Microsoft.UI.Xaml.Controls.BreadcrumbBarItemClickedEventArgs 
}
export namespace WinUI {
export type ColorChangedEventArgs = NativeWinUI.NativeColorChangedEventArgs;    // Microsoft.UI.Xaml.Controls.ColorChangedEventArgs 
}
export namespace WinUI {
export type ExpanderCollapsedEventArgs = NativeWinUI.NativeExpanderCollapsedEventArgs;    // Microsoft.UI.Xaml.Controls.ExpanderCollapsedEventArgs 
}
export namespace WinUI {
export type ExpanderExpandingEventArgs = NativeWinUI.NativeExpanderExpandingEventArgs;    // Microsoft.UI.Xaml.Controls.ExpanderExpandingEventArgs 
}
export namespace WinUI {
export type InfoBarClosedEventArgs = NativeWinUI.NativeInfoBarClosedEventArgs;    // Microsoft.UI.Xaml.Controls.InfoBarClosedEventArgs 
}
export namespace WinUI {
export type InfoBarClosingEventArgs = NativeWinUI.NativeInfoBarClosingEventArgs;    // Microsoft.UI.Xaml.Controls.InfoBarClosingEventArgs 
}
export namespace WinUI {
export type ItemsRepeaterElementClearingEventArgs = NativeWinUI.NativeItemsRepeaterElementClearingEventArgs;    // Microsoft.UI.Xaml.Controls.ItemsRepeaterElementClearingEventArgs 
}
export namespace WinUI {
export type ItemsRepeaterElementIndexChangedEventArgs = NativeWinUI.NativeItemsRepeaterElementIndexChangedEventArgs;    // Microsoft.UI.Xaml.Controls.ItemsRepeaterElementIndexChangedEventArgs 
}
export namespace WinUI {
export type ItemsRepeaterElementPreparedEventArgs = NativeWinUI.NativeItemsRepeaterElementPreparedEventArgs;    // Microsoft.UI.Xaml.Controls.ItemsRepeaterElementPreparedEventArgs 
}
export namespace WinUI {
export type NavigationViewDisplayModeChangedEventArgs = NativeWinUI.NativeNavigationViewDisplayModeChangedEventArgs;    // Microsoft.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs 
}
export namespace WinUI {
export type NavigationViewItemInvokedEventArgs = NativeWinUI.NativeNavigationViewItemInvokedEventArgs;    // Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs 
}
export namespace WinUI {
export type NavigationViewSelectionChangedEventArgs = NativeWinUI.NativeNavigationViewSelectionChangedEventArgs;    // Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs 
}
export namespace WinUI {
export type NavigationViewBackRequestedEventArgs = NativeWinUI.NativeNavigationViewBackRequestedEventArgs;    // Microsoft.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs 
}
export namespace WinUI {
export type NavigationViewItemCollapsedEventArgs = NativeWinUI.NativeNavigationViewItemCollapsedEventArgs;    // Microsoft.UI.Xaml.Controls.NavigationViewItemCollapsedEventArgs 
}
export namespace WinUI {
export type NavigationViewItemExpandingEventArgs = NativeWinUI.NativeNavigationViewItemExpandingEventArgs;    // Microsoft.UI.Xaml.Controls.NavigationViewItemExpandingEventArgs 
}
export namespace WinUI {
export type NavigationViewPaneClosingEventArgs = NativeWinUI.NativeNavigationViewPaneClosingEventArgs;    // Microsoft.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs 
}
export namespace WinUI {
export type NumberBoxValueChangedEventArgs = NativeWinUI.NativeNumberBoxValueChangedEventArgs;    // Microsoft.UI.Xaml.Controls.NumberBoxValueChangedEventArgs 
}
export namespace WinUI {
export type PipsPagerSelectedIndexChangedEventArgs = NativeWinUI.NativePipsPagerSelectedIndexChangedEventArgs;    // Microsoft.UI.Xaml.Controls.PipsPagerSelectedIndexChangedEventArgs 
}
export type SelectionChangedEventArgs = NativeSelectionChangedEventArgs;    // Windows.UI.Xaml.Controls.SelectionChangedEventArgs 
export namespace WinUI {
export type RefreshRequestedEventArgs = NativeWinUI.NativeRefreshRequestedEventArgs;    // Microsoft.UI.Xaml.Controls.RefreshRequestedEventArgs 
}
export namespace WinUI {
export type RefreshStateChangedEventArgs = NativeWinUI.NativeRefreshStateChangedEventArgs;    // Microsoft.UI.Xaml.Controls.RefreshStateChangedEventArgs 
}
export namespace WinUI {
export type SplitButtonClickEventArgs = NativeWinUI.NativeSplitButtonClickEventArgs;    // Microsoft.UI.Xaml.Controls.SplitButtonClickEventArgs 
}
export namespace WinUI {
export type TabViewTabCloseRequestedEventArgs = NativeWinUI.NativeTabViewTabCloseRequestedEventArgs;    // Microsoft.UI.Xaml.Controls.TabViewTabCloseRequestedEventArgs 
}
export namespace WinUI {
export type TabViewTabDragCompletedEventArgs = NativeWinUI.NativeTabViewTabDragCompletedEventArgs;    // Microsoft.UI.Xaml.Controls.TabViewTabDragCompletedEventArgs 
}
export namespace WinUI {
export type TabViewTabDragStartingEventArgs = NativeWinUI.NativeTabViewTabDragStartingEventArgs;    // Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs 
}
export namespace WinUI {
export type TabViewTabDroppedOutsideEventArgs = NativeWinUI.NativeTabViewTabDroppedOutsideEventArgs;    // Microsoft.UI.Xaml.Controls.TabViewTabDroppedOutsideEventArgs 
}
export type IVectorChangedEventArgs = NativeIVectorChangedEventArgs;    // Windows.Foundation.Collections.IVectorChangedEventArgs 
export type DragEventArgs = NativeDragEventArgs;    // Windows.UI.Xaml.DragEventArgs 
export namespace WinUI {
export type TeachingTipClosedEventArgs = NativeWinUI.NativeTeachingTipClosedEventArgs;    // Microsoft.UI.Xaml.Controls.TeachingTipClosedEventArgs 
}
export namespace WinUI {
export type TeachingTipClosingEventArgs = NativeWinUI.NativeTeachingTipClosingEventArgs;    // Microsoft.UI.Xaml.Controls.TeachingTipClosingEventArgs 
}
export namespace WinUI {
export type ToggleSplitButtonIsCheckedChangedEventArgs = NativeWinUI.NativeToggleSplitButtonIsCheckedChangedEventArgs;    // Microsoft.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs 
}
export namespace WinUI {
export type TreeViewCollapsedEventArgs = NativeWinUI.NativeTreeViewCollapsedEventArgs;    // Microsoft.UI.Xaml.Controls.TreeViewCollapsedEventArgs 
}
export namespace WinUI {
export type TreeViewExpandingEventArgs = NativeWinUI.NativeTreeViewExpandingEventArgs;    // Microsoft.UI.Xaml.Controls.TreeViewExpandingEventArgs 
}
export namespace WinUI {
export type TreeViewItemInvokedEventArgs = NativeWinUI.NativeTreeViewItemInvokedEventArgs;    // Microsoft.UI.Xaml.Controls.TreeViewItemInvokedEventArgs 
}
export namespace WinUI {
export type TreeViewDragItemsCompletedEventArgs = NativeWinUI.NativeTreeViewDragItemsCompletedEventArgs;    // Microsoft.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs 
}
export namespace WinUI {
export type TreeViewDragItemsStartingEventArgs = NativeWinUI.NativeTreeViewDragItemsStartingEventArgs;    // Microsoft.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs 
}
export namespace WebView2 {
export type CoreWebView2ProcessFailedEventArgs = NativeWebView2.NativeCoreWebView2ProcessFailedEventArgs;    // Microsoft.Web.WebView2.Core.CoreWebView2ProcessFailedEventArgs 
}
export namespace WinUI {
export type CoreWebView2InitializedEventArgs = NativeWinUI.NativeCoreWebView2InitializedEventArgs;    // Microsoft.UI.Xaml.Controls.CoreWebView2InitializedEventArgs 
}
export namespace WebView2 {
export type CoreWebView2NavigationCompletedEventArgs = NativeWebView2.NativeCoreWebView2NavigationCompletedEventArgs;    // Microsoft.Web.WebView2.Core.CoreWebView2NavigationCompletedEventArgs 
}
export namespace WebView2 {
export type CoreWebView2NavigationStartingEventArgs = NativeWebView2.NativeCoreWebView2NavigationStartingEventArgs;    // Microsoft.Web.WebView2.Core.CoreWebView2NavigationStartingEventArgs 
}
export namespace WebView2 {
export type CoreWebView2WebMessageReceivedEventArgs = NativeWebView2.NativeCoreWebView2WebMessageReceivedEventArgs;    // Microsoft.Web.WebView2.Core.CoreWebView2WebMessageReceivedEventArgs 
}
export type DoubleTappedRoutedEventArgs = NativeDoubleTappedRoutedEventArgs;    // Windows.UI.Xaml.Input.DoubleTappedRoutedEventArgs 
export type RoutedEventArgs = NativeRoutedEventArgs;    // Windows.UI.Xaml.RoutedEventArgs 
export type HoldingRoutedEventArgs = NativeHoldingRoutedEventArgs;    // Windows.UI.Xaml.Input.HoldingRoutedEventArgs 
export type ManipulationCompletedRoutedEventArgs = NativeManipulationCompletedRoutedEventArgs;    // Windows.UI.Xaml.Input.ManipulationCompletedRoutedEventArgs 
export type ManipulationDeltaRoutedEventArgs = NativeManipulationDeltaRoutedEventArgs;    // Windows.UI.Xaml.Input.ManipulationDeltaRoutedEventArgs 
export type ManipulationInertiaStartingRoutedEventArgs = NativeManipulationInertiaStartingRoutedEventArgs;    // Windows.UI.Xaml.Input.ManipulationInertiaStartingRoutedEventArgs 
export type ManipulationStartedRoutedEventArgs = NativeManipulationStartedRoutedEventArgs;    // Windows.UI.Xaml.Input.ManipulationStartedRoutedEventArgs 
export type ManipulationStartingRoutedEventArgs = NativeManipulationStartingRoutedEventArgs;    // Windows.UI.Xaml.Input.ManipulationStartingRoutedEventArgs 
export type PointerRoutedEventArgs = NativePointerRoutedEventArgs;    // Windows.UI.Xaml.Input.PointerRoutedEventArgs 
export type RightTappedRoutedEventArgs = NativeRightTappedRoutedEventArgs;    // Windows.UI.Xaml.Input.RightTappedRoutedEventArgs 
export type TappedRoutedEventArgs = NativeTappedRoutedEventArgs;    // Windows.UI.Xaml.Input.TappedRoutedEventArgs 
export type DragStartingEventArgs = NativeDragStartingEventArgs;    // Windows.UI.Xaml.DragStartingEventArgs 
export type DropCompletedEventArgs = NativeDropCompletedEventArgs;    // Windows.UI.Xaml.DropCompletedEventArgs 
export type AccessKeyDisplayDismissedEventArgs = NativeAccessKeyDisplayDismissedEventArgs;    // Windows.UI.Xaml.Input.AccessKeyDisplayDismissedEventArgs 
export type AccessKeyDisplayRequestedEventArgs = NativeAccessKeyDisplayRequestedEventArgs;    // Windows.UI.Xaml.Input.AccessKeyDisplayRequestedEventArgs 
export type AccessKeyInvokedEventArgs = NativeAccessKeyInvokedEventArgs;    // Windows.UI.Xaml.Input.AccessKeyInvokedEventArgs 
export type ContextRequestedEventArgs = NativeContextRequestedEventArgs;    // Windows.UI.Xaml.Input.ContextRequestedEventArgs 
export type GettingFocusEventArgs = NativeGettingFocusEventArgs;    // Windows.UI.Xaml.Input.GettingFocusEventArgs 
export type LosingFocusEventArgs = NativeLosingFocusEventArgs;    // Windows.UI.Xaml.Input.LosingFocusEventArgs 
export type NoFocusCandidateFoundEventArgs = NativeNoFocusCandidateFoundEventArgs;    // Windows.UI.Xaml.Input.NoFocusCandidateFoundEventArgs 
export type CharacterReceivedRoutedEventArgs = NativeCharacterReceivedRoutedEventArgs;    // Windows.UI.Xaml.Input.CharacterReceivedRoutedEventArgs 
export type KeyRoutedEventArgs = NativeKeyRoutedEventArgs;    // Windows.UI.Xaml.Input.KeyRoutedEventArgs 
export type ProcessKeyboardAcceleratorEventArgs = NativeProcessKeyboardAcceleratorEventArgs;    // Windows.UI.Xaml.Input.ProcessKeyboardAcceleratorEventArgs 
export type BringIntoViewRequestedEventArgs = NativeBringIntoViewRequestedEventArgs;    // Windows.UI.Xaml.BringIntoViewRequestedEventArgs 
export type SizeChangedEventArgs = NativeSizeChangedEventArgs;    // Windows.UI.Xaml.SizeChangedEventArgs 
export type DataContextChangedEventArgs = NativeDataContextChangedEventArgs;    // Windows.UI.Xaml.DataContextChangedEventArgs 
export type EffectiveViewportChangedEventArgs = NativeEffectiveViewportChangedEventArgs;    // Windows.UI.Xaml.EffectiveViewportChangedEventArgs 
export type DependencyPropertyChangedEventArgs = NativeDependencyPropertyChangedEventArgs;    // Windows.UI.Xaml.DependencyPropertyChangedEventArgs 
export type FocusDisengagedEventArgs = NativeFocusDisengagedEventArgs;    // Windows.UI.Xaml.Controls.FocusDisengagedEventArgs 
export type FocusEngagedEventArgs = NativeFocusEngagedEventArgs;    // Windows.UI.Xaml.Controls.FocusEngagedEventArgs 
export type AutoSuggestBoxSuggestionChosenEventArgs = NativeAutoSuggestBoxSuggestionChosenEventArgs;    // Windows.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs 
export type AutoSuggestBoxTextChangedEventArgs = NativeAutoSuggestBoxTextChangedEventArgs;    // Windows.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs 
export type AutoSuggestBoxQuerySubmittedEventArgs = NativeAutoSuggestBoxQuerySubmittedEventArgs;    // Windows.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs 
export type CalendarViewDayItemChangingEventArgs = NativeCalendarViewDayItemChangingEventArgs;    // Windows.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs 
export type CalendarDatePickerDateChangedEventArgs = NativeCalendarDatePickerDateChangedEventArgs;    // Windows.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs 
export type CalendarViewSelectedDatesChangedEventArgs = NativeCalendarViewSelectedDatesChangedEventArgs;    // Windows.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs 
export type ColorChangedEventArgs = NativeColorChangedEventArgs;    // Windows.UI.Xaml.Controls.ColorChangedEventArgs 
export type ComboBoxTextSubmittedEventArgs = NativeComboBoxTextSubmittedEventArgs;    // Windows.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs 
export type DynamicOverflowItemsChangingEventArgs = NativeDynamicOverflowItemsChangingEventArgs;    // Windows.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs 
export type FlyoutBaseClosingEventArgs = NativeFlyoutBaseClosingEventArgs;    // Windows.UI.Xaml.Controls.Primitives.FlyoutBaseClosingEventArgs 
export type ContentDialogClosedEventArgs = NativeContentDialogClosedEventArgs;    // Windows.UI.Xaml.Controls.ContentDialogClosedEventArgs 
export type ContentDialogClosingEventArgs = NativeContentDialogClosingEventArgs;    // Windows.UI.Xaml.Controls.ContentDialogClosingEventArgs 
export type ContentDialogOpenedEventArgs = NativeContentDialogOpenedEventArgs;    // Windows.UI.Xaml.Controls.ContentDialogOpenedEventArgs 
export type ContentDialogButtonClickEventArgs = NativeContentDialogButtonClickEventArgs;    // Windows.UI.Xaml.Controls.ContentDialogButtonClickEventArgs 
export type DatePickerValueChangedEventArgs = NativeDatePickerValueChangedEventArgs;    // Windows.UI.Xaml.Controls.DatePickerValueChangedEventArgs 
export type DatePickerSelectedValueChangedEventArgs = NativeDatePickerSelectedValueChangedEventArgs;    // Windows.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs 
export type DatePickedEventArgs = NativeDatePickedEventArgs;    // Windows.UI.Xaml.Controls.DatePickedEventArgs 
export type NavigationEventArgs = NativeNavigationEventArgs;    // Windows.UI.Xaml.Navigation.NavigationEventArgs 
export type NavigatingCancelEventArgs = NativeNavigatingCancelEventArgs;    // Windows.UI.Xaml.Navigation.NavigatingCancelEventArgs 
export type NavigationFailedEventArgs = NativeNavigationFailedEventArgs;    // Windows.UI.Xaml.Navigation.NavigationFailedEventArgs 
export type DragItemsStartingEventArgs = NativeDragItemsStartingEventArgs;    // Windows.UI.Xaml.Controls.DragItemsStartingEventArgs 
export type ItemClickEventArgs = NativeItemClickEventArgs;    // Windows.UI.Xaml.Controls.ItemClickEventArgs 
export type ContainerContentChangingEventArgs = NativeContainerContentChangingEventArgs;    // Windows.UI.Xaml.Controls.ContainerContentChangingEventArgs 
export type ChoosingGroupHeaderContainerEventArgs = NativeChoosingGroupHeaderContainerEventArgs;    // Windows.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs 
export type ChoosingItemContainerEventArgs = NativeChoosingItemContainerEventArgs;    // Windows.UI.Xaml.Controls.ChoosingItemContainerEventArgs 
export type DragItemsCompletedEventArgs = NativeDragItemsCompletedEventArgs;    // Windows.UI.Xaml.Controls.DragItemsCompletedEventArgs 
export type HandwritingPanelClosedEventArgs = NativeHandwritingPanelClosedEventArgs;    // Windows.UI.Xaml.Controls.HandwritingPanelClosedEventArgs 
export type HandwritingPanelOpenedEventArgs = NativeHandwritingPanelOpenedEventArgs;    // Windows.UI.Xaml.Controls.HandwritingPanelOpenedEventArgs 
export type HubSectionHeaderClickEventArgs = NativeHubSectionHeaderClickEventArgs;    // Windows.UI.Xaml.Controls.HubSectionHeaderClickEventArgs 
export type SectionsInViewChangedEventArgs = NativeSectionsInViewChangedEventArgs;    // Windows.UI.Xaml.Controls.SectionsInViewChangedEventArgs 
export type ExceptionRoutedEventArgs = NativeExceptionRoutedEventArgs;    // Windows.UI.Xaml.ExceptionRoutedEventArgs 
export type InkToolbarIsStencilButtonCheckedChangedEventArgs = NativeInkToolbarIsStencilButtonCheckedChangedEventArgs;    // Windows.UI.Xaml.Controls.InkToolbarIsStencilButtonCheckedChangedEventArgs 
export type ItemsPickedEventArgs = NativeItemsPickedEventArgs;    // Windows.UI.Xaml.Controls.ItemsPickedEventArgs 
export type MapInputEventArgs = NativeMapInputEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapInputEventArgs 
export type MapActualCameraChangedEventArgs = NativeMapActualCameraChangedEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapActualCameraChangedEventArgs 
export type MapActualCameraChangingEventArgs = NativeMapActualCameraChangingEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapActualCameraChangingEventArgs 
export type MapCustomExperienceChangedEventArgs = NativeMapCustomExperienceChangedEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapCustomExperienceChangedEventArgs 
export type MapElementClickEventArgs = NativeMapElementClickEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapElementClickEventArgs 
export type MapElementPointerEnteredEventArgs = NativeMapElementPointerEnteredEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapElementPointerEnteredEventArgs 
export type MapElementPointerExitedEventArgs = NativeMapElementPointerExitedEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapElementPointerExitedEventArgs 
export type MapTargetCameraChangedEventArgs = NativeMapTargetCameraChangedEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapTargetCameraChangedEventArgs 
export type MapRightTappedEventArgs = NativeMapRightTappedEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapRightTappedEventArgs 
export type MapContextRequestedEventArgs = NativeMapContextRequestedEventArgs;    // Windows.UI.Xaml.Controls.Maps.MapContextRequestedEventArgs 
export type TimelineMarkerRoutedEventArgs = NativeTimelineMarkerRoutedEventArgs;    // Windows.UI.Xaml.Media.TimelineMarkerRoutedEventArgs 
export type RateChangedRoutedEventArgs = NativeRateChangedRoutedEventArgs;    // Windows.UI.Xaml.Media.RateChangedRoutedEventArgs 
export type PartialMediaFailureDetectedEventArgs = NativePartialMediaFailureDetectedEventArgs;    // Windows.UI.Xaml.Media.PartialMediaFailureDetectedEventArgs 
export type MediaTransportControlsThumbnailRequestedEventArgs = NativeMediaTransportControlsThumbnailRequestedEventArgs;    // Windows.UI.Xaml.Media.MediaTransportControlsThumbnailRequestedEventArgs 
export type NavigationViewDisplayModeChangedEventArgs = NativeNavigationViewDisplayModeChangedEventArgs;    // Windows.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs 
export type NavigationViewItemInvokedEventArgs = NativeNavigationViewItemInvokedEventArgs;    // Windows.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs 
export type NavigationViewSelectionChangedEventArgs = NativeNavigationViewSelectionChangedEventArgs;    // Windows.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs 
export type NavigationViewBackRequestedEventArgs = NativeNavigationViewBackRequestedEventArgs;    // Windows.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs 
export type NavigationViewPaneClosingEventArgs = NativeNavigationViewPaneClosingEventArgs;    // Windows.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs 
export type ContextMenuEventArgs = NativeContextMenuEventArgs;    // Windows.UI.Xaml.Controls.ContextMenuEventArgs 
export type TextControlPasteEventArgs = NativeTextControlPasteEventArgs;    // Windows.UI.Xaml.Controls.TextControlPasteEventArgs 
export type PasswordBoxPasswordChangingEventArgs = NativePasswordBoxPasswordChangingEventArgs;    // Windows.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs 
export type PickerConfirmedEventArgs = NativePickerConfirmedEventArgs;    // Windows.UI.Xaml.Controls.PickerConfirmedEventArgs 
export type PivotItemEventArgs = NativePivotItemEventArgs;    // Windows.UI.Xaml.Controls.PivotItemEventArgs 
export type RangeBaseValueChangedEventArgs = NativeRangeBaseValueChangedEventArgs;    // Windows.UI.Xaml.Controls.Primitives.RangeBaseValueChangedEventArgs 
export type ScrollEventArgs = NativeScrollEventArgs;    // Windows.UI.Xaml.Controls.Primitives.ScrollEventArgs 
export type DragCompletedEventArgs = NativeDragCompletedEventArgs;    // Windows.UI.Xaml.Controls.Primitives.DragCompletedEventArgs 
export type DragDeltaEventArgs = NativeDragDeltaEventArgs;    // Windows.UI.Xaml.Controls.Primitives.DragDeltaEventArgs 
export type DragStartedEventArgs = NativeDragStartedEventArgs;    // Windows.UI.Xaml.Controls.Primitives.DragStartedEventArgs 
export type RefreshRequestedEventArgs = NativeRefreshRequestedEventArgs;    // Windows.UI.Xaml.Controls.RefreshRequestedEventArgs 
export type RefreshStateChangedEventArgs = NativeRefreshStateChangedEventArgs;    // Windows.UI.Xaml.Controls.RefreshStateChangedEventArgs 
export type CandidateWindowBoundsChangedEventArgs = NativeCandidateWindowBoundsChangedEventArgs;    // Windows.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs 
export type RichEditBoxTextChangingEventArgs = NativeRichEditBoxTextChangingEventArgs;    // Windows.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs 
export type TextCompositionChangedEventArgs = NativeTextCompositionChangedEventArgs;    // Windows.UI.Xaml.Controls.TextCompositionChangedEventArgs 
export type TextCompositionEndedEventArgs = NativeTextCompositionEndedEventArgs;    // Windows.UI.Xaml.Controls.TextCompositionEndedEventArgs 
export type TextCompositionStartedEventArgs = NativeTextCompositionStartedEventArgs;    // Windows.UI.Xaml.Controls.TextCompositionStartedEventArgs 
export type TextControlCopyingToClipboardEventArgs = NativeTextControlCopyingToClipboardEventArgs;    // Windows.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs 
export type TextControlCuttingToClipboardEventArgs = NativeTextControlCuttingToClipboardEventArgs;    // Windows.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs 
export type ContentLinkChangedEventArgs = NativeContentLinkChangedEventArgs;    // Windows.UI.Xaml.Controls.ContentLinkChangedEventArgs 
export type ContentLinkInvokedEventArgs = NativeContentLinkInvokedEventArgs;    // Windows.UI.Xaml.Documents.ContentLinkInvokedEventArgs 
export type RichEditBoxSelectionChangingEventArgs = NativeRichEditBoxSelectionChangingEventArgs;    // Windows.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs 
export type IsTextTrimmedChangedEventArgs = NativeIsTextTrimmedChangedEventArgs;    // Windows.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs 
export type ScrollViewerViewChangedEventArgs = NativeScrollViewerViewChangedEventArgs;    // Windows.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs 
export type ScrollViewerViewChangingEventArgs = NativeScrollViewerViewChangingEventArgs;    // Windows.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs 
export type AnchorRequestedEventArgs = NativeAnchorRequestedEventArgs;    // Windows.UI.Xaml.Controls.AnchorRequestedEventArgs 
export type SearchBoxQueryChangedEventArgs = NativeSearchBoxQueryChangedEventArgs;    // Windows.UI.Xaml.Controls.SearchBoxQueryChangedEventArgs 
export type SearchBoxQuerySubmittedEventArgs = NativeSearchBoxQuerySubmittedEventArgs;    // Windows.UI.Xaml.Controls.SearchBoxQuerySubmittedEventArgs 
export type SearchBoxResultSuggestionChosenEventArgs = NativeSearchBoxResultSuggestionChosenEventArgs;    // Windows.UI.Xaml.Controls.SearchBoxResultSuggestionChosenEventArgs 
export type SearchBoxSuggestionsRequestedEventArgs = NativeSearchBoxSuggestionsRequestedEventArgs;    // Windows.UI.Xaml.Controls.SearchBoxSuggestionsRequestedEventArgs 
export type SemanticZoomViewChangedEventArgs = NativeSemanticZoomViewChangedEventArgs;    // Windows.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs 
export type BackClickEventArgs = NativeBackClickEventArgs;    // Windows.UI.Xaml.Controls.BackClickEventArgs 
export type SplitButtonClickEventArgs = NativeSplitButtonClickEventArgs;    // Windows.UI.Xaml.Controls.SplitButtonClickEventArgs 
export type SplitViewPaneClosingEventArgs = NativeSplitViewPaneClosingEventArgs;    // Windows.UI.Xaml.Controls.SplitViewPaneClosingEventArgs 
export type TextChangedEventArgs = NativeTextChangedEventArgs;    // Windows.UI.Xaml.Controls.TextChangedEventArgs 
export type TextBoxTextChangingEventArgs = NativeTextBoxTextChangingEventArgs;    // Windows.UI.Xaml.Controls.TextBoxTextChangingEventArgs 
export type TextBoxBeforeTextChangingEventArgs = NativeTextBoxBeforeTextChangingEventArgs;    // Windows.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs 
export type TextBoxSelectionChangingEventArgs = NativeTextBoxSelectionChangingEventArgs;    // Windows.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs 
export type TimePickerValueChangedEventArgs = NativeTimePickerValueChangedEventArgs;    // Windows.UI.Xaml.Controls.TimePickerValueChangedEventArgs 
export type TimePickerSelectedValueChangedEventArgs = NativeTimePickerSelectedValueChangedEventArgs;    // Windows.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs 
export type TimePickedEventArgs = NativeTimePickedEventArgs;    // Windows.UI.Xaml.Controls.TimePickedEventArgs 
export type ToggleSplitButtonIsCheckedChangedEventArgs = NativeToggleSplitButtonIsCheckedChangedEventArgs;    // Windows.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs 
export type TreeViewCollapsedEventArgs = NativeTreeViewCollapsedEventArgs;    // Windows.UI.Xaml.Controls.TreeViewCollapsedEventArgs 
export type TreeViewExpandingEventArgs = NativeTreeViewExpandingEventArgs;    // Windows.UI.Xaml.Controls.TreeViewExpandingEventArgs 
export type TreeViewItemInvokedEventArgs = NativeTreeViewItemInvokedEventArgs;    // Windows.UI.Xaml.Controls.TreeViewItemInvokedEventArgs 
export type TreeViewDragItemsCompletedEventArgs = NativeTreeViewDragItemsCompletedEventArgs;    // Windows.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs 
export type TreeViewDragItemsStartingEventArgs = NativeTreeViewDragItemsStartingEventArgs;    // Windows.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs 
export type CleanUpVirtualizedItemEventArgs = NativeCleanUpVirtualizedItemEventArgs;    // Windows.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs 
export type WebViewNavigationFailedEventArgs = NativeWebViewNavigationFailedEventArgs;    // Windows.UI.Xaml.Controls.WebViewNavigationFailedEventArgs 
export type NotifyEventArgs = NativeNotifyEventArgs;    // Windows.UI.Xaml.Controls.NotifyEventArgs 
export type WebViewContentLoadingEventArgs = NativeWebViewContentLoadingEventArgs;    // Windows.UI.Xaml.Controls.WebViewContentLoadingEventArgs 
export type WebViewDOMContentLoadedEventArgs = NativeWebViewDOMContentLoadedEventArgs;    // Windows.UI.Xaml.Controls.WebViewDOMContentLoadedEventArgs 
export type WebViewNavigationCompletedEventArgs = NativeWebViewNavigationCompletedEventArgs;    // Windows.UI.Xaml.Controls.WebViewNavigationCompletedEventArgs 
export type WebViewNavigationStartingEventArgs = NativeWebViewNavigationStartingEventArgs;    // Windows.UI.Xaml.Controls.WebViewNavigationStartingEventArgs 
export type WebViewLongRunningScriptDetectedEventArgs = NativeWebViewLongRunningScriptDetectedEventArgs;    // Windows.UI.Xaml.Controls.WebViewLongRunningScriptDetectedEventArgs 
export type WebViewUnviewableContentIdentifiedEventArgs = NativeWebViewUnviewableContentIdentifiedEventArgs;    // Windows.UI.Xaml.Controls.WebViewUnviewableContentIdentifiedEventArgs 
export type WebViewNewWindowRequestedEventArgs = NativeWebViewNewWindowRequestedEventArgs;    // Windows.UI.Xaml.Controls.WebViewNewWindowRequestedEventArgs 
export type WebViewPermissionRequestedEventArgs = NativeWebViewPermissionRequestedEventArgs;    // Windows.UI.Xaml.Controls.WebViewPermissionRequestedEventArgs 
export type WebViewUnsupportedUriSchemeIdentifiedEventArgs = NativeWebViewUnsupportedUriSchemeIdentifiedEventArgs;    // Windows.UI.Xaml.Controls.WebViewUnsupportedUriSchemeIdentifiedEventArgs 
export type WebViewSeparateProcessLostEventArgs = NativeWebViewSeparateProcessLostEventArgs;    // Windows.UI.Xaml.Controls.WebViewSeparateProcessLostEventArgs 
export type WebViewWebResourceRequestedEventArgs = NativeWebViewWebResourceRequestedEventArgs;    // Windows.UI.Xaml.Controls.WebViewWebResourceRequestedEventArgs 
export type HyperlinkClickEventArgs = NativeHyperlinkClickEventArgs;    // Windows.UI.Xaml.Documents.HyperlinkClickEventArgs 
export type KeyboardAcceleratorInvokedEventArgs = NativeKeyboardAcceleratorInvokedEventArgs;    // Windows.UI.Xaml.Input.KeyboardAcceleratorInvokedEventArgs