diff --git a/package/Codegen/TSTypes.cs b/package/Codegen/TSTypes.cs
index 4aa946f5..f80a63eb 100644
--- a/package/Codegen/TSTypes.cs
+++ b/package/Codegen/TSTypes.cs
@@ -18,7 +18,7 @@ namespace Codegen
     /// Class to produce the template output
     /// </summary>
     
-    #line 1 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+    #line 1 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.TextTemplating", "17.0.0.0")]
     public partial class TSTypes : TSTypesBase
     {
@@ -32,72 +32,72 @@ public virtual string TransformText()
                     "UTOMATICALLY GENERATED, DO NOT MODIFY MANUALLY\r\n********************************" +
                     "******************************/\r\n\r\nimport type {\r\n    // Controls\r\n");
             
-            #line 13 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 13 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
  foreach (var type in Types.Where(t => Util.HasCtor(t) && Util.GetTSNamespace(t) == "")) { 
             
             #line default
             #line hidden
             this.Write("    ");
             
-            #line 14 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 14 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(Util.GetNativePropsName(type)));
             
             #line default
             #line hidden
             this.Write(",\r\n");
             
-            #line 15 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 15 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
  } 
             
             #line default
             #line hidden
             this.Write("\r\n    // EventArgs\r\n");
             
-            #line 18 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 18 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
  foreach (var type in Util.eventArgsTypes.Where(t => Util.GetTSNamespace(t) == "")) { 
             
             #line default
             #line hidden
             this.Write("    Native");
             
-            #line 19 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 19 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(type.GetName()));
             
             #line default
             #line hidden
             this.Write(",\r\n");
             
-            #line 20 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 20 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
  } 
             
             #line default
             #line hidden
             this.Write("} from \'./Props\';\r\n\r\n");
             
-            #line 23 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 23 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
  foreach (var ns in Types.Where(t => Util.HasCtor(t) && Util.GetTSNamespace(t) != "").Select(t => Util.GetTSNamespace(t)).Distinct()) { 
             
             #line default
             #line hidden
             this.Write("import type { Native");
             
-            #line 24 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 24 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(ns));
             
             #line default
             #line hidden
             this.Write(" } from \'./Props\';\r\n");
             
-            #line 25 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 25 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
  } 
             
             #line default
             #line hidden
             this.Write("\r\nimport React from \'react\';\r\nimport { NativeXamlControl } from \'./NativeXamlCont" +
-                    "rol\';\r\nimport { findNodeHandle, UIManager } from \'react-native\';\r\n\r\nimport type " +
+                    "rol\';\r\nimport { findNodeHandle, NativeMethods, UIManager } from \'react-native\';\r\n\r\nimport type " +
                     "{ Point, Color } from \'./Props\';\r\n\r\nexport type { Point, Color };\r\n\r\n");
             
-            #line 35 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 35 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
  
 foreach (var type in Types.Where(t => Util.HasCtor(t))) { 
     var ns = Util.GetTSNamespace(type);
@@ -107,85 +107,104 @@ public virtual string TransformText()
             #line hidden
             this.Write("export namespace ");
             
-            #line 39 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 39 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(ns));
             
             #line default
             #line hidden
             this.Write(" {\r\n");
             
-            #line 40 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 40 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
   } 
             
             #line default
             #line hidden
             this.Write("export type ");
             
-            #line 41 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 41 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(Util.ToJsName(type)));
             
             #line default
             #line hidden
             this.Write("Props = Omit<");
             
-            #line 41 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 41 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
+            this.Write(this.ToStringHelper.ToStringWithCulture(Util.GetNativePropsName(type)));
+
+            #line default
+            #line hidden
+            this.Write(", \'type\'>;\r\n");
+
+
+            #line default
+            #line hidden
+            this.Write("export type ");
+            
+            #line 42 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
+            this.Write(this.ToStringHelper.ToStringWithCulture(Util.ToJsName(type)));
+            
+            #line default
+            #line hidden
+            this.Write("Ref = React.Component<");
+            
+            #line 42 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(Util.GetNativePropsName(type)));
             
             #line default
             #line hidden
-            this.Write(", \'type\'>;\r\n\r\nexport const ");
+            this.Write("> & Readonly<NativeMethods>;\r\n\r\nexport const ");
+
             
-            #line 43 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 44 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(Util.ToJsName(type)));
             
             #line default
             #line hidden
             this.Write(" = React.forwardRef((props: ");
             
-            #line 43 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 44 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(Util.ToJsName(type)));
             
             #line default
             #line hidden
-            this.Write("Props, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {" +
-                    "...props} type=\'");
+            this.Write("Props, ref: React.ForwardedRef<");
             
-            #line 43 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 44 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
+            this.Write(this.ToStringHelper.ToStringWithCulture(Util.ToJsName(type)));
+
+            #line default
+            #line hidden
+            this.Write("Ref>) => <NativeXamlControl {...props} type=\'");
+            
+            #line 44 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(type.GetFullName()));
             
             #line default
             #line hidden
             this.Write("\' ref={ref} />);\r\n");
             
-            #line 44 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 45 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
 
     foreach (var command in Util.GetCommands(type.GetFullName())) { 
             
             #line default
             #line hidden
             
-            #line 46 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 47 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(Util.ToJsName(type)));
             
             #line default
             #line hidden
             this.Write(".");
             
-            #line 46 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 47 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(command.Name));
             
             #line default
             #line hidden
-            this.Write(" = (ref: React.MutableRefObject<");
-            
-            #line 46 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
-            this.Write(this.ToStringHelper.ToStringWithCulture(Util.ToJsName(type)));
-            
-            #line default
-            #line hidden
-            this.Write(">, args: ");
+            this.Write(" = (ref: React.MutableRefObject<typeof NativeXamlControl>, args: ");
             
-            #line 46 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 47 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(command.TSArgTypes != null ? command.TSArgTypes : "any[]"));
             
             #line default
@@ -193,40 +212,40 @@ public virtual string TransformText()
             this.Write(") => {\r\n  const tag = findNodeHandle(ref.current);\r\n  UIManager.dispatchViewManag" +
                     "erCommand(tag, UIManager.getViewManagerConfig(\'XamlControl\').Commands.");
             
-            #line 48 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 49 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(command.Name));
             
             #line default
             #line hidden
             this.Write(", ");
             
-            #line 48 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 49 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(command.TSArgTypes != null ? "[args]" : "args"));
             
             #line default
             #line hidden
             this.Write(");\r\n};\r\n");
             
-            #line 50 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 51 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
   } 
             
             #line default
             #line hidden
             
-            #line 51 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 52 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
   if (ns != "") { 
             
             #line default
             #line hidden
             this.Write("}\r\n");
             
-            #line 53 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 54 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
   } 
             
             #line default
             #line hidden
             
-            #line 54 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 55 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
 
 } 
             
@@ -234,7 +253,7 @@ public virtual string TransformText()
             #line hidden
             this.Write("\r\n");
             
-            #line 57 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 58 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
 
 foreach (var ea in Util.eventArgsTypes) {
     var ns = Util.GetTSNamespace(ea);
@@ -244,14 +263,14 @@ public virtual string TransformText()
             #line hidden
             this.Write("export namespace ");
             
-            #line 61 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 62 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(ns));
             
             #line default
             #line hidden
             this.Write(" {\r\n");
             
-            #line 62 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 63 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
 
     }
 
@@ -260,41 +279,41 @@ public virtual string TransformText()
             #line hidden
             this.Write("export type ");
             
-            #line 65 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 64 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(ea.GetName()));
             
             #line default
             #line hidden
             this.Write(" = ");
             
-            #line 65 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 66 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(Util.GetEventArgsTSType(ea, "Native")));
             
             #line default
             #line hidden
             this.Write(";    // ");
             
-            #line 65 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 66 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
             this.Write(this.ToStringHelper.ToStringWithCulture(ea.GetFullName()));
             
             #line default
             #line hidden
             this.Write(" \r\n");
             
-            #line 66 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 67 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
   if (ns != "") { 
             
             #line default
             #line hidden
             this.Write("}\r\n");
             
-            #line 68 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 69 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
   } 
             
             #line default
             #line hidden
             
-            #line 69 "F:\react-native-xaml\package\Codegen\TSTypes.tt"
+            #line 70 "E:\react-native-xaml\package\Codegen\TSTypes.tt"
 
 } 
             
diff --git a/package/src/Types.tsx b/package/src/Types.tsx
index 3107baa1..6ce6f1e1 100644
--- a/package/src/Types.tsx
+++ b/package/src/Types.tsx
@@ -331,7 +331,7 @@ import type { NativeWinUI } from './Props';
 
 import React from 'react';
 import { NativeXamlControl } from './NativeXamlControl';
-import { findNodeHandle, UIManager } from 'react-native';
+import { findNodeHandle, NativeMethods, UIManager } from 'react-native';
 
 import type { Point, Color } from './Props';
 
@@ -339,763 +339,982 @@ export type { Point, Color };
 
 export namespace WinUI {
 export type AnimatedIconProps = Omit<NativeWinUI.NativeAnimatedIconProps, 'type'>;
+export type AnimatedIconRef = React.Component<NativeWinUI.NativeAnimatedIconProps> & Readonly<NativeMethods>;
 
-export const AnimatedIcon = React.forwardRef((props: AnimatedIconProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.AnimatedIcon' ref={ref} />);
+export const AnimatedIcon = React.forwardRef((props: AnimatedIconProps, ref: React.ForwardedRef<AnimatedIconRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.AnimatedIcon' ref={ref} />);
 }
 export namespace WinUI {
 export type AnimatedVisualPlayerProps = Omit<NativeWinUI.NativeAnimatedVisualPlayerProps, 'type'>;
+export type AnimatedVisualPlayerRef = React.Component<NativeWinUI.NativeAnimatedVisualPlayerProps> & Readonly<NativeMethods>;
 
-export const AnimatedVisualPlayer = React.forwardRef((props: AnimatedVisualPlayerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer' ref={ref} />);
+export const AnimatedVisualPlayer = React.forwardRef((props: AnimatedVisualPlayerProps, ref: React.ForwardedRef<AnimatedVisualPlayerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer' ref={ref} />);
 }
 export namespace WinUI {
 export type BreadcrumbBarProps = Omit<NativeWinUI.NativeBreadcrumbBarProps, 'type'>;
+export type BreadcrumbBarRef = React.Component<NativeWinUI.NativeBreadcrumbBarProps> & Readonly<NativeMethods>;
 
-export const BreadcrumbBar = React.forwardRef((props: BreadcrumbBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.BreadcrumbBar' ref={ref} />);
+export const BreadcrumbBar = React.forwardRef((props: BreadcrumbBarProps, ref: React.ForwardedRef<BreadcrumbBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.BreadcrumbBar' ref={ref} />);
 }
 export namespace WinUI {
 export type BreadcrumbBarItemProps = Omit<NativeWinUI.NativeBreadcrumbBarItemProps, 'type'>;
+export type BreadcrumbBarItemRef = React.Component<NativeWinUI.NativeBreadcrumbBarItemProps> & Readonly<NativeMethods>;
 
-export const BreadcrumbBarItem = React.forwardRef((props: BreadcrumbBarItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.BreadcrumbBarItem' ref={ref} />);
+export const BreadcrumbBarItem = React.forwardRef((props: BreadcrumbBarItemProps, ref: React.ForwardedRef<BreadcrumbBarItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.BreadcrumbBarItem' ref={ref} />);
 }
 export namespace WinUI {
 export type ColorPickerProps = Omit<NativeWinUI.NativeColorPickerProps, 'type'>;
+export type ColorPickerRef = React.Component<NativeWinUI.NativeColorPickerProps> & Readonly<NativeMethods>;
 
-export const ColorPicker = React.forwardRef((props: ColorPickerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ColorPicker' ref={ref} />);
+export const ColorPicker = React.forwardRef((props: ColorPickerProps, ref: React.ForwardedRef<ColorPickerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ColorPicker' ref={ref} />);
 }
 export namespace WinUI {
 export type CommandBarFlyoutProps = Omit<NativeWinUI.NativeCommandBarFlyoutProps, 'type'>;
+export type CommandBarFlyoutRef = React.Component<NativeWinUI.NativeCommandBarFlyoutProps> & Readonly<NativeMethods>;
 
-export const CommandBarFlyout = React.forwardRef((props: CommandBarFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.CommandBarFlyout' ref={ref} />);
+export const CommandBarFlyout = React.forwardRef((props: CommandBarFlyoutProps, ref: React.ForwardedRef<CommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.CommandBarFlyout' ref={ref} />);
 }
 export namespace WinUI {
 export type DropDownButtonProps = Omit<NativeWinUI.NativeDropDownButtonProps, 'type'>;
+export type DropDownButtonRef = React.Component<NativeWinUI.NativeDropDownButtonProps> & Readonly<NativeMethods>;
 
-export const DropDownButton = React.forwardRef((props: DropDownButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.DropDownButton' ref={ref} />);
+export const DropDownButton = React.forwardRef((props: DropDownButtonProps, ref: React.ForwardedRef<DropDownButtonRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.DropDownButton' ref={ref} />);
 }
 export namespace WinUI {
 export type ExpanderProps = Omit<NativeWinUI.NativeExpanderProps, 'type'>;
+export type ExpanderRef = React.Component<NativeWinUI.NativeExpanderProps> & Readonly<NativeMethods>;
 
-export const Expander = React.forwardRef((props: ExpanderProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Expander' ref={ref} />);
+export const Expander = React.forwardRef((props: ExpanderProps, ref: React.ForwardedRef<ExpanderRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Expander' ref={ref} />);
 }
 export namespace WinUI {
 export type ImageIconProps = Omit<NativeWinUI.NativeImageIconProps, 'type'>;
+export type ImageIconRef = React.Component<NativeWinUI.NativeImageIconProps> & Readonly<NativeMethods>;
 
-export const ImageIcon = React.forwardRef((props: ImageIconProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ImageIcon' ref={ref} />);
+export const ImageIcon = React.forwardRef((props: ImageIconProps, ref: React.ForwardedRef<ImageIconRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ImageIcon' ref={ref} />);
 }
 export namespace WinUI {
 export type InfoBarProps = Omit<NativeWinUI.NativeInfoBarProps, 'type'>;
+export type InfoBarRef = React.Component<NativeWinUI.NativeInfoBarProps> & Readonly<NativeMethods>;
 
-export const InfoBar = React.forwardRef((props: InfoBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.InfoBar' ref={ref} />);
+export const InfoBar = React.forwardRef((props: InfoBarProps, ref: React.ForwardedRef<InfoBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.InfoBar' ref={ref} />);
 }
 export namespace WinUI {
 export type ItemsRepeaterProps = Omit<NativeWinUI.NativeItemsRepeaterProps, 'type'>;
+export type ItemsRepeaterRef = React.Component<NativeWinUI.NativeItemsRepeaterProps> & Readonly<NativeMethods>;
 
-export const ItemsRepeater = React.forwardRef((props: ItemsRepeaterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ItemsRepeater' ref={ref} />);
+export const ItemsRepeater = React.forwardRef((props: ItemsRepeaterProps, ref: React.ForwardedRef<ItemsRepeaterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ItemsRepeater' ref={ref} />);
 }
 export namespace WinUI {
 export type ItemsRepeaterScrollHostProps = Omit<NativeWinUI.NativeItemsRepeaterScrollHostProps, 'type'>;
+export type ItemsRepeaterScrollHostRef = React.Component<NativeWinUI.NativeItemsRepeaterScrollHostProps> & Readonly<NativeMethods>;
 
-export const ItemsRepeaterScrollHost = React.forwardRef((props: ItemsRepeaterScrollHostProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost' ref={ref} />);
+export const ItemsRepeaterScrollHost = React.forwardRef((props: ItemsRepeaterScrollHostProps, ref: React.ForwardedRef<ItemsRepeaterScrollHostRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost' ref={ref} />);
 }
 export namespace WinUI {
 export type MenuBarProps = Omit<NativeWinUI.NativeMenuBarProps, 'type'>;
+export type MenuBarRef = React.Component<NativeWinUI.NativeMenuBarProps> & Readonly<NativeMethods>;
 
-export const MenuBar = React.forwardRef((props: MenuBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBar' ref={ref} />);
+export const MenuBar = React.forwardRef((props: MenuBarProps, ref: React.ForwardedRef<MenuBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBar' ref={ref} />);
 }
 export namespace WinUI {
 export type MenuBarItemProps = Omit<NativeWinUI.NativeMenuBarItemProps, 'type'>;
+export type MenuBarItemRef = React.Component<NativeWinUI.NativeMenuBarItemProps> & Readonly<NativeMethods>;
 
-export const MenuBarItem = React.forwardRef((props: MenuBarItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBarItem' ref={ref} />);
+export const MenuBarItem = React.forwardRef((props: MenuBarItemProps, ref: React.ForwardedRef<MenuBarItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBarItem' ref={ref} />);
 }
 export namespace WinUI {
 export type MenuBarItemFlyoutProps = Omit<NativeWinUI.NativeMenuBarItemFlyoutProps, 'type'>;
+export type MenuBarItemFlyoutRef = React.Component<NativeWinUI.NativeMenuBarItemFlyoutProps> & Readonly<NativeMethods>;
 
-export const MenuBarItemFlyout = React.forwardRef((props: MenuBarItemFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBarItemFlyout' ref={ref} />);
+export const MenuBarItemFlyout = React.forwardRef((props: MenuBarItemFlyoutProps, ref: React.ForwardedRef<MenuBarItemFlyoutRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.MenuBarItemFlyout' ref={ref} />);
 }
 export namespace WinUI {
 export type NavigationViewProps = Omit<NativeWinUI.NativeNavigationViewProps, 'type'>;
+export type NavigationViewRef = React.Component<NativeWinUI.NativeNavigationViewProps> & Readonly<NativeMethods>;
 
-export const NavigationView = React.forwardRef((props: NavigationViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationView' ref={ref} />);
+export const NavigationView = React.forwardRef((props: NavigationViewProps, ref: React.ForwardedRef<NavigationViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationView' ref={ref} />);
 }
 export namespace WinUI {
 export type NavigationViewItemProps = Omit<NativeWinUI.NativeNavigationViewItemProps, 'type'>;
+export type NavigationViewItemRef = React.Component<NativeWinUI.NativeNavigationViewItemProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItem = React.forwardRef((props: NavigationViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItem' ref={ref} />);
+export const NavigationViewItem = React.forwardRef((props: NavigationViewItemProps, ref: React.ForwardedRef<NavigationViewItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItem' ref={ref} />);
 }
 export namespace WinUI {
 export type NavigationViewItemHeaderProps = Omit<NativeWinUI.NativeNavigationViewItemHeaderProps, 'type'>;
+export type NavigationViewItemHeaderRef = React.Component<NativeWinUI.NativeNavigationViewItemHeaderProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItemHeader = React.forwardRef((props: NavigationViewItemHeaderProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItemHeader' ref={ref} />);
+export const NavigationViewItemHeader = React.forwardRef((props: NavigationViewItemHeaderProps, ref: React.ForwardedRef<NavigationViewItemHeaderRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItemHeader' ref={ref} />);
 }
 export namespace WinUI {
 export type NavigationViewItemSeparatorProps = Omit<NativeWinUI.NativeNavigationViewItemSeparatorProps, 'type'>;
+export type NavigationViewItemSeparatorRef = React.Component<NativeWinUI.NativeNavigationViewItemSeparatorProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItemSeparator = React.forwardRef((props: NavigationViewItemSeparatorProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItemSeparator' ref={ref} />);
+export const NavigationViewItemSeparator = React.forwardRef((props: NavigationViewItemSeparatorProps, ref: React.ForwardedRef<NavigationViewItemSeparatorRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NavigationViewItemSeparator' ref={ref} />);
 }
 export namespace WinUI {
 export type NumberBoxProps = Omit<NativeWinUI.NativeNumberBoxProps, 'type'>;
+export type NumberBoxRef = React.Component<NativeWinUI.NativeNumberBoxProps> & Readonly<NativeMethods>;
 
-export const NumberBox = React.forwardRef((props: NumberBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NumberBox' ref={ref} />);
+export const NumberBox = React.forwardRef((props: NumberBoxProps, ref: React.ForwardedRef<NumberBoxRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.NumberBox' ref={ref} />);
 }
 export namespace WinUI {
 export type ParallaxViewProps = Omit<NativeWinUI.NativeParallaxViewProps, 'type'>;
+export type ParallaxViewRef = React.Component<NativeWinUI.NativeParallaxViewProps> & Readonly<NativeMethods>;
 
-export const ParallaxView = React.forwardRef((props: ParallaxViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ParallaxView' ref={ref} />);
+export const ParallaxView = React.forwardRef((props: ParallaxViewProps, ref: React.ForwardedRef<ParallaxViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ParallaxView' ref={ref} />);
 }
 export namespace WinUI {
 export type PersonPictureProps = Omit<NativeWinUI.NativePersonPictureProps, 'type'>;
+export type PersonPictureRef = React.Component<NativeWinUI.NativePersonPictureProps> & Readonly<NativeMethods>;
 
-export const PersonPicture = React.forwardRef((props: PersonPictureProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.PersonPicture' ref={ref} />);
+export const PersonPicture = React.forwardRef((props: PersonPictureProps, ref: React.ForwardedRef<PersonPictureRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.PersonPicture' ref={ref} />);
 }
 export namespace WinUI {
 export type PipsPagerProps = Omit<NativeWinUI.NativePipsPagerProps, 'type'>;
+export type PipsPagerRef = React.Component<NativeWinUI.NativePipsPagerProps> & Readonly<NativeMethods>;
 
-export const PipsPager = React.forwardRef((props: PipsPagerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.PipsPager' ref={ref} />);
+export const PipsPager = React.forwardRef((props: PipsPagerProps, ref: React.ForwardedRef<PipsPagerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.PipsPager' ref={ref} />);
 }
 export namespace WinUI {
 export type ColorPickerSliderProps = Omit<NativeWinUI.NativeColorPickerSliderProps, 'type'>;
+export type ColorPickerSliderRef = React.Component<NativeWinUI.NativeColorPickerSliderProps> & Readonly<NativeMethods>;
 
-export const ColorPickerSlider = React.forwardRef((props: ColorPickerSliderProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.ColorPickerSlider' ref={ref} />);
+export const ColorPickerSlider = React.forwardRef((props: ColorPickerSliderProps, ref: React.ForwardedRef<ColorPickerSliderRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.ColorPickerSlider' ref={ref} />);
 }
 export namespace WinUI {
 export type ColorSpectrumProps = Omit<NativeWinUI.NativeColorSpectrumProps, 'type'>;
+export type ColorSpectrumRef = React.Component<NativeWinUI.NativeColorSpectrumProps> & Readonly<NativeMethods>;
 
-export const ColorSpectrum = React.forwardRef((props: ColorSpectrumProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.ColorSpectrum' ref={ref} />);
+export const ColorSpectrum = React.forwardRef((props: ColorSpectrumProps, ref: React.ForwardedRef<ColorSpectrumRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.ColorSpectrum' ref={ref} />);
 }
 export namespace WinUI {
 export type CommandBarFlyoutCommandBarProps = Omit<NativeWinUI.NativeCommandBarFlyoutCommandBarProps, 'type'>;
+export type CommandBarFlyoutCommandBarRef = React.Component<NativeWinUI.NativeCommandBarFlyoutCommandBarProps> & Readonly<NativeMethods>;
 
-export const CommandBarFlyoutCommandBar = React.forwardRef((props: CommandBarFlyoutCommandBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBar' ref={ref} />);
+export const CommandBarFlyoutCommandBar = React.forwardRef((props: CommandBarFlyoutCommandBarProps, ref: React.ForwardedRef<CommandBarFlyoutCommandBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBar' ref={ref} />);
 }
 export namespace WinUI {
 export type InfoBarPanelProps = Omit<NativeWinUI.NativeInfoBarPanelProps, 'type'>;
+export type InfoBarPanelRef = React.Component<NativeWinUI.NativeInfoBarPanelProps> & Readonly<NativeMethods>;
 
-export const InfoBarPanel = React.forwardRef((props: InfoBarPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.InfoBarPanel' ref={ref} />);
+export const InfoBarPanel = React.forwardRef((props: InfoBarPanelProps, ref: React.ForwardedRef<InfoBarPanelRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.InfoBarPanel' ref={ref} />);
 }
 export namespace WinUI {
 export type MonochromaticOverlayPresenterProps = Omit<NativeWinUI.NativeMonochromaticOverlayPresenterProps, 'type'>;
+export type MonochromaticOverlayPresenterRef = React.Component<NativeWinUI.NativeMonochromaticOverlayPresenterProps> & Readonly<NativeMethods>;
 
-export const MonochromaticOverlayPresenter = React.forwardRef((props: MonochromaticOverlayPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.MonochromaticOverlayPresenter' ref={ref} />);
+export const MonochromaticOverlayPresenter = React.forwardRef((props: MonochromaticOverlayPresenterProps, ref: React.ForwardedRef<MonochromaticOverlayPresenterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.MonochromaticOverlayPresenter' ref={ref} />);
 }
 export namespace WinUI {
 export type NavigationViewItemPresenterProps = Omit<NativeWinUI.NativeNavigationViewItemPresenterProps, 'type'>;
+export type NavigationViewItemPresenterRef = React.Component<NativeWinUI.NativeNavigationViewItemPresenterProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItemPresenter = React.forwardRef((props: NavigationViewItemPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.NavigationViewItemPresenter' ref={ref} />);
+export const NavigationViewItemPresenter = React.forwardRef((props: NavigationViewItemPresenterProps, ref: React.ForwardedRef<NavigationViewItemPresenterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.NavigationViewItemPresenter' ref={ref} />);
 }
 export namespace WinUI {
 export type TabViewListViewProps = Omit<NativeWinUI.NativeTabViewListViewProps, 'type'>;
+export type TabViewListViewRef = React.Component<NativeWinUI.NativeTabViewListViewProps> & Readonly<NativeMethods>;
 
-export const TabViewListView = React.forwardRef((props: TabViewListViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.TabViewListView' ref={ref} />);
+export const TabViewListView = React.forwardRef((props: TabViewListViewProps, ref: React.ForwardedRef<TabViewListViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.Primitives.TabViewListView' ref={ref} />);
 }
 export namespace WinUI {
 export type ProgressBarProps = Omit<NativeWinUI.NativeProgressBarProps, 'type'>;
+export type ProgressBarRef = React.Component<NativeWinUI.NativeProgressBarProps> & Readonly<NativeMethods>;
 
-export const ProgressBar = React.forwardRef((props: ProgressBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ProgressBar' ref={ref} />);
+export const ProgressBar = React.forwardRef((props: ProgressBarProps, ref: React.ForwardedRef<ProgressBarRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ProgressBar' ref={ref} />);
 }
 export namespace WinUI {
 export type ProgressRingProps = Omit<NativeWinUI.NativeProgressRingProps, 'type'>;
+export type ProgressRingRef = React.Component<NativeWinUI.NativeProgressRingProps> & Readonly<NativeMethods>;
 
-export const ProgressRing = React.forwardRef((props: ProgressRingProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ProgressRing' ref={ref} />);
+export const ProgressRing = React.forwardRef((props: ProgressRingProps, ref: React.ForwardedRef<ProgressRingRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ProgressRing' ref={ref} />);
 }
 export namespace WinUI {
 export type RadioButtonsProps = Omit<NativeWinUI.NativeRadioButtonsProps, 'type'>;
+export type RadioButtonsRef = React.Component<NativeWinUI.NativeRadioButtonsProps> & Readonly<NativeMethods>;
 
-export const RadioButtons = React.forwardRef((props: RadioButtonsProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RadioButtons' ref={ref} />);
+export const RadioButtons = React.forwardRef((props: RadioButtonsProps, ref: React.ForwardedRef<RadioButtonsRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RadioButtons' ref={ref} />);
 }
 export namespace WinUI {
 export type RadioMenuFlyoutItemProps = Omit<NativeWinUI.NativeRadioMenuFlyoutItemProps, 'type'>;
+export type RadioMenuFlyoutItemRef = React.Component<NativeWinUI.NativeRadioMenuFlyoutItemProps> & Readonly<NativeMethods>;
 
-export const RadioMenuFlyoutItem = React.forwardRef((props: RadioMenuFlyoutItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem' ref={ref} />);
+export const RadioMenuFlyoutItem = React.forwardRef((props: RadioMenuFlyoutItemProps, ref: React.ForwardedRef<RadioMenuFlyoutItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem' ref={ref} />);
 }
 export namespace WinUI {
 export type RatingControlProps = Omit<NativeWinUI.NativeRatingControlProps, 'type'>;
+export type RatingControlRef = React.Component<NativeWinUI.NativeRatingControlProps> & Readonly<NativeMethods>;
 
-export const RatingControl = React.forwardRef((props: RatingControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RatingControl' ref={ref} />);
+export const RatingControl = React.forwardRef((props: RatingControlProps, ref: React.ForwardedRef<RatingControlRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RatingControl' ref={ref} />);
 }
 export namespace WinUI {
 export type RefreshContainerProps = Omit<NativeWinUI.NativeRefreshContainerProps, 'type'>;
+export type RefreshContainerRef = React.Component<NativeWinUI.NativeRefreshContainerProps> & Readonly<NativeMethods>;
 
-export const RefreshContainer = React.forwardRef((props: RefreshContainerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RefreshContainer' ref={ref} />);
+export const RefreshContainer = React.forwardRef((props: RefreshContainerProps, ref: React.ForwardedRef<RefreshContainerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RefreshContainer' ref={ref} />);
 }
 export namespace WinUI {
 export type RefreshVisualizerProps = Omit<NativeWinUI.NativeRefreshVisualizerProps, 'type'>;
+export type RefreshVisualizerRef = React.Component<NativeWinUI.NativeRefreshVisualizerProps> & Readonly<NativeMethods>;
 
-export const RefreshVisualizer = React.forwardRef((props: RefreshVisualizerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RefreshVisualizer' ref={ref} />);
+export const RefreshVisualizer = React.forwardRef((props: RefreshVisualizerProps, ref: React.ForwardedRef<RefreshVisualizerRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RefreshVisualizer' ref={ref} />);
 }
 export namespace WinUI {
 export type RevealListViewItemPresenterProps = Omit<NativeWinUI.NativeRevealListViewItemPresenterProps, 'type'>;
+export type RevealListViewItemPresenterRef = React.Component<NativeWinUI.NativeRevealListViewItemPresenterProps> & Readonly<NativeMethods>;
 
-export const RevealListViewItemPresenter = React.forwardRef((props: RevealListViewItemPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RevealListViewItemPresenter' ref={ref} />);
+export const RevealListViewItemPresenter = React.forwardRef((props: RevealListViewItemPresenterProps, ref: React.ForwardedRef<RevealListViewItemPresenterRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.RevealListViewItemPresenter' ref={ref} />);
 }
 export namespace WinUI {
 export type SplitButtonProps = Omit<NativeWinUI.NativeSplitButtonProps, 'type'>;
+export type SplitButtonRef = React.Component<NativeWinUI.NativeSplitButtonProps> & Readonly<NativeMethods>;
 
-export const SplitButton = React.forwardRef((props: SplitButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.SplitButton' ref={ref} />);
+export const SplitButton = React.forwardRef((props: SplitButtonProps, ref: React.ForwardedRef<SplitButtonRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.SplitButton' ref={ref} />);
 }
 export namespace WinUI {
 export type SwipeControlProps = Omit<NativeWinUI.NativeSwipeControlProps, 'type'>;
+export type SwipeControlRef = React.Component<NativeWinUI.NativeSwipeControlProps> & Readonly<NativeMethods>;
 
-export const SwipeControl = React.forwardRef((props: SwipeControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.SwipeControl' ref={ref} />);
+export const SwipeControl = React.forwardRef((props: SwipeControlProps, ref: React.ForwardedRef<SwipeControlRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.SwipeControl' ref={ref} />);
 }
 export namespace WinUI {
 export type TabViewProps = Omit<NativeWinUI.NativeTabViewProps, 'type'>;
+export type TabViewRef = React.Component<NativeWinUI.NativeTabViewProps> & Readonly<NativeMethods>;
 
-export const TabView = React.forwardRef((props: TabViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TabView' ref={ref} />);
+export const TabView = React.forwardRef((props: TabViewProps, ref: React.ForwardedRef<TabViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TabView' ref={ref} />);
 }
 export namespace WinUI {
 export type TabViewItemProps = Omit<NativeWinUI.NativeTabViewItemProps, 'type'>;
+export type TabViewItemRef = React.Component<NativeWinUI.NativeTabViewItemProps> & Readonly<NativeMethods>;
 
-export const TabViewItem = React.forwardRef((props: TabViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TabViewItem' ref={ref} />);
+export const TabViewItem = React.forwardRef((props: TabViewItemProps, ref: React.ForwardedRef<TabViewItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TabViewItem' ref={ref} />);
 }
 export namespace WinUI {
 export type TeachingTipProps = Omit<NativeWinUI.NativeTeachingTipProps, 'type'>;
+export type TeachingTipRef = React.Component<NativeWinUI.NativeTeachingTipProps> & Readonly<NativeMethods>;
 
-export const TeachingTip = React.forwardRef((props: TeachingTipProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TeachingTip' ref={ref} />);
+export const TeachingTip = React.forwardRef((props: TeachingTipProps, ref: React.ForwardedRef<TeachingTipRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TeachingTip' ref={ref} />);
 }
 export namespace WinUI {
 export type TextCommandBarFlyoutProps = Omit<NativeWinUI.NativeTextCommandBarFlyoutProps, 'type'>;
+export type TextCommandBarFlyoutRef = React.Component<NativeWinUI.NativeTextCommandBarFlyoutProps> & Readonly<NativeMethods>;
 
-export const TextCommandBarFlyout = React.forwardRef((props: TextCommandBarFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TextCommandBarFlyout' ref={ref} />);
+export const TextCommandBarFlyout = React.forwardRef((props: TextCommandBarFlyoutProps, ref: React.ForwardedRef<TextCommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TextCommandBarFlyout' ref={ref} />);
 }
 export namespace WinUI {
 export type ToggleSplitButtonProps = Omit<NativeWinUI.NativeToggleSplitButtonProps, 'type'>;
+export type ToggleSplitButtonRef = React.Component<NativeWinUI.NativeToggleSplitButtonProps> & Readonly<NativeMethods>;
 
-export const ToggleSplitButton = React.forwardRef((props: ToggleSplitButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ToggleSplitButton' ref={ref} />);
+export const ToggleSplitButton = React.forwardRef((props: ToggleSplitButtonProps, ref: React.ForwardedRef<ToggleSplitButtonRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.ToggleSplitButton' ref={ref} />);
 }
 export namespace WinUI {
 export type TreeViewProps = Omit<NativeWinUI.NativeTreeViewProps, 'type'>;
+export type TreeViewRef = React.Component<NativeWinUI.NativeTreeViewProps> & Readonly<NativeMethods>;
 
-export const TreeView = React.forwardRef((props: TreeViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeView' ref={ref} />);
+export const TreeView = React.forwardRef((props: TreeViewProps, ref: React.ForwardedRef<TreeViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeView' ref={ref} />);
 }
 export namespace WinUI {
 export type TreeViewItemProps = Omit<NativeWinUI.NativeTreeViewItemProps, 'type'>;
+export type TreeViewItemRef = React.Component<NativeWinUI.NativeTreeViewItemProps> & Readonly<NativeMethods>;
 
-export const TreeViewItem = React.forwardRef((props: TreeViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeViewItem' ref={ref} />);
+export const TreeViewItem = React.forwardRef((props: TreeViewItemProps, ref: React.ForwardedRef<TreeViewItemRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeViewItem' ref={ref} />);
 }
 export namespace WinUI {
 export type TreeViewListProps = Omit<NativeWinUI.NativeTreeViewListProps, 'type'>;
+export type TreeViewListRef = React.Component<NativeWinUI.NativeTreeViewListProps> & Readonly<NativeMethods>;
 
-export const TreeViewList = React.forwardRef((props: TreeViewListProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeViewList' ref={ref} />);
+export const TreeViewList = React.forwardRef((props: TreeViewListProps, ref: React.ForwardedRef<TreeViewListRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TreeViewList' ref={ref} />);
 }
 export namespace WinUI {
 export type TwoPaneViewProps = Omit<NativeWinUI.NativeTwoPaneViewProps, 'type'>;
+export type TwoPaneViewRef = React.Component<NativeWinUI.NativeTwoPaneViewProps> & Readonly<NativeMethods>;
 
-export const TwoPaneView = React.forwardRef((props: TwoPaneViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TwoPaneView' ref={ref} />);
+export const TwoPaneView = React.forwardRef((props: TwoPaneViewProps, ref: React.ForwardedRef<TwoPaneViewRef>) => <NativeXamlControl {...props} type='Microsoft.UI.Xaml.Controls.TwoPaneView' ref={ref} />);
 }
 export type ContentControlProps = Omit<NativeContentControlProps, 'type'>;
+export type ContentControlRef = React.Component<NativeContentControlProps> & Readonly<NativeMethods>;
 
-export const ContentControl = React.forwardRef((props: ContentControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentControl' ref={ref} />);
+export const ContentControl = React.forwardRef((props: ContentControlProps, ref: React.ForwardedRef<ContentControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentControl' ref={ref} />);
 export type AppBarProps = Omit<NativeAppBarProps, 'type'>;
+export type AppBarRef = React.Component<NativeAppBarProps> & Readonly<NativeMethods>;
 
-export const AppBar = React.forwardRef((props: AppBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBar' ref={ref} />);
+export const AppBar = React.forwardRef((props: AppBarProps, ref: React.ForwardedRef<AppBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBar' ref={ref} />);
 export type ButtonProps = Omit<NativeButtonProps, 'type'>;
+export type ButtonRef = React.Component<NativeButtonProps> & Readonly<NativeMethods>;
 
-export const Button = React.forwardRef((props: ButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Button' ref={ref} />);
+export const Button = React.forwardRef((props: ButtonProps, ref: React.ForwardedRef<ButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Button' ref={ref} />);
 export type AppBarButtonProps = Omit<NativeAppBarButtonProps, 'type'>;
+export type AppBarButtonRef = React.Component<NativeAppBarButtonProps> & Readonly<NativeMethods>;
 
-export const AppBarButton = React.forwardRef((props: AppBarButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarButton' ref={ref} />);
+export const AppBarButton = React.forwardRef((props: AppBarButtonProps, ref: React.ForwardedRef<AppBarButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarButton' ref={ref} />);
 export type AppBarElementContainerProps = Omit<NativeAppBarElementContainerProps, 'type'>;
+export type AppBarElementContainerRef = React.Component<NativeAppBarElementContainerProps> & Readonly<NativeMethods>;
 
-export const AppBarElementContainer = React.forwardRef((props: AppBarElementContainerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarElementContainer' ref={ref} />);
+export const AppBarElementContainer = React.forwardRef((props: AppBarElementContainerProps, ref: React.ForwardedRef<AppBarElementContainerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarElementContainer' ref={ref} />);
 export type AppBarSeparatorProps = Omit<NativeAppBarSeparatorProps, 'type'>;
+export type AppBarSeparatorRef = React.Component<NativeAppBarSeparatorProps> & Readonly<NativeMethods>;
 
-export const AppBarSeparator = React.forwardRef((props: AppBarSeparatorProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarSeparator' ref={ref} />);
+export const AppBarSeparator = React.forwardRef((props: AppBarSeparatorProps, ref: React.ForwardedRef<AppBarSeparatorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarSeparator' ref={ref} />);
 export type ToggleButtonProps = Omit<NativeToggleButtonProps, 'type'>;
+export type ToggleButtonRef = React.Component<NativeToggleButtonProps> & Readonly<NativeMethods>;
 
-export const ToggleButton = React.forwardRef((props: ToggleButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ToggleButton' ref={ref} />);
+export const ToggleButton = React.forwardRef((props: ToggleButtonProps, ref: React.ForwardedRef<ToggleButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ToggleButton' ref={ref} />);
 export type AppBarToggleButtonProps = Omit<NativeAppBarToggleButtonProps, 'type'>;
+export type AppBarToggleButtonRef = React.Component<NativeAppBarToggleButtonProps> & Readonly<NativeMethods>;
 
-export const AppBarToggleButton = React.forwardRef((props: AppBarToggleButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarToggleButton' ref={ref} />);
+export const AppBarToggleButton = React.forwardRef((props: AppBarToggleButtonProps, ref: React.ForwardedRef<AppBarToggleButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AppBarToggleButton' ref={ref} />);
 export type ItemsControlProps = Omit<NativeItemsControlProps, 'type'>;
+export type ItemsControlRef = React.Component<NativeItemsControlProps> & Readonly<NativeMethods>;
 
-export const ItemsControl = React.forwardRef((props: ItemsControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsControl' ref={ref} />);
+export const ItemsControl = React.forwardRef((props: ItemsControlProps, ref: React.ForwardedRef<ItemsControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsControl' ref={ref} />);
 export type AutoSuggestBoxProps = Omit<NativeAutoSuggestBoxProps, 'type'>;
+export type AutoSuggestBoxRef = React.Component<NativeAutoSuggestBoxProps> & Readonly<NativeMethods>;
 
-export const AutoSuggestBox = React.forwardRef((props: AutoSuggestBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AutoSuggestBox' ref={ref} />);
+export const AutoSuggestBox = React.forwardRef((props: AutoSuggestBoxProps, ref: React.ForwardedRef<AutoSuggestBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.AutoSuggestBox' ref={ref} />);
 export type BitmapIconProps = Omit<NativeBitmapIconProps, 'type'>;
+export type BitmapIconRef = React.Component<NativeBitmapIconProps> & Readonly<NativeMethods>;
 
-export const BitmapIcon = React.forwardRef((props: BitmapIconProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.BitmapIcon' ref={ref} />);
+export const BitmapIcon = React.forwardRef((props: BitmapIconProps, ref: React.ForwardedRef<BitmapIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.BitmapIcon' ref={ref} />);
 export type BorderProps = Omit<NativeBorderProps, 'type'>;
+export type BorderRef = React.Component<NativeBorderProps> & Readonly<NativeMethods>;
 
-export const Border = React.forwardRef((props: BorderProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Border' ref={ref} />);
+export const Border = React.forwardRef((props: BorderProps, ref: React.ForwardedRef<BorderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Border' ref={ref} />);
 export type CalendarDatePickerProps = Omit<NativeCalendarDatePickerProps, 'type'>;
+export type CalendarDatePickerRef = React.Component<NativeCalendarDatePickerProps> & Readonly<NativeMethods>;
 
-export const CalendarDatePicker = React.forwardRef((props: CalendarDatePickerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarDatePicker' ref={ref} />);
+export const CalendarDatePicker = React.forwardRef((props: CalendarDatePickerProps, ref: React.ForwardedRef<CalendarDatePickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarDatePicker' ref={ref} />);
 export type CalendarViewProps = Omit<NativeCalendarViewProps, 'type'>;
+export type CalendarViewRef = React.Component<NativeCalendarViewProps> & Readonly<NativeMethods>;
 
-export const CalendarView = React.forwardRef((props: CalendarViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarView' ref={ref} />);
+export const CalendarView = React.forwardRef((props: CalendarViewProps, ref: React.ForwardedRef<CalendarViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarView' ref={ref} />);
 export type CalendarViewDayItemProps = Omit<NativeCalendarViewDayItemProps, 'type'>;
+export type CalendarViewDayItemRef = React.Component<NativeCalendarViewDayItemProps> & Readonly<NativeMethods>;
 
-export const CalendarViewDayItem = React.forwardRef((props: CalendarViewDayItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarViewDayItem' ref={ref} />);
+export const CalendarViewDayItem = React.forwardRef((props: CalendarViewDayItemProps, ref: React.ForwardedRef<CalendarViewDayItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CalendarViewDayItem' ref={ref} />);
 export type CanvasProps = Omit<NativeCanvasProps, 'type'>;
+export type CanvasRef = React.Component<NativeCanvasProps> & Readonly<NativeMethods>;
 
-export const Canvas = React.forwardRef((props: CanvasProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Canvas' ref={ref} />);
+export const Canvas = React.forwardRef((props: CanvasProps, ref: React.ForwardedRef<CanvasRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Canvas' ref={ref} />);
 export type CaptureElementProps = Omit<NativeCaptureElementProps, 'type'>;
+export type CaptureElementRef = React.Component<NativeCaptureElementProps> & Readonly<NativeMethods>;
 
-export const CaptureElement = React.forwardRef((props: CaptureElementProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CaptureElement' ref={ref} />);
+export const CaptureElement = React.forwardRef((props: CaptureElementProps, ref: React.ForwardedRef<CaptureElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CaptureElement' ref={ref} />);
 export type CheckBoxProps = Omit<NativeCheckBoxProps, 'type'>;
+export type CheckBoxRef = React.Component<NativeCheckBoxProps> & Readonly<NativeMethods>;
 
-export const CheckBox = React.forwardRef((props: CheckBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CheckBox' ref={ref} />);
+export const CheckBox = React.forwardRef((props: CheckBoxProps, ref: React.ForwardedRef<CheckBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CheckBox' ref={ref} />);
 export type ColorPickerProps = Omit<NativeColorPickerProps, 'type'>;
+export type ColorPickerRef = React.Component<NativeColorPickerProps> & Readonly<NativeMethods>;
 
-export const ColorPicker = React.forwardRef((props: ColorPickerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ColorPicker' ref={ref} />);
+export const ColorPicker = React.forwardRef((props: ColorPickerProps, ref: React.ForwardedRef<ColorPickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ColorPicker' ref={ref} />);
 export type ComboBoxProps = Omit<NativeComboBoxProps, 'type'>;
+export type ComboBoxRef = React.Component<NativeComboBoxProps> & Readonly<NativeMethods>;
 
-export const ComboBox = React.forwardRef((props: ComboBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ComboBox' ref={ref} />);
+export const ComboBox = React.forwardRef((props: ComboBoxProps, ref: React.ForwardedRef<ComboBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ComboBox' ref={ref} />);
 export type ComboBoxItemProps = Omit<NativeComboBoxItemProps, 'type'>;
+export type ComboBoxItemRef = React.Component<NativeComboBoxItemProps> & Readonly<NativeMethods>;
 
-export const ComboBoxItem = React.forwardRef((props: ComboBoxItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ComboBoxItem' ref={ref} />);
+export const ComboBoxItem = React.forwardRef((props: ComboBoxItemProps, ref: React.ForwardedRef<ComboBoxItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ComboBoxItem' ref={ref} />);
 export type CommandBarProps = Omit<NativeCommandBarProps, 'type'>;
+export type CommandBarRef = React.Component<NativeCommandBarProps> & Readonly<NativeMethods>;
 
-export const CommandBar = React.forwardRef((props: CommandBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBar' ref={ref} />);
+export const CommandBar = React.forwardRef((props: CommandBarProps, ref: React.ForwardedRef<CommandBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBar' ref={ref} />);
 export type CommandBarFlyoutProps = Omit<NativeCommandBarFlyoutProps, 'type'>;
+export type CommandBarFlyoutRef = React.Component<NativeCommandBarFlyoutProps> & Readonly<NativeMethods>;
 
-export const CommandBarFlyout = React.forwardRef((props: CommandBarFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBarFlyout' ref={ref} />);
+export const CommandBarFlyout = React.forwardRef((props: CommandBarFlyoutProps, ref: React.ForwardedRef<CommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBarFlyout' ref={ref} />);
 export type CommandBarOverflowPresenterProps = Omit<NativeCommandBarOverflowPresenterProps, 'type'>;
+export type CommandBarOverflowPresenterRef = React.Component<NativeCommandBarOverflowPresenterProps> & Readonly<NativeMethods>;
 
-export const CommandBarOverflowPresenter = React.forwardRef((props: CommandBarOverflowPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBarOverflowPresenter' ref={ref} />);
+export const CommandBarOverflowPresenter = React.forwardRef((props: CommandBarOverflowPresenterProps, ref: React.ForwardedRef<CommandBarOverflowPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.CommandBarOverflowPresenter' ref={ref} />);
 export type ContentDialogProps = Omit<NativeContentDialogProps, 'type'>;
+export type ContentDialogRef = React.Component<NativeContentDialogProps> & Readonly<NativeMethods>;
 
-export const ContentDialog = React.forwardRef((props: ContentDialogProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentDialog' ref={ref} />);
+export const ContentDialog = React.forwardRef((props: ContentDialogProps, ref: React.ForwardedRef<ContentDialogRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentDialog' ref={ref} />);
 export type ContentPresenterProps = Omit<NativeContentPresenterProps, 'type'>;
+export type ContentPresenterRef = React.Component<NativeContentPresenterProps> & Readonly<NativeMethods>;
 
-export const ContentPresenter = React.forwardRef((props: ContentPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentPresenter' ref={ref} />);
+export const ContentPresenter = React.forwardRef((props: ContentPresenterProps, ref: React.ForwardedRef<ContentPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ContentPresenter' ref={ref} />);
 export type DatePickerProps = Omit<NativeDatePickerProps, 'type'>;
+export type DatePickerRef = React.Component<NativeDatePickerProps> & Readonly<NativeMethods>;
 
-export const DatePicker = React.forwardRef((props: DatePickerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DatePicker' ref={ref} />);
+export const DatePicker = React.forwardRef((props: DatePickerProps, ref: React.ForwardedRef<DatePickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DatePicker' ref={ref} />);
 export type DatePickerFlyoutProps = Omit<NativeDatePickerFlyoutProps, 'type'>;
+export type DatePickerFlyoutRef = React.Component<NativeDatePickerFlyoutProps> & Readonly<NativeMethods>;
 
-export const DatePickerFlyout = React.forwardRef((props: DatePickerFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DatePickerFlyout' ref={ref} />);
+export const DatePickerFlyout = React.forwardRef((props: DatePickerFlyoutProps, ref: React.ForwardedRef<DatePickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DatePickerFlyout' ref={ref} />);
 export type DropDownButtonProps = Omit<NativeDropDownButtonProps, 'type'>;
+export type DropDownButtonRef = React.Component<NativeDropDownButtonProps> & Readonly<NativeMethods>;
 
-export const DropDownButton = React.forwardRef((props: DropDownButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DropDownButton' ref={ref} />);
+export const DropDownButton = React.forwardRef((props: DropDownButtonProps, ref: React.ForwardedRef<DropDownButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.DropDownButton' ref={ref} />);
 export type FlipViewProps = Omit<NativeFlipViewProps, 'type'>;
+export type FlipViewRef = React.Component<NativeFlipViewProps> & Readonly<NativeMethods>;
 
-export const FlipView = React.forwardRef((props: FlipViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlipView' ref={ref} />);
+export const FlipView = React.forwardRef((props: FlipViewProps, ref: React.ForwardedRef<FlipViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlipView' ref={ref} />);
 export type FlipViewItemProps = Omit<NativeFlipViewItemProps, 'type'>;
+export type FlipViewItemRef = React.Component<NativeFlipViewItemProps> & Readonly<NativeMethods>;
 
-export const FlipViewItem = React.forwardRef((props: FlipViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlipViewItem' ref={ref} />);
+export const FlipViewItem = React.forwardRef((props: FlipViewItemProps, ref: React.ForwardedRef<FlipViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlipViewItem' ref={ref} />);
 export type FlyoutProps = Omit<NativeFlyoutProps, 'type'>;
+export type FlyoutRef = React.Component<NativeFlyoutProps> & Readonly<NativeMethods>;
 
-export const Flyout = React.forwardRef((props: FlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Flyout' ref={ref} />);
+export const Flyout = React.forwardRef((props: FlyoutProps, ref: React.ForwardedRef<FlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Flyout' ref={ref} />);
 export type FlyoutPresenterProps = Omit<NativeFlyoutPresenterProps, 'type'>;
+export type FlyoutPresenterRef = React.Component<NativeFlyoutPresenterProps> & Readonly<NativeMethods>;
 
-export const FlyoutPresenter = React.forwardRef((props: FlyoutPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlyoutPresenter' ref={ref} />);
+export const FlyoutPresenter = React.forwardRef((props: FlyoutPresenterProps, ref: React.ForwardedRef<FlyoutPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FlyoutPresenter' ref={ref} />);
 export type FontIconProps = Omit<NativeFontIconProps, 'type'>;
+export type FontIconRef = React.Component<NativeFontIconProps> & Readonly<NativeMethods>;
 
-export const FontIcon = React.forwardRef((props: FontIconProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FontIcon' ref={ref} />);
+export const FontIcon = React.forwardRef((props: FontIconProps, ref: React.ForwardedRef<FontIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.FontIcon' ref={ref} />);
 export type FrameProps = Omit<NativeFrameProps, 'type'>;
+export type FrameRef = React.Component<NativeFrameProps> & Readonly<NativeMethods>;
 
-export const Frame = React.forwardRef((props: FrameProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Frame' ref={ref} />);
+export const Frame = React.forwardRef((props: FrameProps, ref: React.ForwardedRef<FrameRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Frame' ref={ref} />);
 export type GridProps = Omit<NativeGridProps, 'type'>;
+export type GridRef = React.Component<NativeGridProps> & Readonly<NativeMethods>;
 
-export const Grid = React.forwardRef((props: GridProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Grid' ref={ref} />);
+export const Grid = React.forwardRef((props: GridProps, ref: React.ForwardedRef<GridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Grid' ref={ref} />);
 export type GridViewProps = Omit<NativeGridViewProps, 'type'>;
+export type GridViewRef = React.Component<NativeGridViewProps> & Readonly<NativeMethods>;
 
-export const GridView = React.forwardRef((props: GridViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridView' ref={ref} />);
+export const GridView = React.forwardRef((props: GridViewProps, ref: React.ForwardedRef<GridViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridView' ref={ref} />);
 export type GridViewHeaderItemProps = Omit<NativeGridViewHeaderItemProps, 'type'>;
+export type GridViewHeaderItemRef = React.Component<NativeGridViewHeaderItemProps> & Readonly<NativeMethods>;
 
-export const GridViewHeaderItem = React.forwardRef((props: GridViewHeaderItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridViewHeaderItem' ref={ref} />);
+export const GridViewHeaderItem = React.forwardRef((props: GridViewHeaderItemProps, ref: React.ForwardedRef<GridViewHeaderItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridViewHeaderItem' ref={ref} />);
 export type GridViewItemProps = Omit<NativeGridViewItemProps, 'type'>;
+export type GridViewItemRef = React.Component<NativeGridViewItemProps> & Readonly<NativeMethods>;
 
-export const GridViewItem = React.forwardRef((props: GridViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridViewItem' ref={ref} />);
+export const GridViewItem = React.forwardRef((props: GridViewItemProps, ref: React.ForwardedRef<GridViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GridViewItem' ref={ref} />);
 export type GroupItemProps = Omit<NativeGroupItemProps, 'type'>;
+export type GroupItemRef = React.Component<NativeGroupItemProps> & Readonly<NativeMethods>;
 
-export const GroupItem = React.forwardRef((props: GroupItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GroupItem' ref={ref} />);
+export const GroupItem = React.forwardRef((props: GroupItemProps, ref: React.ForwardedRef<GroupItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.GroupItem' ref={ref} />);
 export type HandwritingViewProps = Omit<NativeHandwritingViewProps, 'type'>;
+export type HandwritingViewRef = React.Component<NativeHandwritingViewProps> & Readonly<NativeMethods>;
 
-export const HandwritingView = React.forwardRef((props: HandwritingViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HandwritingView' ref={ref} />);
+export const HandwritingView = React.forwardRef((props: HandwritingViewProps, ref: React.ForwardedRef<HandwritingViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HandwritingView' ref={ref} />);
 export type HubProps = Omit<NativeHubProps, 'type'>;
+export type HubRef = React.Component<NativeHubProps> & Readonly<NativeMethods>;
 
-export const Hub = React.forwardRef((props: HubProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Hub' ref={ref} />);
+export const Hub = React.forwardRef((props: HubProps, ref: React.ForwardedRef<HubRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Hub' ref={ref} />);
 export type HubSectionProps = Omit<NativeHubSectionProps, 'type'>;
+export type HubSectionRef = React.Component<NativeHubSectionProps> & Readonly<NativeMethods>;
 
-export const HubSection = React.forwardRef((props: HubSectionProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HubSection' ref={ref} />);
+export const HubSection = React.forwardRef((props: HubSectionProps, ref: React.ForwardedRef<HubSectionRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HubSection' ref={ref} />);
 export type HyperlinkButtonProps = Omit<NativeHyperlinkButtonProps, 'type'>;
+export type HyperlinkButtonRef = React.Component<NativeHyperlinkButtonProps> & Readonly<NativeMethods>;
 
-export const HyperlinkButton = React.forwardRef((props: HyperlinkButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HyperlinkButton' ref={ref} />);
+export const HyperlinkButton = React.forwardRef((props: HyperlinkButtonProps, ref: React.ForwardedRef<HyperlinkButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.HyperlinkButton' ref={ref} />);
 export type IconSourceElementProps = Omit<NativeIconSourceElementProps, 'type'>;
+export type IconSourceElementRef = React.Component<NativeIconSourceElementProps> & Readonly<NativeMethods>;
 
-export const IconSourceElement = React.forwardRef((props: IconSourceElementProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.IconSourceElement' ref={ref} />);
+export const IconSourceElement = React.forwardRef((props: IconSourceElementProps, ref: React.ForwardedRef<IconSourceElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.IconSourceElement' ref={ref} />);
 export type ImageProps = Omit<NativeImageProps, 'type'>;
+export type ImageRef = React.Component<NativeImageProps> & Readonly<NativeMethods>;
 
-export const Image = React.forwardRef((props: ImageProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Image' ref={ref} />);
+export const Image = React.forwardRef((props: ImageProps, ref: React.ForwardedRef<ImageRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Image' ref={ref} />);
 export type InkCanvasProps = Omit<NativeInkCanvasProps, 'type'>;
+export type InkCanvasRef = React.Component<NativeInkCanvasProps> & Readonly<NativeMethods>;
 
-export const InkCanvas = React.forwardRef((props: InkCanvasProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkCanvas' ref={ref} />);
+export const InkCanvas = React.forwardRef((props: InkCanvasProps, ref: React.ForwardedRef<InkCanvasRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkCanvas' ref={ref} />);
 export type InkToolbarProps = Omit<NativeInkToolbarProps, 'type'>;
+export type InkToolbarRef = React.Component<NativeInkToolbarProps> & Readonly<NativeMethods>;
 
-export const InkToolbar = React.forwardRef((props: InkToolbarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbar' ref={ref} />);
+export const InkToolbar = React.forwardRef((props: InkToolbarProps, ref: React.ForwardedRef<InkToolbarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbar' ref={ref} />);
 export type RadioButtonProps = Omit<NativeRadioButtonProps, 'type'>;
+export type RadioButtonRef = React.Component<NativeRadioButtonProps> & Readonly<NativeMethods>;
 
-export const RadioButton = React.forwardRef((props: RadioButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RadioButton' ref={ref} />);
+export const RadioButton = React.forwardRef((props: RadioButtonProps, ref: React.ForwardedRef<RadioButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RadioButton' ref={ref} />);
 export type InkToolbarBallpointPenButtonProps = Omit<NativeInkToolbarBallpointPenButtonProps, 'type'>;
+export type InkToolbarBallpointPenButtonRef = React.Component<NativeInkToolbarBallpointPenButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarBallpointPenButton = React.forwardRef((props: InkToolbarBallpointPenButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarBallpointPenButton' ref={ref} />);
+export const InkToolbarBallpointPenButton = React.forwardRef((props: InkToolbarBallpointPenButtonProps, ref: React.ForwardedRef<InkToolbarBallpointPenButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarBallpointPenButton' ref={ref} />);
 export type InkToolbarCustomPenButtonProps = Omit<NativeInkToolbarCustomPenButtonProps, 'type'>;
+export type InkToolbarCustomPenButtonRef = React.Component<NativeInkToolbarCustomPenButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarCustomPenButton = React.forwardRef((props: InkToolbarCustomPenButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomPenButton' ref={ref} />);
+export const InkToolbarCustomPenButton = React.forwardRef((props: InkToolbarCustomPenButtonProps, ref: React.ForwardedRef<InkToolbarCustomPenButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomPenButton' ref={ref} />);
 export type InkToolbarCustomToggleButtonProps = Omit<NativeInkToolbarCustomToggleButtonProps, 'type'>;
+export type InkToolbarCustomToggleButtonRef = React.Component<NativeInkToolbarCustomToggleButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarCustomToggleButton = React.forwardRef((props: InkToolbarCustomToggleButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomToggleButton' ref={ref} />);
+export const InkToolbarCustomToggleButton = React.forwardRef((props: InkToolbarCustomToggleButtonProps, ref: React.ForwardedRef<InkToolbarCustomToggleButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomToggleButton' ref={ref} />);
 export type InkToolbarCustomToolButtonProps = Omit<NativeInkToolbarCustomToolButtonProps, 'type'>;
+export type InkToolbarCustomToolButtonRef = React.Component<NativeInkToolbarCustomToolButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarCustomToolButton = React.forwardRef((props: InkToolbarCustomToolButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomToolButton' ref={ref} />);
+export const InkToolbarCustomToolButton = React.forwardRef((props: InkToolbarCustomToolButtonProps, ref: React.ForwardedRef<InkToolbarCustomToolButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarCustomToolButton' ref={ref} />);
 export type InkToolbarEraserButtonProps = Omit<NativeInkToolbarEraserButtonProps, 'type'>;
+export type InkToolbarEraserButtonRef = React.Component<NativeInkToolbarEraserButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarEraserButton = React.forwardRef((props: InkToolbarEraserButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarEraserButton' ref={ref} />);
+export const InkToolbarEraserButton = React.forwardRef((props: InkToolbarEraserButtonProps, ref: React.ForwardedRef<InkToolbarEraserButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarEraserButton' ref={ref} />);
 export type InkToolbarFlyoutItemProps = Omit<NativeInkToolbarFlyoutItemProps, 'type'>;
+export type InkToolbarFlyoutItemRef = React.Component<NativeInkToolbarFlyoutItemProps> & Readonly<NativeMethods>;
 
-export const InkToolbarFlyoutItem = React.forwardRef((props: InkToolbarFlyoutItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarFlyoutItem' ref={ref} />);
+export const InkToolbarFlyoutItem = React.forwardRef((props: InkToolbarFlyoutItemProps, ref: React.ForwardedRef<InkToolbarFlyoutItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarFlyoutItem' ref={ref} />);
 export type InkToolbarHighlighterButtonProps = Omit<NativeInkToolbarHighlighterButtonProps, 'type'>;
+export type InkToolbarHighlighterButtonRef = React.Component<NativeInkToolbarHighlighterButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarHighlighterButton = React.forwardRef((props: InkToolbarHighlighterButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarHighlighterButton' ref={ref} />);
+export const InkToolbarHighlighterButton = React.forwardRef((props: InkToolbarHighlighterButtonProps, ref: React.ForwardedRef<InkToolbarHighlighterButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarHighlighterButton' ref={ref} />);
 export type InkToolbarPenConfigurationControlProps = Omit<NativeInkToolbarPenConfigurationControlProps, 'type'>;
+export type InkToolbarPenConfigurationControlRef = React.Component<NativeInkToolbarPenConfigurationControlProps> & Readonly<NativeMethods>;
 
-export const InkToolbarPenConfigurationControl = React.forwardRef((props: InkToolbarPenConfigurationControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarPenConfigurationControl' ref={ref} />);
+export const InkToolbarPenConfigurationControl = React.forwardRef((props: InkToolbarPenConfigurationControlProps, ref: React.ForwardedRef<InkToolbarPenConfigurationControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarPenConfigurationControl' ref={ref} />);
 export type InkToolbarPencilButtonProps = Omit<NativeInkToolbarPencilButtonProps, 'type'>;
+export type InkToolbarPencilButtonRef = React.Component<NativeInkToolbarPencilButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarPencilButton = React.forwardRef((props: InkToolbarPencilButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarPencilButton' ref={ref} />);
+export const InkToolbarPencilButton = React.forwardRef((props: InkToolbarPencilButtonProps, ref: React.ForwardedRef<InkToolbarPencilButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarPencilButton' ref={ref} />);
 export type InkToolbarRulerButtonProps = Omit<NativeInkToolbarRulerButtonProps, 'type'>;
+export type InkToolbarRulerButtonRef = React.Component<NativeInkToolbarRulerButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarRulerButton = React.forwardRef((props: InkToolbarRulerButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarRulerButton' ref={ref} />);
+export const InkToolbarRulerButton = React.forwardRef((props: InkToolbarRulerButtonProps, ref: React.ForwardedRef<InkToolbarRulerButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarRulerButton' ref={ref} />);
 export type InkToolbarStencilButtonProps = Omit<NativeInkToolbarStencilButtonProps, 'type'>;
+export type InkToolbarStencilButtonRef = React.Component<NativeInkToolbarStencilButtonProps> & Readonly<NativeMethods>;
 
-export const InkToolbarStencilButton = React.forwardRef((props: InkToolbarStencilButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarStencilButton' ref={ref} />);
+export const InkToolbarStencilButton = React.forwardRef((props: InkToolbarStencilButtonProps, ref: React.ForwardedRef<InkToolbarStencilButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.InkToolbarStencilButton' ref={ref} />);
 export type ItemsPresenterProps = Omit<NativeItemsPresenterProps, 'type'>;
+export type ItemsPresenterRef = React.Component<NativeItemsPresenterProps> & Readonly<NativeMethods>;
 
-export const ItemsPresenter = React.forwardRef((props: ItemsPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsPresenter' ref={ref} />);
+export const ItemsPresenter = React.forwardRef((props: ItemsPresenterProps, ref: React.ForwardedRef<ItemsPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsPresenter' ref={ref} />);
 export type ItemsStackPanelProps = Omit<NativeItemsStackPanelProps, 'type'>;
+export type ItemsStackPanelRef = React.Component<NativeItemsStackPanelProps> & Readonly<NativeMethods>;
 
-export const ItemsStackPanel = React.forwardRef((props: ItemsStackPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsStackPanel' ref={ref} />);
+export const ItemsStackPanel = React.forwardRef((props: ItemsStackPanelProps, ref: React.ForwardedRef<ItemsStackPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsStackPanel' ref={ref} />);
 export type ItemsWrapGridProps = Omit<NativeItemsWrapGridProps, 'type'>;
+export type ItemsWrapGridRef = React.Component<NativeItemsWrapGridProps> & Readonly<NativeMethods>;
 
-export const ItemsWrapGrid = React.forwardRef((props: ItemsWrapGridProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsWrapGrid' ref={ref} />);
+export const ItemsWrapGrid = React.forwardRef((props: ItemsWrapGridProps, ref: React.ForwardedRef<ItemsWrapGridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ItemsWrapGrid' ref={ref} />);
 export type ListBoxProps = Omit<NativeListBoxProps, 'type'>;
+export type ListBoxRef = React.Component<NativeListBoxProps> & Readonly<NativeMethods>;
 
-export const ListBox = React.forwardRef((props: ListBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListBox' ref={ref} />);
+export const ListBox = React.forwardRef((props: ListBoxProps, ref: React.ForwardedRef<ListBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListBox' ref={ref} />);
 export type ListBoxItemProps = Omit<NativeListBoxItemProps, 'type'>;
+export type ListBoxItemRef = React.Component<NativeListBoxItemProps> & Readonly<NativeMethods>;
 
-export const ListBoxItem = React.forwardRef((props: ListBoxItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListBoxItem' ref={ref} />);
+export const ListBoxItem = React.forwardRef((props: ListBoxItemProps, ref: React.ForwardedRef<ListBoxItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListBoxItem' ref={ref} />);
 export type ListPickerFlyoutProps = Omit<NativeListPickerFlyoutProps, 'type'>;
+export type ListPickerFlyoutRef = React.Component<NativeListPickerFlyoutProps> & Readonly<NativeMethods>;
 
-export const ListPickerFlyout = React.forwardRef((props: ListPickerFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListPickerFlyout' ref={ref} />);
+export const ListPickerFlyout = React.forwardRef((props: ListPickerFlyoutProps, ref: React.ForwardedRef<ListPickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListPickerFlyout' ref={ref} />);
 export type ListViewProps = Omit<NativeListViewProps, 'type'>;
+export type ListViewRef = React.Component<NativeListViewProps> & Readonly<NativeMethods>;
 
-export const ListView = React.forwardRef((props: ListViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListView' ref={ref} />);
+export const ListView = React.forwardRef((props: ListViewProps, ref: React.ForwardedRef<ListViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListView' ref={ref} />);
 export type ListViewHeaderItemProps = Omit<NativeListViewHeaderItemProps, 'type'>;
+export type ListViewHeaderItemRef = React.Component<NativeListViewHeaderItemProps> & Readonly<NativeMethods>;
 
-export const ListViewHeaderItem = React.forwardRef((props: ListViewHeaderItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListViewHeaderItem' ref={ref} />);
+export const ListViewHeaderItem = React.forwardRef((props: ListViewHeaderItemProps, ref: React.ForwardedRef<ListViewHeaderItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListViewHeaderItem' ref={ref} />);
 export type ListViewItemProps = Omit<NativeListViewItemProps, 'type'>;
+export type ListViewItemRef = React.Component<NativeListViewItemProps> & Readonly<NativeMethods>;
 
-export const ListViewItem = React.forwardRef((props: ListViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListViewItem' ref={ref} />);
+export const ListViewItem = React.forwardRef((props: ListViewItemProps, ref: React.ForwardedRef<ListViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ListViewItem' ref={ref} />);
 export type MapControlProps = Omit<NativeMapControlProps, 'type'>;
+export type MapControlRef = React.Component<NativeMapControlProps> & Readonly<NativeMethods>;
 
-export const MapControl = React.forwardRef((props: MapControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Maps.MapControl' ref={ref} />);
+export const MapControl = React.forwardRef((props: MapControlProps, ref: React.ForwardedRef<MapControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Maps.MapControl' ref={ref} />);
 export type MediaElementProps = Omit<NativeMediaElementProps, 'type'>;
+export type MediaElementRef = React.Component<NativeMediaElementProps> & Readonly<NativeMethods>;
 
-export const MediaElement = React.forwardRef((props: MediaElementProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaElement' ref={ref} />);
+export const MediaElement = React.forwardRef((props: MediaElementProps, ref: React.ForwardedRef<MediaElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaElement' ref={ref} />);
 export type MediaPlayerElementProps = Omit<NativeMediaPlayerElementProps, 'type'>;
+export type MediaPlayerElementRef = React.Component<NativeMediaPlayerElementProps> & Readonly<NativeMethods>;
 
-export const MediaPlayerElement = React.forwardRef((props: MediaPlayerElementProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaPlayerElement' ref={ref} />);
+export const MediaPlayerElement = React.forwardRef((props: MediaPlayerElementProps, ref: React.ForwardedRef<MediaPlayerElementRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaPlayerElement' ref={ref} />);
 export type MediaPlayerPresenterProps = Omit<NativeMediaPlayerPresenterProps, 'type'>;
+export type MediaPlayerPresenterRef = React.Component<NativeMediaPlayerPresenterProps> & Readonly<NativeMethods>;
 
-export const MediaPlayerPresenter = React.forwardRef((props: MediaPlayerPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaPlayerPresenter' ref={ref} />);
+export const MediaPlayerPresenter = React.forwardRef((props: MediaPlayerPresenterProps, ref: React.ForwardedRef<MediaPlayerPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaPlayerPresenter' ref={ref} />);
 export type MediaTransportControlsProps = Omit<NativeMediaTransportControlsProps, 'type'>;
+export type MediaTransportControlsRef = React.Component<NativeMediaTransportControlsProps> & Readonly<NativeMethods>;
 
-export const MediaTransportControls = React.forwardRef((props: MediaTransportControlsProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaTransportControls' ref={ref} />);
+export const MediaTransportControls = React.forwardRef((props: MediaTransportControlsProps, ref: React.ForwardedRef<MediaTransportControlsRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MediaTransportControls' ref={ref} />);
 export type MenuBarProps = Omit<NativeMenuBarProps, 'type'>;
+export type MenuBarRef = React.Component<NativeMenuBarProps> & Readonly<NativeMethods>;
 
-export const MenuBar = React.forwardRef((props: MenuBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBar' ref={ref} />);
+export const MenuBar = React.forwardRef((props: MenuBarProps, ref: React.ForwardedRef<MenuBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBar' ref={ref} />);
 export type MenuBarItemProps = Omit<NativeMenuBarItemProps, 'type'>;
+export type MenuBarItemRef = React.Component<NativeMenuBarItemProps> & Readonly<NativeMethods>;
 
-export const MenuBarItem = React.forwardRef((props: MenuBarItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBarItem' ref={ref} />);
+export const MenuBarItem = React.forwardRef((props: MenuBarItemProps, ref: React.ForwardedRef<MenuBarItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBarItem' ref={ref} />);
 export type MenuFlyoutProps = Omit<NativeMenuFlyoutProps, 'type'>;
+export type MenuFlyoutRef = React.Component<NativeMenuFlyoutProps> & Readonly<NativeMethods>;
 
-export const MenuFlyout = React.forwardRef((props: MenuFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyout' ref={ref} />);
-MenuFlyout.ShowAt = (ref: React.MutableRefObject<MenuFlyout>, args: { point: Point,  }) => {
+export const MenuFlyout = React.forwardRef((props: MenuFlyoutProps, ref: React.ForwardedRef<MenuFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyout' ref={ref} />);
+MenuFlyout.ShowAt = (ref: React.MutableRefObject<typeof NativeXamlControl>, args: { point: Point,  }) => {
   const tag = findNodeHandle(ref.current);
   UIManager.dispatchViewManagerCommand(tag, UIManager.getViewManagerConfig('XamlControl').Commands.ShowAt, [args]);
 };
 export type MenuBarItemFlyoutProps = Omit<NativeMenuBarItemFlyoutProps, 'type'>;
+export type MenuBarItemFlyoutRef = React.Component<NativeMenuBarItemFlyoutProps> & Readonly<NativeMethods>;
 
-export const MenuBarItemFlyout = React.forwardRef((props: MenuBarItemFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBarItemFlyout' ref={ref} />);
+export const MenuBarItemFlyout = React.forwardRef((props: MenuBarItemFlyoutProps, ref: React.ForwardedRef<MenuBarItemFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuBarItemFlyout' ref={ref} />);
 export type MenuFlyoutItemProps = Omit<NativeMenuFlyoutItemProps, 'type'>;
+export type MenuFlyoutItemRef = React.Component<NativeMenuFlyoutItemProps> & Readonly<NativeMethods>;
 
-export const MenuFlyoutItem = React.forwardRef((props: MenuFlyoutItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutItem' ref={ref} />);
+export const MenuFlyoutItem = React.forwardRef((props: MenuFlyoutItemProps, ref: React.ForwardedRef<MenuFlyoutItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutItem' ref={ref} />);
 export type MenuFlyoutPresenterProps = Omit<NativeMenuFlyoutPresenterProps, 'type'>;
+export type MenuFlyoutPresenterRef = React.Component<NativeMenuFlyoutPresenterProps> & Readonly<NativeMethods>;
 
-export const MenuFlyoutPresenter = React.forwardRef((props: MenuFlyoutPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutPresenter' ref={ref} />);
+export const MenuFlyoutPresenter = React.forwardRef((props: MenuFlyoutPresenterProps, ref: React.ForwardedRef<MenuFlyoutPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutPresenter' ref={ref} />);
 export type MenuFlyoutSeparatorProps = Omit<NativeMenuFlyoutSeparatorProps, 'type'>;
+export type MenuFlyoutSeparatorRef = React.Component<NativeMenuFlyoutSeparatorProps> & Readonly<NativeMethods>;
 
-export const MenuFlyoutSeparator = React.forwardRef((props: MenuFlyoutSeparatorProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutSeparator' ref={ref} />);
+export const MenuFlyoutSeparator = React.forwardRef((props: MenuFlyoutSeparatorProps, ref: React.ForwardedRef<MenuFlyoutSeparatorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutSeparator' ref={ref} />);
 export type MenuFlyoutSubItemProps = Omit<NativeMenuFlyoutSubItemProps, 'type'>;
+export type MenuFlyoutSubItemRef = React.Component<NativeMenuFlyoutSubItemProps> & Readonly<NativeMethods>;
 
-export const MenuFlyoutSubItem = React.forwardRef((props: MenuFlyoutSubItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutSubItem' ref={ref} />);
+export const MenuFlyoutSubItem = React.forwardRef((props: MenuFlyoutSubItemProps, ref: React.ForwardedRef<MenuFlyoutSubItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.MenuFlyoutSubItem' ref={ref} />);
 export type NavigationViewProps = Omit<NativeNavigationViewProps, 'type'>;
+export type NavigationViewRef = React.Component<NativeNavigationViewProps> & Readonly<NativeMethods>;
 
-export const NavigationView = React.forwardRef((props: NavigationViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationView' ref={ref} />);
+export const NavigationView = React.forwardRef((props: NavigationViewProps, ref: React.ForwardedRef<NavigationViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationView' ref={ref} />);
 export type NavigationViewItemProps = Omit<NativeNavigationViewItemProps, 'type'>;
+export type NavigationViewItemRef = React.Component<NativeNavigationViewItemProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItem = React.forwardRef((props: NavigationViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItem' ref={ref} />);
+export const NavigationViewItem = React.forwardRef((props: NavigationViewItemProps, ref: React.ForwardedRef<NavigationViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItem' ref={ref} />);
 export type NavigationViewItemHeaderProps = Omit<NativeNavigationViewItemHeaderProps, 'type'>;
+export type NavigationViewItemHeaderRef = React.Component<NativeNavigationViewItemHeaderProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItemHeader = React.forwardRef((props: NavigationViewItemHeaderProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItemHeader' ref={ref} />);
+export const NavigationViewItemHeader = React.forwardRef((props: NavigationViewItemHeaderProps, ref: React.ForwardedRef<NavigationViewItemHeaderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItemHeader' ref={ref} />);
 export type NavigationViewItemSeparatorProps = Omit<NativeNavigationViewItemSeparatorProps, 'type'>;
+export type NavigationViewItemSeparatorRef = React.Component<NativeNavigationViewItemSeparatorProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItemSeparator = React.forwardRef((props: NavigationViewItemSeparatorProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItemSeparator' ref={ref} />);
+export const NavigationViewItemSeparator = React.forwardRef((props: NavigationViewItemSeparatorProps, ref: React.ForwardedRef<NavigationViewItemSeparatorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewItemSeparator' ref={ref} />);
 export type NavigationViewListProps = Omit<NativeNavigationViewListProps, 'type'>;
+export type NavigationViewListRef = React.Component<NativeNavigationViewListProps> & Readonly<NativeMethods>;
 
-export const NavigationViewList = React.forwardRef((props: NavigationViewListProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewList' ref={ref} />);
+export const NavigationViewList = React.forwardRef((props: NavigationViewListProps, ref: React.ForwardedRef<NavigationViewListRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.NavigationViewList' ref={ref} />);
 export type UserControlProps = Omit<NativeUserControlProps, 'type'>;
+export type UserControlRef = React.Component<NativeUserControlProps> & Readonly<NativeMethods>;
 
-export const UserControl = React.forwardRef((props: UserControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.UserControl' ref={ref} />);
+export const UserControl = React.forwardRef((props: UserControlProps, ref: React.ForwardedRef<UserControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.UserControl' ref={ref} />);
 export type PageProps = Omit<NativePageProps, 'type'>;
+export type PageRef = React.Component<NativePageProps> & Readonly<NativeMethods>;
 
-export const Page = React.forwardRef((props: PageProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Page' ref={ref} />);
+export const Page = React.forwardRef((props: PageProps, ref: React.ForwardedRef<PageRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Page' ref={ref} />);
 export type ParallaxViewProps = Omit<NativeParallaxViewProps, 'type'>;
+export type ParallaxViewRef = React.Component<NativeParallaxViewProps> & Readonly<NativeMethods>;
 
-export const ParallaxView = React.forwardRef((props: ParallaxViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ParallaxView' ref={ref} />);
+export const ParallaxView = React.forwardRef((props: ParallaxViewProps, ref: React.ForwardedRef<ParallaxViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ParallaxView' ref={ref} />);
 export type PasswordBoxProps = Omit<NativePasswordBoxProps, 'type'>;
+export type PasswordBoxRef = React.Component<NativePasswordBoxProps> & Readonly<NativeMethods>;
 
-export const PasswordBox = React.forwardRef((props: PasswordBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PasswordBox' ref={ref} />);
+export const PasswordBox = React.forwardRef((props: PasswordBoxProps, ref: React.ForwardedRef<PasswordBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PasswordBox' ref={ref} />);
 export type PathIconProps = Omit<NativePathIconProps, 'type'>;
+export type PathIconRef = React.Component<NativePathIconProps> & Readonly<NativeMethods>;
 
-export const PathIcon = React.forwardRef((props: PathIconProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PathIcon' ref={ref} />);
+export const PathIcon = React.forwardRef((props: PathIconProps, ref: React.ForwardedRef<PathIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PathIcon' ref={ref} />);
 export type PersonPictureProps = Omit<NativePersonPictureProps, 'type'>;
+export type PersonPictureRef = React.Component<NativePersonPictureProps> & Readonly<NativeMethods>;
 
-export const PersonPicture = React.forwardRef((props: PersonPictureProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PersonPicture' ref={ref} />);
+export const PersonPicture = React.forwardRef((props: PersonPictureProps, ref: React.ForwardedRef<PersonPictureRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PersonPicture' ref={ref} />);
 export type PickerFlyoutProps = Omit<NativePickerFlyoutProps, 'type'>;
+export type PickerFlyoutRef = React.Component<NativePickerFlyoutProps> & Readonly<NativeMethods>;
 
-export const PickerFlyout = React.forwardRef((props: PickerFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PickerFlyout' ref={ref} />);
+export const PickerFlyout = React.forwardRef((props: PickerFlyoutProps, ref: React.ForwardedRef<PickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PickerFlyout' ref={ref} />);
 export type PivotProps = Omit<NativePivotProps, 'type'>;
+export type PivotRef = React.Component<NativePivotProps> & Readonly<NativeMethods>;
 
-export const Pivot = React.forwardRef((props: PivotProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Pivot' ref={ref} />);
+export const Pivot = React.forwardRef((props: PivotProps, ref: React.ForwardedRef<PivotRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Pivot' ref={ref} />);
 export type PivotItemProps = Omit<NativePivotItemProps, 'type'>;
+export type PivotItemRef = React.Component<NativePivotItemProps> & Readonly<NativeMethods>;
 
-export const PivotItem = React.forwardRef((props: PivotItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PivotItem' ref={ref} />);
+export const PivotItem = React.forwardRef((props: PivotItemProps, ref: React.ForwardedRef<PivotItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.PivotItem' ref={ref} />);
 export type CalendarPanelProps = Omit<NativeCalendarPanelProps, 'type'>;
+export type CalendarPanelRef = React.Component<NativeCalendarPanelProps> & Readonly<NativeMethods>;
 
-export const CalendarPanel = React.forwardRef((props: CalendarPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CalendarPanel' ref={ref} />);
+export const CalendarPanel = React.forwardRef((props: CalendarPanelProps, ref: React.ForwardedRef<CalendarPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CalendarPanel' ref={ref} />);
 export type CarouselPanelProps = Omit<NativeCarouselPanelProps, 'type'>;
+export type CarouselPanelRef = React.Component<NativeCarouselPanelProps> & Readonly<NativeMethods>;
 
-export const CarouselPanel = React.forwardRef((props: CarouselPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CarouselPanel' ref={ref} />);
+export const CarouselPanel = React.forwardRef((props: CarouselPanelProps, ref: React.ForwardedRef<CarouselPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CarouselPanel' ref={ref} />);
 export type SliderProps = Omit<NativeSliderProps, 'type'>;
+export type SliderRef = React.Component<NativeSliderProps> & Readonly<NativeMethods>;
 
-export const Slider = React.forwardRef((props: SliderProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Slider' ref={ref} />);
+export const Slider = React.forwardRef((props: SliderProps, ref: React.ForwardedRef<SliderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Slider' ref={ref} />);
 export type ColorPickerSliderProps = Omit<NativeColorPickerSliderProps, 'type'>;
+export type ColorPickerSliderRef = React.Component<NativeColorPickerSliderProps> & Readonly<NativeMethods>;
 
-export const ColorPickerSlider = React.forwardRef((props: ColorPickerSliderProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ColorPickerSlider' ref={ref} />);
+export const ColorPickerSlider = React.forwardRef((props: ColorPickerSliderProps, ref: React.ForwardedRef<ColorPickerSliderRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ColorPickerSlider' ref={ref} />);
 export type ColorSpectrumProps = Omit<NativeColorSpectrumProps, 'type'>;
+export type ColorSpectrumRef = React.Component<NativeColorSpectrumProps> & Readonly<NativeMethods>;
 
-export const ColorSpectrum = React.forwardRef((props: ColorSpectrumProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ColorSpectrum' ref={ref} />);
+export const ColorSpectrum = React.forwardRef((props: ColorSpectrumProps, ref: React.ForwardedRef<ColorSpectrumRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ColorSpectrum' ref={ref} />);
 export type CommandBarFlyoutCommandBarProps = Omit<NativeCommandBarFlyoutCommandBarProps, 'type'>;
+export type CommandBarFlyoutCommandBarRef = React.Component<NativeCommandBarFlyoutCommandBarProps> & Readonly<NativeMethods>;
 
-export const CommandBarFlyoutCommandBar = React.forwardRef((props: CommandBarFlyoutCommandBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBar' ref={ref} />);
+export const CommandBarFlyoutCommandBar = React.forwardRef((props: CommandBarFlyoutCommandBarProps, ref: React.ForwardedRef<CommandBarFlyoutCommandBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.CommandBarFlyoutCommandBar' ref={ref} />);
 export type GridViewItemPresenterProps = Omit<NativeGridViewItemPresenterProps, 'type'>;
+export type GridViewItemPresenterRef = React.Component<NativeGridViewItemPresenterProps> & Readonly<NativeMethods>;
 
-export const GridViewItemPresenter = React.forwardRef((props: GridViewItemPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.GridViewItemPresenter' ref={ref} />);
+export const GridViewItemPresenter = React.forwardRef((props: GridViewItemPresenterProps, ref: React.ForwardedRef<GridViewItemPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.GridViewItemPresenter' ref={ref} />);
 export type ListViewItemPresenterProps = Omit<NativeListViewItemPresenterProps, 'type'>;
+export type ListViewItemPresenterRef = React.Component<NativeListViewItemPresenterProps> & Readonly<NativeMethods>;
 
-export const ListViewItemPresenter = React.forwardRef((props: ListViewItemPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ListViewItemPresenter' ref={ref} />);
+export const ListViewItemPresenter = React.forwardRef((props: ListViewItemPresenterProps, ref: React.ForwardedRef<ListViewItemPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ListViewItemPresenter' ref={ref} />);
 export type NavigationViewItemPresenterProps = Omit<NativeNavigationViewItemPresenterProps, 'type'>;
+export type NavigationViewItemPresenterRef = React.Component<NativeNavigationViewItemPresenterProps> & Readonly<NativeMethods>;
 
-export const NavigationViewItemPresenter = React.forwardRef((props: NavigationViewItemPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.NavigationViewItemPresenter' ref={ref} />);
+export const NavigationViewItemPresenter = React.forwardRef((props: NavigationViewItemPresenterProps, ref: React.ForwardedRef<NavigationViewItemPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.NavigationViewItemPresenter' ref={ref} />);
 export type PivotHeaderItemProps = Omit<NativePivotHeaderItemProps, 'type'>;
+export type PivotHeaderItemRef = React.Component<NativePivotHeaderItemProps> & Readonly<NativeMethods>;
 
-export const PivotHeaderItem = React.forwardRef((props: PivotHeaderItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotHeaderItem' ref={ref} />);
+export const PivotHeaderItem = React.forwardRef((props: PivotHeaderItemProps, ref: React.ForwardedRef<PivotHeaderItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotHeaderItem' ref={ref} />);
 export type PivotHeaderPanelProps = Omit<NativePivotHeaderPanelProps, 'type'>;
+export type PivotHeaderPanelRef = React.Component<NativePivotHeaderPanelProps> & Readonly<NativeMethods>;
 
-export const PivotHeaderPanel = React.forwardRef((props: PivotHeaderPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotHeaderPanel' ref={ref} />);
+export const PivotHeaderPanel = React.forwardRef((props: PivotHeaderPanelProps, ref: React.ForwardedRef<PivotHeaderPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotHeaderPanel' ref={ref} />);
 export type PivotPanelProps = Omit<NativePivotPanelProps, 'type'>;
+export type PivotPanelRef = React.Component<NativePivotPanelProps> & Readonly<NativeMethods>;
 
-export const PivotPanel = React.forwardRef((props: PivotPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotPanel' ref={ref} />);
+export const PivotPanel = React.forwardRef((props: PivotPanelProps, ref: React.ForwardedRef<PivotPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.PivotPanel' ref={ref} />);
 export type PopupProps = Omit<NativePopupProps, 'type'>;
+export type PopupRef = React.Component<NativePopupProps> & Readonly<NativeMethods>;
 
-export const Popup = React.forwardRef((props: PopupProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.Popup' ref={ref} />);
+export const Popup = React.forwardRef((props: PopupProps, ref: React.ForwardedRef<PopupRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.Popup' ref={ref} />);
 export type RepeatButtonProps = Omit<NativeRepeatButtonProps, 'type'>;
+export type RepeatButtonRef = React.Component<NativeRepeatButtonProps> & Readonly<NativeMethods>;
 
-export const RepeatButton = React.forwardRef((props: RepeatButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.RepeatButton' ref={ref} />);
+export const RepeatButton = React.forwardRef((props: RepeatButtonProps, ref: React.ForwardedRef<RepeatButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.RepeatButton' ref={ref} />);
 export type ScrollBarProps = Omit<NativeScrollBarProps, 'type'>;
+export type ScrollBarRef = React.Component<NativeScrollBarProps> & Readonly<NativeMethods>;
 
-export const ScrollBar = React.forwardRef((props: ScrollBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ScrollBar' ref={ref} />);
+export const ScrollBar = React.forwardRef((props: ScrollBarProps, ref: React.ForwardedRef<ScrollBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.ScrollBar' ref={ref} />);
 export type ThumbProps = Omit<NativeThumbProps, 'type'>;
+export type ThumbRef = React.Component<NativeThumbProps> & Readonly<NativeMethods>;
 
-export const Thumb = React.forwardRef((props: ThumbProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.Thumb' ref={ref} />);
+export const Thumb = React.forwardRef((props: ThumbProps, ref: React.ForwardedRef<ThumbRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.Thumb' ref={ref} />);
 export type TickBarProps = Omit<NativeTickBarProps, 'type'>;
+export type TickBarRef = React.Component<NativeTickBarProps> & Readonly<NativeMethods>;
 
-export const TickBar = React.forwardRef((props: TickBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.TickBar' ref={ref} />);
+export const TickBar = React.forwardRef((props: TickBarProps, ref: React.ForwardedRef<TickBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Primitives.TickBar' ref={ref} />);
 export type ProgressBarProps = Omit<NativeProgressBarProps, 'type'>;
+export type ProgressBarRef = React.Component<NativeProgressBarProps> & Readonly<NativeMethods>;
 
-export const ProgressBar = React.forwardRef((props: ProgressBarProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ProgressBar' ref={ref} />);
+export const ProgressBar = React.forwardRef((props: ProgressBarProps, ref: React.ForwardedRef<ProgressBarRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ProgressBar' ref={ref} />);
 export type ProgressRingProps = Omit<NativeProgressRingProps, 'type'>;
+export type ProgressRingRef = React.Component<NativeProgressRingProps> & Readonly<NativeMethods>;
 
-export const ProgressRing = React.forwardRef((props: ProgressRingProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ProgressRing' ref={ref} />);
+export const ProgressRing = React.forwardRef((props: ProgressRingProps, ref: React.ForwardedRef<ProgressRingRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ProgressRing' ref={ref} />);
 export type RatingControlProps = Omit<NativeRatingControlProps, 'type'>;
+export type RatingControlRef = React.Component<NativeRatingControlProps> & Readonly<NativeMethods>;
 
-export const RatingControl = React.forwardRef((props: RatingControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RatingControl' ref={ref} />);
+export const RatingControl = React.forwardRef((props: RatingControlProps, ref: React.ForwardedRef<RatingControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RatingControl' ref={ref} />);
 export type RefreshContainerProps = Omit<NativeRefreshContainerProps, 'type'>;
+export type RefreshContainerRef = React.Component<NativeRefreshContainerProps> & Readonly<NativeMethods>;
 
-export const RefreshContainer = React.forwardRef((props: RefreshContainerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RefreshContainer' ref={ref} />);
+export const RefreshContainer = React.forwardRef((props: RefreshContainerProps, ref: React.ForwardedRef<RefreshContainerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RefreshContainer' ref={ref} />);
 export type RefreshVisualizerProps = Omit<NativeRefreshVisualizerProps, 'type'>;
+export type RefreshVisualizerRef = React.Component<NativeRefreshVisualizerProps> & Readonly<NativeMethods>;
 
-export const RefreshVisualizer = React.forwardRef((props: RefreshVisualizerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RefreshVisualizer' ref={ref} />);
+export const RefreshVisualizer = React.forwardRef((props: RefreshVisualizerProps, ref: React.ForwardedRef<RefreshVisualizerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RefreshVisualizer' ref={ref} />);
 export type RelativePanelProps = Omit<NativeRelativePanelProps, 'type'>;
+export type RelativePanelRef = React.Component<NativeRelativePanelProps> & Readonly<NativeMethods>;
 
-export const RelativePanel = React.forwardRef((props: RelativePanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RelativePanel' ref={ref} />);
+export const RelativePanel = React.forwardRef((props: RelativePanelProps, ref: React.ForwardedRef<RelativePanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RelativePanel' ref={ref} />);
 export type RichEditBoxProps = Omit<NativeRichEditBoxProps, 'type'>;
+export type RichEditBoxRef = React.Component<NativeRichEditBoxProps> & Readonly<NativeMethods>;
 
-export const RichEditBox = React.forwardRef((props: RichEditBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichEditBox' ref={ref} />);
+export const RichEditBox = React.forwardRef((props: RichEditBoxProps, ref: React.ForwardedRef<RichEditBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichEditBox' ref={ref} />);
 export type RichTextBlockProps = Omit<NativeRichTextBlockProps, 'type'>;
+export type RichTextBlockRef = React.Component<NativeRichTextBlockProps> & Readonly<NativeMethods>;
 
-export const RichTextBlock = React.forwardRef((props: RichTextBlockProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichTextBlock' ref={ref} />);
+export const RichTextBlock = React.forwardRef((props: RichTextBlockProps, ref: React.ForwardedRef<RichTextBlockRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichTextBlock' ref={ref} />);
 export type RichTextBlockOverflowProps = Omit<NativeRichTextBlockOverflowProps, 'type'>;
+export type RichTextBlockOverflowRef = React.Component<NativeRichTextBlockOverflowProps> & Readonly<NativeMethods>;
 
-export const RichTextBlockOverflow = React.forwardRef((props: RichTextBlockOverflowProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichTextBlockOverflow' ref={ref} />);
+export const RichTextBlockOverflow = React.forwardRef((props: RichTextBlockOverflowProps, ref: React.ForwardedRef<RichTextBlockOverflowRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.RichTextBlockOverflow' ref={ref} />);
 export type ScrollContentPresenterProps = Omit<NativeScrollContentPresenterProps, 'type'>;
+export type ScrollContentPresenterRef = React.Component<NativeScrollContentPresenterProps> & Readonly<NativeMethods>;
 
-export const ScrollContentPresenter = React.forwardRef((props: ScrollContentPresenterProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ScrollContentPresenter' ref={ref} />);
+export const ScrollContentPresenter = React.forwardRef((props: ScrollContentPresenterProps, ref: React.ForwardedRef<ScrollContentPresenterRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ScrollContentPresenter' ref={ref} />);
 export type ScrollViewerProps = Omit<NativeScrollViewerProps, 'type'>;
+export type ScrollViewerRef = React.Component<NativeScrollViewerProps> & Readonly<NativeMethods>;
 
-export const ScrollViewer = React.forwardRef((props: ScrollViewerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ScrollViewer' ref={ref} />);
+export const ScrollViewer = React.forwardRef((props: ScrollViewerProps, ref: React.ForwardedRef<ScrollViewerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ScrollViewer' ref={ref} />);
 export type SearchBoxProps = Omit<NativeSearchBoxProps, 'type'>;
+export type SearchBoxRef = React.Component<NativeSearchBoxProps> & Readonly<NativeMethods>;
 
-export const SearchBox = React.forwardRef((props: SearchBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SearchBox' ref={ref} />);
+export const SearchBox = React.forwardRef((props: SearchBoxProps, ref: React.ForwardedRef<SearchBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SearchBox' ref={ref} />);
 export type SemanticZoomProps = Omit<NativeSemanticZoomProps, 'type'>;
+export type SemanticZoomRef = React.Component<NativeSemanticZoomProps> & Readonly<NativeMethods>;
 
-export const SemanticZoom = React.forwardRef((props: SemanticZoomProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SemanticZoom' ref={ref} />);
+export const SemanticZoom = React.forwardRef((props: SemanticZoomProps, ref: React.ForwardedRef<SemanticZoomRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SemanticZoom' ref={ref} />);
 export type SettingsFlyoutProps = Omit<NativeSettingsFlyoutProps, 'type'>;
+export type SettingsFlyoutRef = React.Component<NativeSettingsFlyoutProps> & Readonly<NativeMethods>;
 
-export const SettingsFlyout = React.forwardRef((props: SettingsFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SettingsFlyout' ref={ref} />);
+export const SettingsFlyout = React.forwardRef((props: SettingsFlyoutProps, ref: React.ForwardedRef<SettingsFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SettingsFlyout' ref={ref} />);
 export type SplitButtonProps = Omit<NativeSplitButtonProps, 'type'>;
+export type SplitButtonRef = React.Component<NativeSplitButtonProps> & Readonly<NativeMethods>;
 
-export const SplitButton = React.forwardRef((props: SplitButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SplitButton' ref={ref} />);
+export const SplitButton = React.forwardRef((props: SplitButtonProps, ref: React.ForwardedRef<SplitButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SplitButton' ref={ref} />);
 export type SplitViewProps = Omit<NativeSplitViewProps, 'type'>;
+export type SplitViewRef = React.Component<NativeSplitViewProps> & Readonly<NativeMethods>;
 
-export const SplitView = React.forwardRef((props: SplitViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SplitView' ref={ref} />);
+export const SplitView = React.forwardRef((props: SplitViewProps, ref: React.ForwardedRef<SplitViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SplitView' ref={ref} />);
 export type StackPanelProps = Omit<NativeStackPanelProps, 'type'>;
+export type StackPanelRef = React.Component<NativeStackPanelProps> & Readonly<NativeMethods>;
 
-export const StackPanel = React.forwardRef((props: StackPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.StackPanel' ref={ref} />);
+export const StackPanel = React.forwardRef((props: StackPanelProps, ref: React.ForwardedRef<StackPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.StackPanel' ref={ref} />);
 export type SwapChainBackgroundPanelProps = Omit<NativeSwapChainBackgroundPanelProps, 'type'>;
+export type SwapChainBackgroundPanelRef = React.Component<NativeSwapChainBackgroundPanelProps> & Readonly<NativeMethods>;
 
-export const SwapChainBackgroundPanel = React.forwardRef((props: SwapChainBackgroundPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwapChainBackgroundPanel' ref={ref} />);
+export const SwapChainBackgroundPanel = React.forwardRef((props: SwapChainBackgroundPanelProps, ref: React.ForwardedRef<SwapChainBackgroundPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwapChainBackgroundPanel' ref={ref} />);
 export type SwapChainPanelProps = Omit<NativeSwapChainPanelProps, 'type'>;
+export type SwapChainPanelRef = React.Component<NativeSwapChainPanelProps> & Readonly<NativeMethods>;
 
-export const SwapChainPanel = React.forwardRef((props: SwapChainPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwapChainPanel' ref={ref} />);
+export const SwapChainPanel = React.forwardRef((props: SwapChainPanelProps, ref: React.ForwardedRef<SwapChainPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwapChainPanel' ref={ref} />);
 export type SwipeControlProps = Omit<NativeSwipeControlProps, 'type'>;
+export type SwipeControlRef = React.Component<NativeSwipeControlProps> & Readonly<NativeMethods>;
 
-export const SwipeControl = React.forwardRef((props: SwipeControlProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwipeControl' ref={ref} />);
+export const SwipeControl = React.forwardRef((props: SwipeControlProps, ref: React.ForwardedRef<SwipeControlRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SwipeControl' ref={ref} />);
 export type SymbolIconProps = Omit<NativeSymbolIconProps, 'type'>;
+export type SymbolIconRef = React.Component<NativeSymbolIconProps> & Readonly<NativeMethods>;
 
-export const SymbolIcon = React.forwardRef((props: SymbolIconProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SymbolIcon' ref={ref} />);
+export const SymbolIcon = React.forwardRef((props: SymbolIconProps, ref: React.ForwardedRef<SymbolIconRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.SymbolIcon' ref={ref} />);
 export type TextBlockProps = Omit<NativeTextBlockProps, 'type'>;
+export type TextBlockRef = React.Component<NativeTextBlockProps> & Readonly<NativeMethods>;
 
-export const TextBlock = React.forwardRef((props: TextBlockProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextBlock' ref={ref} />);
+export const TextBlock = React.forwardRef((props: TextBlockProps, ref: React.ForwardedRef<TextBlockRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextBlock' ref={ref} />);
 export type TextBoxProps = Omit<NativeTextBoxProps, 'type'>;
+export type TextBoxRef = React.Component<NativeTextBoxProps> & Readonly<NativeMethods>;
 
-export const TextBox = React.forwardRef((props: TextBoxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextBox' ref={ref} />);
+export const TextBox = React.forwardRef((props: TextBoxProps, ref: React.ForwardedRef<TextBoxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextBox' ref={ref} />);
 export type TextCommandBarFlyoutProps = Omit<NativeTextCommandBarFlyoutProps, 'type'>;
+export type TextCommandBarFlyoutRef = React.Component<NativeTextCommandBarFlyoutProps> & Readonly<NativeMethods>;
 
-export const TextCommandBarFlyout = React.forwardRef((props: TextCommandBarFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextCommandBarFlyout' ref={ref} />);
+export const TextCommandBarFlyout = React.forwardRef((props: TextCommandBarFlyoutProps, ref: React.ForwardedRef<TextCommandBarFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TextCommandBarFlyout' ref={ref} />);
 export type TimePickerProps = Omit<NativeTimePickerProps, 'type'>;
+export type TimePickerRef = React.Component<NativeTimePickerProps> & Readonly<NativeMethods>;
 
-export const TimePicker = React.forwardRef((props: TimePickerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TimePicker' ref={ref} />);
+export const TimePicker = React.forwardRef((props: TimePickerProps, ref: React.ForwardedRef<TimePickerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TimePicker' ref={ref} />);
 export type TimePickerFlyoutProps = Omit<NativeTimePickerFlyoutProps, 'type'>;
+export type TimePickerFlyoutRef = React.Component<NativeTimePickerFlyoutProps> & Readonly<NativeMethods>;
 
-export const TimePickerFlyout = React.forwardRef((props: TimePickerFlyoutProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TimePickerFlyout' ref={ref} />);
+export const TimePickerFlyout = React.forwardRef((props: TimePickerFlyoutProps, ref: React.ForwardedRef<TimePickerFlyoutRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TimePickerFlyout' ref={ref} />);
 export type ToggleMenuFlyoutItemProps = Omit<NativeToggleMenuFlyoutItemProps, 'type'>;
+export type ToggleMenuFlyoutItemRef = React.Component<NativeToggleMenuFlyoutItemProps> & Readonly<NativeMethods>;
 
-export const ToggleMenuFlyoutItem = React.forwardRef((props: ToggleMenuFlyoutItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleMenuFlyoutItem' ref={ref} />);
+export const ToggleMenuFlyoutItem = React.forwardRef((props: ToggleMenuFlyoutItemProps, ref: React.ForwardedRef<ToggleMenuFlyoutItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleMenuFlyoutItem' ref={ref} />);
 export type ToggleSplitButtonProps = Omit<NativeToggleSplitButtonProps, 'type'>;
+export type ToggleSplitButtonRef = React.Component<NativeToggleSplitButtonProps> & Readonly<NativeMethods>;
 
-export const ToggleSplitButton = React.forwardRef((props: ToggleSplitButtonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleSplitButton' ref={ref} />);
+export const ToggleSplitButton = React.forwardRef((props: ToggleSplitButtonProps, ref: React.ForwardedRef<ToggleSplitButtonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleSplitButton' ref={ref} />);
 export type ToggleSwitchProps = Omit<NativeToggleSwitchProps, 'type'>;
+export type ToggleSwitchRef = React.Component<NativeToggleSwitchProps> & Readonly<NativeMethods>;
 
-export const ToggleSwitch = React.forwardRef((props: ToggleSwitchProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleSwitch' ref={ref} />);
+export const ToggleSwitch = React.forwardRef((props: ToggleSwitchProps, ref: React.ForwardedRef<ToggleSwitchRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToggleSwitch' ref={ref} />);
 export type ToolTipProps = Omit<NativeToolTipProps, 'type'>;
+export type ToolTipRef = React.Component<NativeToolTipProps> & Readonly<NativeMethods>;
 
-export const ToolTip = React.forwardRef((props: ToolTipProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToolTip' ref={ref} />);
+export const ToolTip = React.forwardRef((props: ToolTipProps, ref: React.ForwardedRef<ToolTipRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.ToolTip' ref={ref} />);
 export type TreeViewProps = Omit<NativeTreeViewProps, 'type'>;
+export type TreeViewRef = React.Component<NativeTreeViewProps> & Readonly<NativeMethods>;
 
-export const TreeView = React.forwardRef((props: TreeViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeView' ref={ref} />);
+export const TreeView = React.forwardRef((props: TreeViewProps, ref: React.ForwardedRef<TreeViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeView' ref={ref} />);
 export type TreeViewItemProps = Omit<NativeTreeViewItemProps, 'type'>;
+export type TreeViewItemRef = React.Component<NativeTreeViewItemProps> & Readonly<NativeMethods>;
 
-export const TreeViewItem = React.forwardRef((props: TreeViewItemProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeViewItem' ref={ref} />);
+export const TreeViewItem = React.forwardRef((props: TreeViewItemProps, ref: React.ForwardedRef<TreeViewItemRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeViewItem' ref={ref} />);
 export type TreeViewListProps = Omit<NativeTreeViewListProps, 'type'>;
+export type TreeViewListRef = React.Component<NativeTreeViewListProps> & Readonly<NativeMethods>;
 
-export const TreeViewList = React.forwardRef((props: TreeViewListProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeViewList' ref={ref} />);
+export const TreeViewList = React.forwardRef((props: TreeViewListProps, ref: React.ForwardedRef<TreeViewListRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TreeViewList' ref={ref} />);
 export type TwoPaneViewProps = Omit<NativeTwoPaneViewProps, 'type'>;
+export type TwoPaneViewRef = React.Component<NativeTwoPaneViewProps> & Readonly<NativeMethods>;
 
-export const TwoPaneView = React.forwardRef((props: TwoPaneViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TwoPaneView' ref={ref} />);
+export const TwoPaneView = React.forwardRef((props: TwoPaneViewProps, ref: React.ForwardedRef<TwoPaneViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.TwoPaneView' ref={ref} />);
 export type VariableSizedWrapGridProps = Omit<NativeVariableSizedWrapGridProps, 'type'>;
+export type VariableSizedWrapGridRef = React.Component<NativeVariableSizedWrapGridProps> & Readonly<NativeMethods>;
 
-export const VariableSizedWrapGrid = React.forwardRef((props: VariableSizedWrapGridProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.VariableSizedWrapGrid' ref={ref} />);
+export const VariableSizedWrapGrid = React.forwardRef((props: VariableSizedWrapGridProps, ref: React.ForwardedRef<VariableSizedWrapGridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.VariableSizedWrapGrid' ref={ref} />);
 export type ViewboxProps = Omit<NativeViewboxProps, 'type'>;
+export type ViewboxRef = React.Component<NativeViewboxProps> & Readonly<NativeMethods>;
 
-export const Viewbox = React.forwardRef((props: ViewboxProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Viewbox' ref={ref} />);
+export const Viewbox = React.forwardRef((props: ViewboxProps, ref: React.ForwardedRef<ViewboxRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.Viewbox' ref={ref} />);
 export type VirtualizingStackPanelProps = Omit<NativeVirtualizingStackPanelProps, 'type'>;
+export type VirtualizingStackPanelRef = React.Component<NativeVirtualizingStackPanelProps> & Readonly<NativeMethods>;
 
-export const VirtualizingStackPanel = React.forwardRef((props: VirtualizingStackPanelProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.VirtualizingStackPanel' ref={ref} />);
+export const VirtualizingStackPanel = React.forwardRef((props: VirtualizingStackPanelProps, ref: React.ForwardedRef<VirtualizingStackPanelRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.VirtualizingStackPanel' ref={ref} />);
 export type WebViewProps = Omit<NativeWebViewProps, 'type'>;
+export type WebViewRef = React.Component<NativeWebViewProps> & Readonly<NativeMethods>;
 
-export const WebView = React.forwardRef((props: WebViewProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.WebView' ref={ref} />);
+export const WebView = React.forwardRef((props: WebViewProps, ref: React.ForwardedRef<WebViewRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.WebView' ref={ref} />);
 export type WrapGridProps = Omit<NativeWrapGridProps, 'type'>;
+export type WrapGridRef = React.Component<NativeWrapGridProps> & Readonly<NativeMethods>;
 
-export const WrapGrid = React.forwardRef((props: WrapGridProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.WrapGrid' ref={ref} />);
+export const WrapGrid = React.forwardRef((props: WrapGridProps, ref: React.ForwardedRef<WrapGridRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Controls.WrapGrid' ref={ref} />);
 export type SpanProps = Omit<NativeSpanProps, 'type'>;
+export type SpanRef = React.Component<NativeSpanProps> & Readonly<NativeMethods>;
 
-export const Span = React.forwardRef((props: SpanProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Span' ref={ref} />);
+export const Span = React.forwardRef((props: SpanProps, ref: React.ForwardedRef<SpanRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Span' ref={ref} />);
 export type BoldProps = Omit<NativeBoldProps, 'type'>;
+export type BoldRef = React.Component<NativeBoldProps> & Readonly<NativeMethods>;
 
-export const Bold = React.forwardRef((props: BoldProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Bold' ref={ref} />);
+export const Bold = React.forwardRef((props: BoldProps, ref: React.ForwardedRef<BoldRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Bold' ref={ref} />);
 export type ContentLinkProps = Omit<NativeContentLinkProps, 'type'>;
+export type ContentLinkRef = React.Component<NativeContentLinkProps> & Readonly<NativeMethods>;
 
-export const ContentLink = React.forwardRef((props: ContentLinkProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.ContentLink' ref={ref} />);
+export const ContentLink = React.forwardRef((props: ContentLinkProps, ref: React.ForwardedRef<ContentLinkRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.ContentLink' ref={ref} />);
 export type GlyphsProps = Omit<NativeGlyphsProps, 'type'>;
+export type GlyphsRef = React.Component<NativeGlyphsProps> & Readonly<NativeMethods>;
 
-export const Glyphs = React.forwardRef((props: GlyphsProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Glyphs' ref={ref} />);
+export const Glyphs = React.forwardRef((props: GlyphsProps, ref: React.ForwardedRef<GlyphsRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Glyphs' ref={ref} />);
 export type HyperlinkProps = Omit<NativeHyperlinkProps, 'type'>;
+export type HyperlinkRef = React.Component<NativeHyperlinkProps> & Readonly<NativeMethods>;
 
-export const Hyperlink = React.forwardRef((props: HyperlinkProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Hyperlink' ref={ref} />);
+export const Hyperlink = React.forwardRef((props: HyperlinkProps, ref: React.ForwardedRef<HyperlinkRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Hyperlink' ref={ref} />);
 export type InlineUIContainerProps = Omit<NativeInlineUIContainerProps, 'type'>;
+export type InlineUIContainerRef = React.Component<NativeInlineUIContainerProps> & Readonly<NativeMethods>;
 
-export const InlineUIContainer = React.forwardRef((props: InlineUIContainerProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.InlineUIContainer' ref={ref} />);
+export const InlineUIContainer = React.forwardRef((props: InlineUIContainerProps, ref: React.ForwardedRef<InlineUIContainerRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.InlineUIContainer' ref={ref} />);
 export type ItalicProps = Omit<NativeItalicProps, 'type'>;
+export type ItalicRef = React.Component<NativeItalicProps> & Readonly<NativeMethods>;
 
-export const Italic = React.forwardRef((props: ItalicProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Italic' ref={ref} />);
+export const Italic = React.forwardRef((props: ItalicProps, ref: React.ForwardedRef<ItalicRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Italic' ref={ref} />);
 export type LineBreakProps = Omit<NativeLineBreakProps, 'type'>;
+export type LineBreakRef = React.Component<NativeLineBreakProps> & Readonly<NativeMethods>;
 
-export const LineBreak = React.forwardRef((props: LineBreakProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.LineBreak' ref={ref} />);
+export const LineBreak = React.forwardRef((props: LineBreakProps, ref: React.ForwardedRef<LineBreakRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.LineBreak' ref={ref} />);
 export type ParagraphProps = Omit<NativeParagraphProps, 'type'>;
+export type ParagraphRef = React.Component<NativeParagraphProps> & Readonly<NativeMethods>;
 
-export const Paragraph = React.forwardRef((props: ParagraphProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Paragraph' ref={ref} />);
+export const Paragraph = React.forwardRef((props: ParagraphProps, ref: React.ForwardedRef<ParagraphRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Paragraph' ref={ref} />);
 export type RunProps = Omit<NativeRunProps, 'type'>;
+export type RunRef = React.Component<NativeRunProps> & Readonly<NativeMethods>;
 
-export const Run = React.forwardRef((props: RunProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Run' ref={ref} />);
+export const Run = React.forwardRef((props: RunProps, ref: React.ForwardedRef<RunRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Run' ref={ref} />);
 export type UnderlineProps = Omit<NativeUnderlineProps, 'type'>;
+export type UnderlineRef = React.Component<NativeUnderlineProps> & Readonly<NativeMethods>;
 
-export const Underline = React.forwardRef((props: UnderlineProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Underline' ref={ref} />);
+export const Underline = React.forwardRef((props: UnderlineProps, ref: React.ForwardedRef<UnderlineRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Documents.Underline' ref={ref} />);
 export type KeyboardAcceleratorProps = Omit<NativeKeyboardAcceleratorProps, 'type'>;
+export type KeyboardAcceleratorRef = React.Component<NativeKeyboardAcceleratorProps> & Readonly<NativeMethods>;
 
-export const KeyboardAccelerator = React.forwardRef((props: KeyboardAcceleratorProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Input.KeyboardAccelerator' ref={ref} />);
+export const KeyboardAccelerator = React.forwardRef((props: KeyboardAcceleratorProps, ref: React.ForwardedRef<KeyboardAcceleratorRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Input.KeyboardAccelerator' ref={ref} />);
 export type EllipseProps = Omit<NativeEllipseProps, 'type'>;
+export type EllipseRef = React.Component<NativeEllipseProps> & Readonly<NativeMethods>;
 
-export const Ellipse = React.forwardRef((props: EllipseProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Ellipse' ref={ref} />);
+export const Ellipse = React.forwardRef((props: EllipseProps, ref: React.ForwardedRef<EllipseRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Ellipse' ref={ref} />);
 export type LineProps = Omit<NativeLineProps, 'type'>;
+export type LineRef = React.Component<NativeLineProps> & Readonly<NativeMethods>;
 
-export const Line = React.forwardRef((props: LineProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Line' ref={ref} />);
+export const Line = React.forwardRef((props: LineProps, ref: React.ForwardedRef<LineRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Line' ref={ref} />);
 export type PathProps = Omit<NativePathProps, 'type'>;
+export type PathRef = React.Component<NativePathProps> & Readonly<NativeMethods>;
 
-export const Path = React.forwardRef((props: PathProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Path' ref={ref} />);
+export const Path = React.forwardRef((props: PathProps, ref: React.ForwardedRef<PathRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Path' ref={ref} />);
 export type PolygonProps = Omit<NativePolygonProps, 'type'>;
+export type PolygonRef = React.Component<NativePolygonProps> & Readonly<NativeMethods>;
 
-export const Polygon = React.forwardRef((props: PolygonProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Polygon' ref={ref} />);
+export const Polygon = React.forwardRef((props: PolygonProps, ref: React.ForwardedRef<PolygonRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Polygon' ref={ref} />);
 export type PolylineProps = Omit<NativePolylineProps, 'type'>;
+export type PolylineRef = React.Component<NativePolylineProps> & Readonly<NativeMethods>;
 
-export const Polyline = React.forwardRef((props: PolylineProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Polyline' ref={ref} />);
+export const Polyline = React.forwardRef((props: PolylineProps, ref: React.ForwardedRef<PolylineRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Polyline' ref={ref} />);
 export type RectangleProps = Omit<NativeRectangleProps, 'type'>;
+export type RectangleRef = React.Component<NativeRectangleProps> & Readonly<NativeMethods>;
 
-export const Rectangle = React.forwardRef((props: RectangleProps, ref: React.ForwardedRef<typeof NativeXamlControl>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Rectangle' ref={ref} />);
+export const Rectangle = React.forwardRef((props: RectangleProps, ref: React.ForwardedRef<RectangleRef>) => <NativeXamlControl {...props} type='Windows.UI.Xaml.Shapes.Rectangle' ref={ref} />);
 
 export namespace WinUI {
 export type BreadcrumbBarItemClickedEventArgs = NativeWinUI.NativeBreadcrumbBarItemClickedEventArgs;    // Microsoft.UI.Xaml.Controls.BreadcrumbBarItemClickedEventArgs