diff --git a/.github/ISSUE_TEMPLATE/react-native-windows--vnext--bug-report.md b/.github/ISSUE_TEMPLATE/react-native-windows--vnext--bug-report.md
index 9eec9ad1661..e04f2dbda25 100644
--- a/.github/ISSUE_TEMPLATE/react-native-windows--vnext--bug-report.md
+++ b/.github/ISSUE_TEMPLATE/react-native-windows--vnext--bug-report.md
@@ -15,6 +15,7 @@ assignees: ''
 If you are using latest version:
 1. `react-native -v`:
 2. `react-native run-windows --info`:
+3. `reg query "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\AppModelUnlock"`
 
 Otherwise if `--info` doesn't exist:
 1. `react-native -v`:
diff --git a/change/@office-iss-react-native-win32-2020-04-15-05-17-49-statusbarmanager.json b/change/@office-iss-react-native-win32-2020-04-15-05-17-49-statusbarmanager.json
deleted file mode 100644
index 12f05680cb6..00000000000
--- a/change/@office-iss-react-native-win32-2020-04-15-05-17-49-statusbarmanager.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "type": "prerelease",
-  "comment": "Implelent Shared StatusBarManagerModule and Do Module Cleanup",
-  "packageName": "@office-iss/react-native-win32",
-  "email": "ngerlem@microsoft.com",
-  "dependentChangeType": "patch",
-  "date": "2020-04-15T12:17:45.965Z"
-}
\ No newline at end of file
diff --git a/change/react-native-windows-2020-04-08-09-04-34-direct_debugging_cli.json b/change/react-native-windows-2020-04-08-09-04-34-direct_debugging_cli.json
deleted file mode 100644
index 6e190fdc286..00000000000
--- a/change/react-native-windows-2020-04-08-09-04-34-direct_debugging_cli.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "type": "prerelease",
-  "comment": "Allow enabling of direct debugging through the CLI.",
-  "packageName": "react-native-windows",
-  "email": "12337821+nasadigital@users.noreply.github.com",
-  "dependentChangeType": "patch",
-  "date": "2020-04-08T16:04:34.634Z"
-}
\ No newline at end of file
diff --git a/change/react-native-windows-2020-04-15-05-17-49-statusbarmanager.json b/change/react-native-windows-2020-04-15-05-17-49-statusbarmanager.json
deleted file mode 100644
index b480b1da114..00000000000
--- a/change/react-native-windows-2020-04-15-05-17-49-statusbarmanager.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "type": "prerelease",
-  "comment": "Implelent Shared StatusBarManagerModule and Do Module Cleanup",
-  "packageName": "react-native-windows",
-  "email": "ngerlem@microsoft.com",
-  "dependentChangeType": "patch",
-  "date": "2020-04-15T12:17:49.517Z"
-}
\ No newline at end of file
diff --git a/change/react-native-windows-2020-04-16-08-41-54-appearance-module.json b/change/react-native-windows-2020-04-16-08-41-54-appearance-module.json
deleted file mode 100644
index fe356c2fdee..00000000000
--- a/change/react-native-windows-2020-04-16-08-41-54-appearance-module.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "type": "prerelease",
-  "comment": "Implement AppearanceModule",
-  "packageName": "react-native-windows",
-  "email": "ngerlem@microsoft.com",
-  "dependentChangeType": "patch",
-  "date": "2020-04-16T15:41:54.563Z"
-}
\ No newline at end of file
diff --git a/change/react-native-windows-2020-04-17-10-57-52-x64releaseyoga.json b/change/react-native-windows-2020-04-17-10-57-52-x64releaseyoga.json
deleted file mode 100644
index 06de46f36b9..00000000000
--- a/change/react-native-windows-2020-04-17-10-57-52-x64releaseyoga.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "type": "prerelease",
-  "comment": "Fix issue with yoga layout in x64 release",
-  "packageName": "react-native-windows",
-  "email": "acoates@microsoft.com",
-  "dependentChangeType": "patch",
-  "date": "2020-04-17T17:57:52.347Z"
-}
\ No newline at end of file
diff --git a/change/react-native-windows-2020-04-16-17-40-26-removeAccessibilityStates.json b/change/react-native-windows-2020-04-22-16-22-32-direction-rtl.json
similarity index 63%
rename from change/react-native-windows-2020-04-16-17-40-26-removeAccessibilityStates.json
rename to change/react-native-windows-2020-04-22-16-22-32-direction-rtl.json
index 5339bf2015e..344797ea32a 100644
--- a/change/react-native-windows-2020-04-16-17-40-26-removeAccessibilityStates.json
+++ b/change/react-native-windows-2020-04-22-16-22-32-direction-rtl.json
@@ -1,8 +1,8 @@
 {
   "type": "prerelease",
-  "comment": "remove AccessibilityStates",
+  "comment": "fix RTL",
   "packageName": "react-native-windows",
   "email": "kmelmon@microsoft.com",
   "dependentChangeType": "patch",
-  "date": "2020-04-17T00:40:26.842Z"
+  "date": "2020-04-22T23:22:32.344Z"
 }
\ No newline at end of file
diff --git a/packages/E2ETest/package.json b/packages/E2ETest/package.json
index f4901d96b96..46062c996ec 100644
--- a/packages/E2ETest/package.json
+++ b/packages/E2ETest/package.json
@@ -25,7 +25,7 @@
     "prompt-sync": "^4.2.0",
     "react": "16.9.0",
     "react-native": "0.62.2",
-    "react-native-windows": "0.0.0-master.42",
+    "react-native-windows": "0.0.0-master.46",
     "rnpm-plugin-windows": "^0.6.1"
   },
   "devDependencies": {
diff --git a/packages/E2ETest/wdio/test/DirectManipulation.spec.ts b/packages/E2ETest/wdio/test/DirectManipulation.spec.ts
index 6e97bb96599..bc609af6a41 100644
--- a/packages/E2ETest/wdio/test/DirectManipulation.spec.ts
+++ b/packages/E2ETest/wdio/test/DirectManipulation.spec.ts
@@ -28,9 +28,6 @@ describe('DirectManipulationTest', () => {
       result.includes('width=50'),
       'measureLayout response has correct width'
     );
-    // https://github.com/microsoft/react-native-windows/issues/4122
-    // Un-comment this when bug 4122 is fixed
-    // E2ETEST_OVERRIDE_4122
-    // assert.ok(result.includes('x=20;'), 'measureLayout response x=20');
+    assert.ok(result.includes('x=20;'), 'measureLayout response x=20');
   });
 });
diff --git a/packages/E2ETest/windows/ReactUWPTestApp/App.xaml.cs b/packages/E2ETest/windows/ReactUWPTestApp/App.xaml.cs
index 0a6a8c61fd0..d813eb85f37 100644
--- a/packages/E2ETest/windows/ReactUWPTestApp/App.xaml.cs
+++ b/packages/E2ETest/windows/ReactUWPTestApp/App.xaml.cs
@@ -56,12 +56,6 @@ protected override void OnLaunched(LaunchActivatedEventArgs e)
             base.OnLaunched(e);
             SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility = AppViewBackButtonVisibility.Collapsed;
             ApplicationView.GetForCurrentView().TryResizeView(new Size(800, 600));
-#if !E2ETEST_OVERRIDE_4122
-#error [E2ETest] - There is a bug in Yoga with v142/VS2019 that makes the masters for this app different in Release|x64 than in other platforms.
-#error However we want to test what people will be shipping. As a result, the tree dump output won't match the masters (which have the bug).
-#error You can disable this warning by defining the constant E2ETEST_OVERRIDE_4122 in the project properties page under "Define Constants"
-#error For more information see https://github.com/microsoft/react-native-windows/issues/4122
-#endif
             if (DisplayInformation.GetForCurrentView().ResolutionScale != ResolutionScale.Scale100Percent)
             {
                 throw new Exception("A bug requires this app to run at 100% for accurate results - See https://github.com/microsoft/react-native-windows/issues/4619");
diff --git a/packages/E2ETest/windows/ReactUWPTestApp/ReactUWPTestApp.csproj b/packages/E2ETest/windows/ReactUWPTestApp/ReactUWPTestApp.csproj
index 6611c1e40c4..863452d52a0 100644
--- a/packages/E2ETest/windows/ReactUWPTestApp/ReactUWPTestApp.csproj
+++ b/packages/E2ETest/windows/ReactUWPTestApp/ReactUWPTestApp.csproj
@@ -81,7 +81,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
     <OutputPath>bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP;E2ETEST_OVERRIDE_4122</DefineConstants>
+    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP;</DefineConstants>
     <Optimize>true</Optimize>
     <NoWarn>;2008</NoWarn>
     <DebugType>pdbonly</DebugType>
@@ -174,11 +174,9 @@
     <VisualStudioVersion>16.0</VisualStudioVersion>
   </PropertyGroup>
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.props" />
   <PropertyGroup>
-    <BundleCommand>
-      echo WorkingDir %CD%
-      npx --no-install yarn run bundle
-    </BundleCommand>
+    <BundleEntryFile>dist/app/index.js</BundleEntryFile>
   </PropertyGroup>
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
diff --git a/packages/E2ETest/windows/TreeDumpLibrary/TreeDumpLibrary.csproj b/packages/E2ETest/windows/TreeDumpLibrary/TreeDumpLibrary.csproj
index 7407afba744..6e960869419 100644
--- a/packages/E2ETest/windows/TreeDumpLibrary/TreeDumpLibrary.csproj
+++ b/packages/E2ETest/windows/TreeDumpLibrary/TreeDumpLibrary.csproj
@@ -116,7 +116,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
-      <Version>6.2.8</Version>
+      <Version>6.2.10</Version>
     </PackageReference>
   </ItemGroup>
   <ItemGroup>
diff --git a/packages/microsoft-reactnative-sampleapps/NativeMyModule.js b/packages/microsoft-reactnative-sampleapps/NativeMyModule.js
new file mode 100644
index 00000000000..bb647a3e3d1
--- /dev/null
+++ b/packages/microsoft-reactnative-sampleapps/NativeMyModule.js
@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from 'react-native/Libraries/TurboModule/RCTExport';
+import * as TurboModuleRegistry from 'react-native/Libraries/TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  // Exported methods.
+  +getConstants: () => {|
+    const1: boolean,
+    const2: number,
+    const3: string,
+  |};
+  +voidFunc: () => void;
+  +getBool: (arg: boolean) => boolean;
+  +getNumber: (arg: number) => number;
+  +getString: (arg: string) => string;
+  +getArray: (arg: Array<any>) => Array<any>;
+  +getObject: (arg: Object) => Object;
+  +getValue: (x: number, y: string, z: Object) => Object;
+  +getValueWithCallback: (callback: (value: string) => void) => void;
+  +getValueWithPromise: (error: boolean) => Promise<string>;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>('MyModule'): Spec);
diff --git a/packages/microsoft-reactnative-sampleapps/codegen/NativeModules.g.h b/packages/microsoft-reactnative-sampleapps/codegen/NativeModules.g.h
new file mode 100644
index 00000000000..22d7b869d01
--- /dev/null
+++ b/packages/microsoft-reactnative-sampleapps/codegen/NativeModules.g.h
@@ -0,0 +1,83 @@
+
+/**
+ * This file is auto-generated from a NativeModule spec file in js.
+ */
+
+#pragma once
+
+#include "NativeModules.h"
+#include <tuple>
+
+namespace SampleLibraryCpp {
+
+/*
+ * This is a C++ Spec class that should be used with MakeTurboModuleProvider to register native modules
+ * in a way that also verifies at compile time that the native module matches the interface required
+ * by the TurboModule JS spec.
+ */
+struct MyModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto methods = std::tuple{
+      Method<void() noexcept>{0, L"voidFunc"},
+      SyncMethod<bool(bool) noexcept>{1, L"getBool"},
+      SyncMethod<double(double) noexcept>{2, L"getNumber"},
+      SyncMethod<std::string(std::string) noexcept>{3, L"getString"},
+      SyncMethod<JSValueArray(JSValueArray) noexcept>{4, L"getArray"},
+      SyncMethod<JSValueObject(JSValueObject) noexcept>{5, L"getObject"},
+      SyncMethod<JSValueObject(double,std::string,JSValueObject) noexcept>{6, L"getValue"},
+      Method<void(Callback<JSValue>) noexcept>{7, L"getValueWithCallback"},
+      Method<void(bool,Promise<JSValue>) noexcept>{8, L"getValueWithPromise"},
+  };
+
+  template <class TModule>
+  static constexpr void ValidateModule() noexcept {
+    constexpr auto methodCheckResults = CheckMethods<TModule, MyModuleSpec>();
+
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          0,
+          "voidFunc",
+          "    REACT_METHOD(voidFunc) void voidFunc() noexcept { /* implementation */ }}",
+          "    REACT_METHOD(voidFunc) static void voidFunc() noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          1,
+          "getBool",
+          "    REACT_SYNC_METHOD(getBool) bool getBool(bool arg) noexcept { /* implementation */ }}",
+          "    REACT_SYNC_METHOD(getBool) static bool getBool(bool arg) noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          2,
+          "getNumber",
+          "    REACT_SYNC_METHOD(getNumber) double getNumber(double arg) noexcept { /* implementation */ }}",
+          "    REACT_SYNC_METHOD(getNumber) static double getNumber(double arg) noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          3,
+          "getString",
+          "    REACT_SYNC_METHOD(getString) std::string getString(std::string arg) noexcept { /* implementation */ }}",
+          "    REACT_SYNC_METHOD(getString) static std::string getString(std::string arg) noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          4,
+          "getArray",
+          "    REACT_SYNC_METHOD(getArray) React::JSValueArray getArray(React::JSValueArray && arg) noexcept { /* implementation */ }}",
+          "    REACT_SYNC_METHOD(getArray) static React::JSValueArray getArray(React::JSValueArray && arg) noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          5,
+          "getObject",
+          "    REACT_SYNC_METHOD(getObject) React::JSValueObject getObject(React::JSValueObject && arg) noexcept { /* implementation */ }}",
+          "    REACT_SYNC_METHOD(getObject) static React::JSValueObject getObject(React::JSValueObject && arg) noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          6,
+          "getValue",
+          "    REACT_SYNC_METHOD(getValue) React::JSValueObject getValue(double x, std::string y, React::JSValueObject && z) noexcept { /* implementation */ }}",
+          "    REACT_SYNC_METHOD(getValue) static React::JSValueObject getValue(double x, std::string y, React::JSValueObject && z) noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          7,
+          "getValueWithCallback",
+          "    REACT_METHOD(getValueWithCallback) void getValueWithCallback(std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}",
+          "    REACT_METHOD(getValueWithCallback) static void getValueWithCallback(std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          8,
+          "getValueWithPromise",
+          "    REACT_METHOD(getValueWithPromise) void getValueWithPromise(bool error, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}",
+          "    REACT_METHOD(getValueWithPromise) static void getValueWithPromise(bool error, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}");
+  }
+};
+
+} // namespace SampleLibraryCpp
diff --git a/packages/microsoft-reactnative-sampleapps/index.windows.js b/packages/microsoft-reactnative-sampleapps/index.windows.js
index 8256f7c6253..6adf5cdaf99 100644
--- a/packages/microsoft-reactnative-sampleapps/index.windows.js
+++ b/packages/microsoft-reactnative-sampleapps/index.windows.js
@@ -20,6 +20,8 @@ import { NativeModules, NativeEventEmitter } from 'react-native';
 
 import {MyComp} from './myComp';
 
+import {default as MyModule} from './NativeMyModule';
+
 // Creating event emitters
 const SampleModuleCSEmitter = new NativeEventEmitter(NativeModules.SampleModuleCS);
 const SampleModuleCppEmitter = new NativeEventEmitter(NativeModules.SampleModuleCpp);
@@ -278,6 +280,8 @@ class SampleApp extends Component {
           This app consumes custom Native Modules and View Managers.
         </Text>
 
+        <Button onPress={() => { MyModule.voidFunc(); }} title="Call MyModule tests"/>
+
         <Button onPress={() => { this.onPressSampleModuleCS(); }} title="Call SampleModuleCS!" disabled={NativeModules.SampleModuleCS == null} />
         <Button onPress={() => { this.onPressSampleModuleCpp(); }} title="Call SampleModuleCpp!" disabled={NativeModules.SampleModuleCpp == null} />
 
diff --git a/packages/microsoft-reactnative-sampleapps/just-task.js b/packages/microsoft-reactnative-sampleapps/just-task.js
index df5a61a38b7..9339105da9c 100644
--- a/packages/microsoft-reactnative-sampleapps/just-task.js
+++ b/packages/microsoft-reactnative-sampleapps/just-task.js
@@ -8,6 +8,7 @@
 const {
   task,
   series,
+  parallel,
   option,
   argv,
   tscTask,
@@ -15,6 +16,7 @@ const {
 } = require('just-scripts');
 const fs = require('fs');
 const path = require('path');
+const {execSync} = require('child_process');
 
 option('production');
 option('clean');
@@ -36,6 +38,12 @@ task('ts', () => {
   });
 });
 
+task('codegen', () => {
+  execSync(
+    'npx react-native-windows-codegen --file NativeMyModule.js --namespace SampleLibraryCpp',
+  );
+});
+
 function ensureDirectoryExists(filePath) {
   const dir = path.dirname(filePath);
   if (!fs.existsSync(dir)) {
@@ -49,6 +57,6 @@ task('prepareBundle', () => {
   ensureDirectoryExists('windows/SampleAppCPP/Bundle');
 });
 
-task('build', series('ts'));
+task('build', parallel('ts', 'codegen'));
 task('lint', series('eslint'));
 task('lint:fix', series('eslint:fix'));
diff --git a/packages/microsoft-reactnative-sampleapps/package.json b/packages/microsoft-reactnative-sampleapps/package.json
index 8b3b95431bc..ea125db63e2 100644
--- a/packages/microsoft-reactnative-sampleapps/package.json
+++ b/packages/microsoft-reactnative-sampleapps/package.json
@@ -16,7 +16,7 @@
   "dependencies": {
     "react": "16.9.0",
     "react-native": "0.62.2",
-    "react-native-windows": "0.0.0-master.42",
+    "react-native-windows": "0.0.0-master.46",
     "rnpm-plugin-windows": "^0.6.1"
   },
   "devDependencies": {
@@ -26,6 +26,7 @@
     "@types/react-native": "^0.62.2",
     "just-scripts": "^0.36.1",
     "metro-react-native-babel-preset": "^0.56.0",
+    "react-native-windows-codegen": "0.0.2",
     "react-test-renderer": "16.9.0"
   }
 }
diff --git a/packages/microsoft-reactnative-sampleapps/windows/SampleAppCPP/SampleAppCpp.vcxproj b/packages/microsoft-reactnative-sampleapps/windows/SampleAppCPP/SampleAppCpp.vcxproj
index c18ff844d50..61c4965de7d 100644
--- a/packages/microsoft-reactnative-sampleapps/windows/SampleAppCPP/SampleAppCpp.vcxproj
+++ b/packages/microsoft-reactnative-sampleapps/windows/SampleAppCPP/SampleAppCpp.vcxproj
@@ -41,7 +41,6 @@
   <PropertyGroup>
     <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
   </PropertyGroup>
-  <Import Project="$(ReactNativeWindowsDir)PropertySheets\React.Cpp.props" />
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|ARM">
       <Configuration>Debug</Configuration>
@@ -198,11 +197,7 @@
     <Import Project="..\packages\Microsoft.UI.Xaml.2.3.191129002\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\packages\Microsoft.UI.Xaml.2.3.191129002\build\native\Microsoft.UI.Xaml.targets')" />
     <Import Project="..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets')" />
   </ImportGroup>
-  <PropertyGroup>
-    <BundleCommand>
-      npx --no-install yarn run bundle-cpp
-    </BundleCommand>
-  </PropertyGroup>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.props" />
   <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.Cpp.targets" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
diff --git a/packages/microsoft-reactnative-sampleapps/windows/SampleAppCS/SampleAppCS.csproj b/packages/microsoft-reactnative-sampleapps/windows/SampleAppCS/SampleAppCS.csproj
index 2e97b136b5b..39da02a581d 100644
--- a/packages/microsoft-reactnative-sampleapps/windows/SampleAppCS/SampleAppCS.csproj
+++ b/packages/microsoft-reactnative-sampleapps/windows/SampleAppCS/SampleAppCS.csproj
@@ -174,13 +174,9 @@
   <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '16.0' ">
     <VisualStudioVersion>16.0</VisualStudioVersion>
   </PropertyGroup>
-  <PropertyGroup>
-    <BundleCommand>
-      npx --no-install yarn run bundle-cs
-    </BundleCommand>
-  </PropertyGroup>
-  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.targets" />
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.props" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.cpp b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.cpp
index 8bc8dea706e..58ce16cc054 100644
--- a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.cpp
+++ b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.cpp
@@ -105,18 +105,18 @@ void CustomUserControlViewManagerCpp::UpdateProperties(
 }
 
 // IViewManagerWithCommands
-IMapView<hstring, int64_t> CustomUserControlViewManagerCpp::Commands() noexcept {
-  auto commands = winrt::single_threaded_map<hstring, int64_t>();
-  commands.Insert(L"CustomCommand", 0);
+IVectorView<hstring> CustomUserControlViewManagerCpp::Commands() noexcept {
+  auto commands = winrt::single_threaded_vector<hstring>();
+  commands.Append(L"CustomCommand");
   return commands.GetView();
 }
 
 void CustomUserControlViewManagerCpp::DispatchCommand(
     FrameworkElement const &view,
-    int64_t commandId,
+    winrt::hstring const &commandId,
     IJSValueReader const &commandArgsReader) noexcept {
   if (auto control = view.try_as<winrt::SampleLibraryCpp::CustomUserControlCpp>()) {
-    if (commandId == 0) {
+    if (commandId == L"CustomCommand") {
       std::string arg = std::to_string(winrt::unbox_value<int64_t>(view.Tag()));
       arg.append(", \"");
       arg.append(winrt::to_string(commandArgsReader.GetString()));
diff --git a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.h b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.h
index 8a07bb92ac4..d9e5775e011 100644
--- a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.h
+++ b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/CustomUserControlViewManagerCPP.h
@@ -38,11 +38,11 @@ struct CustomUserControlViewManagerCpp
       winrt::Microsoft::ReactNative::IJSValueReader const &propertyMapReader) noexcept;
 
   // IViewManagerWithCommands
-  winrt::Windows::Foundation::Collections::IMapView<winrt::hstring, int64_t> Commands() noexcept;
+  winrt::Windows::Foundation::Collections::IVectorView<winrt::hstring> Commands() noexcept;
 
   void DispatchCommand(
       winrt::Windows::UI::Xaml::FrameworkElement const &view,
-      int64_t commandId,
+      winrt::hstring const &commandId,
       winrt::Microsoft::ReactNative::IJSValueReader const &commandArgsReader) noexcept;
 
   // IViewManagerWithExportedEventTypeConstants
diff --git a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/MyModule.h b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/MyModule.h
new file mode 100644
index 00000000000..c9d9415ac12
--- /dev/null
+++ b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/MyModule.h
@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "DebugHelpers.h"
+
+#define DEBUG_MYMODULE_OUTPUT(...) DebugWriteLine("MyModule", ##__VA_ARGS__);
+
+namespace SampleLibraryCpp {
+
+REACT_MODULE(MyModule)
+struct MyModule {
+  // The spec file does not currently validate constants
+  REACT_CONSTANT(const1)
+  const bool const1 = true;
+  REACT_CONSTANT(const2)
+  const double const2 = 1.234;
+  REACT_CONSTANT(const3)
+  const std::string const3{"const3"};
+
+  REACT_METHOD(voidFunc)
+  void voidFunc() noexcept {
+    DEBUG_MYMODULE_OUTPUT("voidFunc");
+  }
+
+  REACT_SYNC_METHOD(getBool)
+  bool getBool(bool arg) noexcept {
+    DEBUG_MYMODULE_OUTPUT("getBool", arg);
+    return arg;
+  }
+
+  REACT_SYNC_METHOD(getNumber)
+  double getNumber(double arg) noexcept {
+    DEBUG_MYMODULE_OUTPUT("getNumber", arg);
+    return arg;
+  }
+
+  REACT_SYNC_METHOD(getString)
+  std::string getString(std::string arg) noexcept {
+    DEBUG_MYMODULE_OUTPUT("getString", arg);
+    return arg;
+  }
+
+  REACT_SYNC_METHOD(getArray)
+  React::JSValueArray getArray(React::JSValueArray && /*arg*/) noexcept {
+    return React::JSValueArray{"X", 4, true};
+  }
+
+  REACT_SYNC_METHOD(getObject)
+  React::JSValueObject getObject(React::JSValueObject && /*arg*/) noexcept {
+    return React::JSValueObject{{"X", 4}, {"Y", 2}};
+  }
+
+  REACT_SYNC_METHOD(getValue)
+  React::JSValueObject getValue(double x, std::string y, JSValueObject &&z) noexcept {
+    return React::JSValueObject{{"X", x}, {"Y", y}, {"Z", std::move(z)}};
+  }
+
+  REACT_METHOD(getValueWithCallback)
+  void getValueWithCallback(std::function<void(React::JSValue const &)> const &callback) noexcept {
+    callback(React::JSValue{"some string"});
+  }
+
+  REACT_METHOD(getValueWithPromise)
+  void getValueWithPromise(bool error, React::ReactPromise<React::JSValue> &&result) noexcept {
+    if (error) {
+      result.Reject("Failure");
+    } else {
+      result.Resolve(React::JSValue{"Succeeded"});
+    }
+  }
+};
+
+} // namespace SampleLibraryCpp
diff --git a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/ReactPackageProvider.cpp b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/ReactPackageProvider.cpp
index ec971e59149..c7dd9c8c335 100644
--- a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/ReactPackageProvider.cpp
+++ b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/ReactPackageProvider.cpp
@@ -11,12 +11,21 @@
 #include "CustomUserControlViewManagerCpp.h"
 #include "SampleModuleCpp.h"
 
+// Import generated definitions
+#include "..\..\codegen\NativeModules.g.h"
+
+// Import impls of modules
+#include "MyModule.h"
+
 using namespace winrt::Microsoft::ReactNative;
 
 namespace winrt::SampleLibraryCpp::implementation {
 
 void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept {
   AddAttributedModules(packageBuilder);
+
+  packageBuilder.AddModule(
+      L"MyModule", MakeTurboModuleProvider<::SampleLibraryCpp::MyModule, ::SampleLibraryCpp::MyModuleSpec>());
   packageBuilder.AddViewManager(
       L"CustomUserControlViewManagerCpp", []() { return winrt::make<CustomUserControlViewManagerCpp>(); });
   packageBuilder.AddViewManager(L"CircleViewManagerCpp", []() { return winrt::make<CircleViewManagerCpp>(); });
diff --git a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/SampleLibraryCPP.vcxproj b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/SampleLibraryCPP.vcxproj
index 444db48e6bc..bb3b37cbd45 100644
--- a/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/SampleLibraryCPP.vcxproj
+++ b/packages/microsoft-reactnative-sampleapps/windows/SampleLibraryCPP/SampleLibraryCPP.vcxproj
@@ -17,7 +17,6 @@
     <WindowsTargetPlatformMinVersion>10.0.16299.0</WindowsTargetPlatformMinVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <Import Project="$(ReactNativeWindowsDir)PropertySheets\React.Cpp.props" />
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|ARM">
       <Configuration>Debug</Configuration>
diff --git a/packages/override-tools/src/Manifest.ts b/packages/override-tools/src/Manifest.ts
index 78e872cf3d3..3c362767642 100644
--- a/packages/override-tools/src/Manifest.ts
+++ b/packages/override-tools/src/Manifest.ts
@@ -242,7 +242,8 @@ export default class Manifest {
    */
   static hashContent(str: string) {
     const hasher = crypto.createHash('sha1');
-    hasher.update(str);
+    const normalizedStr = str.replace(/(?<!\r)\n/g, '\r\n');
+    hasher.update(normalizedStr);
     return hasher.digest('hex');
   }
 
diff --git a/packages/playground/Samples/mouse.tsx b/packages/playground/Samples/mouse.tsx
index f55251e60b3..455947f7ada 100644
--- a/packages/playground/Samples/mouse.tsx
+++ b/packages/playground/Samples/mouse.tsx
@@ -11,6 +11,7 @@ import {
   Text,
   GestureResponderEvent,
   TouchableHighlight,
+  BackHandler,
 } from 'react-native';
 
 export default class Bootstrap extends React.Component<
@@ -32,6 +33,10 @@ export default class Bootstrap extends React.Component<
     };
   }
 
+  componentDidMount() {
+    BackHandler.addEventListener('hardwareBackPress', this.back);
+  }
+
   render() {
     return (
       <View
@@ -115,6 +120,10 @@ export default class Bootstrap extends React.Component<
     console.log('pressout');
     console.log(event);
   };
+  back = () => {
+    console.log('hardwareBackPress');
+    return true;
+  };
 }
 
 const styles = StyleSheet.create({
diff --git a/packages/playground/package.json b/packages/playground/package.json
index 67ec25b6364..99dffded717 100644
--- a/packages/playground/package.json
+++ b/packages/playground/package.json
@@ -11,7 +11,7 @@
   "dependencies": {
     "react": "16.9.0",
     "react-native": "0.62.2",
-    "react-native-windows": "0.0.0-master.42"
+    "react-native-windows": "0.0.0-master.46"
   },
   "devDependencies": {
     "@babel/core": "^7.8.4",
diff --git a/packages/playground/windows/.gitignore b/packages/playground/windows/.gitignore
index 4ea0c7b5a35..cdb229b3b3a 100644
--- a/packages/playground/windows/.gitignore
+++ b/packages/playground/windows/.gitignore
@@ -90,3 +90,4 @@ packages/
 #Files generated by the VS build
 **/Generated Files/**
 
+playground/Bundle
diff --git a/packages/playground/windows/playground/Bundle/.gitignore b/packages/playground/windows/playground/Bundle/.gitignore
deleted file mode 100644
index d6b7ef32c84..00000000000
--- a/packages/playground/windows/playground/Bundle/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*
-!.gitignore
diff --git a/packages/playground/windows/playground/Playground.vcxproj b/packages/playground/windows/playground/Playground.vcxproj
index b88008699a6..b4f37c4a9e6 100644
--- a/packages/playground/windows/playground/Playground.vcxproj
+++ b/packages/playground/windows/playground/Playground.vcxproj
@@ -171,13 +171,11 @@
   </ItemGroup>
 
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.props" />
   <PropertyGroup>
-    <BundleCommand>
-      npx --no-install react-native bundle --platform windows --entry-file Samples/rntester.tsx --bundle-output $(MSBuildThisFileDirectory)/Bundle/index.windows.bundle --assets-dest $(MSBuildThisFileDirectory)/Bundle
-    </BundleCommand>
-    <AppxPackageSigningEnabled>True</AppxPackageSigningEnabled>
+    <BundleEntryFile>Samples/rntester.tsx</BundleEntryFile>
   </PropertyGroup>
-  <Import Project="..\..\..\..\vnext\PropertySheets\Bundle.Cpp.targets" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
     <Import Project="..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets')" />
     <Import Project="..\packages\Microsoft.UI.Xaml.2.3.191129002\build\native\Microsoft.UI.Xaml.targets" Condition="Exists('..\packages\Microsoft.UI.Xaml.2.3.191129002\build\native\Microsoft.UI.Xaml.targets')" />
diff --git a/packages/react-native-win32/CHANGELOG.json b/packages/react-native-win32/CHANGELOG.json
index ff298ee9b21..3c83cf0780f 100644
--- a/packages/react-native-win32/CHANGELOG.json
+++ b/packages/react-native-win32/CHANGELOG.json
@@ -1,6 +1,21 @@
 {
   "name": "@office-iss/react-native-win32",
   "entries": [
+    {
+      "date": "Sat, 18 Apr 2020 00:04:34 GMT",
+      "tag": "@office-iss/react-native-win32_v0.0.0-master.6",
+      "version": "0.0.0-master.6",
+      "comments": {
+        "prerelease": [
+          {
+            "comment": "Implelent Shared StatusBarManagerModule and Do Module Cleanup",
+            "author": "ngerlem@microsoft.com",
+            "commit": "609c18ca016e9e4b5831890bad56309f02280566",
+            "package": "@office-iss/react-native-win32"
+          }
+        ]
+      }
+    },
     {
       "date": "Wed, 15 Apr 2020 22:26:36 GMT",
       "tag": "@office-iss/react-native-win32_v0.0.0-master.5",
diff --git a/packages/react-native-win32/CHANGELOG.md b/packages/react-native-win32/CHANGELOG.md
index 31e1fdfcde8..15432ae1647 100644
--- a/packages/react-native-win32/CHANGELOG.md
+++ b/packages/react-native-win32/CHANGELOG.md
@@ -1,9 +1,17 @@
 # Change Log - @office-iss/react-native-win32
 
-This log was last generated on Wed, 15 Apr 2020 22:26:36 GMT and should not be manually modified.
+This log was last generated on Sat, 18 Apr 2020 00:04:34 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.0.0-master.6
+
+Sat, 18 Apr 2020 00:04:34 GMT
+
+### Changes
+
+- Implelent Shared StatusBarManagerModule and Do Module Cleanup (ngerlem@microsoft.com)
+
 ## 0.0.0-master.5
 
 Wed, 15 Apr 2020 22:26:36 GMT
diff --git a/packages/react-native-win32/package.json b/packages/react-native-win32/package.json
index 663285b48d4..9f18e975354 100644
--- a/packages/react-native-win32/package.json
+++ b/packages/react-native-win32/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@office-iss/react-native-win32",
-  "version": "0.0.0-master.5",
+  "version": "0.0.0-master.6",
   "description": "Implementation of react native on top of Office's Win32 platform.",
   "license": "MIT",
   "main": "./index.win32.js",
diff --git a/packages/react-native-windows-codegen/.gitignore b/packages/react-native-windows-codegen/.gitignore
new file mode 100644
index 00000000000..f42efbb9f7c
--- /dev/null
+++ b/packages/react-native-windows-codegen/.gitignore
@@ -0,0 +1,2 @@
+lib/
+lib-commonjs/
diff --git a/packages/react-native-windows-codegen/CHANGELOG.json b/packages/react-native-windows-codegen/CHANGELOG.json
new file mode 100644
index 00000000000..c708783e949
--- /dev/null
+++ b/packages/react-native-windows-codegen/CHANGELOG.json
@@ -0,0 +1,20 @@
+{
+  "name": "react-native-windows-codegen",
+  "entries": [
+    {
+      "date": "Thu, 23 Apr 2020 00:04:37 GMT",
+      "tag": "react-native-windows-codegen_v0.0.2",
+      "version": "0.0.2",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Initial react-native-windows-codegen",
+            "author": "acoates@microsoft.com",
+            "commit": "dcccb2c4d84ff530de5a80ac7e947c3287dff5ab",
+            "package": "react-native-windows-codegen"
+          }
+        ]
+      }
+    }
+  ]
+}
diff --git a/packages/react-native-windows-codegen/CHANGELOG.md b/packages/react-native-windows-codegen/CHANGELOG.md
new file mode 100644
index 00000000000..2ca2fe760aa
--- /dev/null
+++ b/packages/react-native-windows-codegen/CHANGELOG.md
@@ -0,0 +1,13 @@
+# Change Log - react-native-windows-codegen
+
+This log was last generated on Thu, 23 Apr 2020 00:04:37 GMT and should not be manually modified.
+
+<!-- Start content -->
+
+## 0.0.2
+
+Thu, 23 Apr 2020 00:04:37 GMT
+
+### Patches
+
+- Initial react-native-windows-codegen (acoates@microsoft.com)
diff --git a/packages/react-native-windows-codegen/README.md b/packages/react-native-windows-codegen/README.md
new file mode 100644
index 00000000000..2950bcd0969
--- /dev/null
+++ b/packages/react-native-windows-codegen/README.md
@@ -0,0 +1,7 @@
+# react-native-windows-codegen
+
+Generators for react-native-codegen targeting react-native-windows
+
+## Usage
+
+Coming soon..
diff --git a/packages/react-native-windows-codegen/bin.js b/packages/react-native-windows-codegen/bin.js
new file mode 100644
index 00000000000..24e308197b6
--- /dev/null
+++ b/packages/react-native-windows-codegen/bin.js
@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+
+// Yarn will fail to link workspace binaries if they haven't been built yet. Add
+// a simple JS file to forward to the CLI which is built after install.
+require('./lib-commonjs/Cli');
diff --git a/packages/react-native-windows-codegen/just-task.js b/packages/react-native-windows-codegen/just-task.js
new file mode 100644
index 00000000000..f5fac08c7f8
--- /dev/null
+++ b/packages/react-native-windows-codegen/just-task.js
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ * @ts-check
+ */
+
+const {eslintTask, series, task, taskPresets} = require('just-scripts');
+
+taskPresets.lib();
+
+task('eslint', () => {
+  return eslintTask();
+});
+task('eslint:fix', () => {
+  return eslintTask({fix: true});
+});
+task('lint', series('eslint'));
+task('lint:fix', series('eslint:fix'));
diff --git a/packages/react-native-windows-codegen/package.json b/packages/react-native-windows-codegen/package.json
new file mode 100644
index 00000000000..bc8ee786b23
--- /dev/null
+++ b/packages/react-native-windows-codegen/package.json
@@ -0,0 +1,29 @@
+{
+  "name": "react-native-windows-codegen",
+  "version": "0.0.2",
+  "description": "Generators for react-native-codegen targeting react-native-windows",
+  "main": "index.js",
+  "repository": "https://github.com/microsoft/react-native-windows",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "build": "just-scripts build",
+    "clean": "just-scripts clean",
+    "lint": "just-scripts lint",
+    "lint:fix": "just-scripts lint:fix"
+  },
+  "bin": {
+    "react-native-windows-codegen": "./bin.js"
+  },
+  "dependencies": {
+    "chalk": "^3",
+    "react-native-tscodegen": "0.0.10",
+    "react-native-codegen": "0.0.2",
+    "yargs": "^15.1.0"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.2.0",
+    "@types/yargs": "^15.0.3",
+    "just-scripts": "^0.36.1"
+  }
+}
diff --git a/packages/react-native-windows-codegen/src/Cli.ts b/packages/react-native-windows-codegen/src/Cli.ts
new file mode 100644
index 00000000000..d8ea11a57dd
--- /dev/null
+++ b/packages/react-native-windows-codegen/src/Cli.ts
@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+
+import * as yargs from 'yargs';
+import * as path from 'path';
+import * as fs from 'fs';
+import {createNM2Generator} from './generators/GenerateNM2';
+// @ts-ignore
+import {parseFile} from 'react-native-tscodegen/lib/rncodegen/src/parsers/flow';
+// @ts-ignore
+import * as schemaValidator from 'react-native-tscodegen/lib/rncodegen/src/schemaValidator';
+
+const argv = yargs.options({
+  file: {
+    type: 'string',
+    describe: 'file which contains spec',
+  },
+  test: {
+    type: 'boolean',
+    describe: 'Verify that the generated output is unchanged',
+  },
+  namespace: {
+    type: 'string',
+    describe: 'C++/C# Namespace to put generated native modules in',
+    default: 'MyNamespace',
+  },
+}).argv;
+
+import {SchemaType} from 'react-native-tscodegen';
+
+interface Options {
+  libraryName: string;
+  schema: SchemaType;
+  outputDirectory: string;
+  moduleSpecName: string;
+}
+
+interface Config {
+  generators: any[] /*Generators[]*/;
+  test?: boolean;
+}
+
+/*
+const GENERATORS = {
+  descriptors: [generateComponentDescriptorH.generate],
+  events: [
+    generateEventEmitterCpp.generate,
+    generateEventEmitterH.generate,
+    generateModuleHObjCpp.generate,
+    generateModuleMm.generate,
+  ],
+  props: [
+    generateComponentHObjCpp.generate,
+    generatePropsCpp.generate,
+    generatePropsH.generate,
+    generatePropsJavaInterface.generate,
+    generatePropsJavaDelegate.generate,
+  ],
+  modules: [generateModuleCpp.generate, generateModuleH.generate],
+  tests: [generateTests.generate],
+  'shadow-nodes': [
+    generateShadowNodeCpp.generate,
+    generateShadowNodeH.generate,
+  ],
+};
+*/
+
+function checkFilesForChanges(
+  map: Map<string, string>,
+  outputDir: string,
+): boolean {
+  map.forEach((contents: string, fileName: string) => {
+    const location = path.join(outputDir, fileName);
+    if (!fs.existsSync(location)) {
+      return true;
+    }
+
+    const currentContents = fs.readFileSync(location, 'utf8');
+    if (currentContents !== contents) {
+      console.error(`- ${fileName} has changed`);
+      return true;
+    }
+  });
+
+  return false;
+}
+
+function writeMapToFiles(map: Map<string, string>, outputDir: string) {
+  let success = true;
+  map.forEach((contents: string, fileName: string) => {
+    try {
+      const location = path.join(outputDir, fileName);
+      fs.writeFileSync(location, contents);
+    } catch (error) {
+      success = false;
+      console.error(`Failed to write ${fileName} to ${outputDir}`, error);
+    }
+  });
+
+  return success;
+}
+
+function generate(
+  {libraryName, schema, outputDirectory, moduleSpecName}: Options,
+  {/*generators,*/ test}: Config,
+): boolean {
+  schemaValidator.validate(schema);
+
+  const generatedFiles = [];
+  /*
+  for (const name of generators) {
+    for (const generator of GENERATORS[name]) {
+      generatedFiles.push(...generator(libraryName, schema, moduleSpecName));
+    }
+  }
+*/
+
+  const generateNM2 = createNM2Generator({namespace: argv.namespace});
+
+  generatedFiles.push(...generateNM2(libraryName, schema, moduleSpecName));
+
+  const filesToUpdate = new Map<string, string>([...generatedFiles]);
+
+  if (test === true) {
+    return checkFilesForChanges(filesToUpdate, outputDirectory);
+  }
+
+  return writeMapToFiles(filesToUpdate, outputDirectory);
+}
+
+const schema: SchemaType = parseFile(argv.file);
+const libraryName = 'libraryName';
+const moduleSpecName = 'moduleSpecName';
+const outputDirectory = 'codegen';
+generate(
+  {libraryName, schema, outputDirectory, moduleSpecName},
+  {generators: [], test: false},
+);
diff --git a/packages/react-native-windows-codegen/src/generators/GenerateNM2.ts b/packages/react-native-windows-codegen/src/generators/GenerateNM2.ts
new file mode 100644
index 00000000000..190e09c6821
--- /dev/null
+++ b/packages/react-native-windows-codegen/src/generators/GenerateNM2.ts
@@ -0,0 +1,305 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import {
+  SchemaType,
+  MethodTypeShape,
+  // FunctionTypeAnnotation,
+  FunctionTypeAnnotationParam,
+  FunctionTypeAnnotationParamTypeAnnotation,
+  FunctionTypeAnnotationReturn,
+} from 'react-native-tscodegen';
+
+type FilesOutput = Map<string, string>;
+
+const moduleTemplate = `
+/*
+ * This is a C++ Spec class that should be used with MakeTurboModuleProvider to register native modules
+ * in a way that also verifies at compile time that the native module matches the interface required
+ * by the TurboModule JS spec.
+ */
+struct ::_MODULE_NAME_::Spec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto methods = std::tuple{
+::_MODULE_PROPERTIES_TUPLE_::
+  };
+
+  template <class TModule>
+  static constexpr void ValidateModule() noexcept {
+    constexpr auto methodCheckResults = CheckMethods<TModule, ::_MODULE_NAME_::Spec>();
+
+::_MODULE_PROPERTIES_SPEC_ERRORS_::
+  }
+};`;
+
+const template = `
+/**
+ * This file is auto-generated from a NativeModule spec file in js.
+ */
+
+#pragma once
+
+#include "NativeModules.h"
+#include <tuple>
+
+namespace ::_NAMESPACE_:: {
+::_MODULES_::
+
+} // namespace ::_NAMESPACE_::
+`;
+
+function translateSpecFunctionParam(
+  param: FunctionTypeAnnotationParam,
+): string {
+  switch (param.typeAnnotation.type) {
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'FunctionTypeAnnotation': {
+      // Ideally we'd get more information about the expected parameters of the callback
+      // But the current schema doesn't seem to provide the necessary information.
+      return 'Callback<JSValue>';
+    }
+    case 'ArrayTypeAnnotation':
+      // Ideally we'd get more information about the expected type of the array
+      // But the current schema doesn't seem to provide the necessary information.
+      return 'JSValueArray';
+    case 'GenericObjectTypeAnnotation':
+      return 'JSValueObject';
+    default:
+      throw new Error(`Unhandled type: ${param.typeAnnotation.type}`);
+  }
+}
+
+function translateFunctionParam(param: FunctionTypeAnnotationParam): string {
+  switch (param.typeAnnotation.type) {
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'FunctionTypeAnnotation': {
+      // Ideally we'd get more information about the expected parameters of the callback
+      // But the current schema doesn't seem to provide the necessary information.
+      return 'std::function<void(React::JSValue const &)> const &';
+    }
+    case 'ArrayTypeAnnotation':
+      // Ideally we'd get more information about the expected type of the array
+      // But the current schema doesn't seem to provide the necessary information.
+      return 'React::JSValueArray &&';
+    case 'GenericObjectTypeAnnotation':
+      return 'React::JSValueObject &&';
+    default:
+      throw new Error(`Unhandled type: ${param.typeAnnotation.type}`);
+  }
+}
+
+function translateSpecReturnType(
+  type:
+    | FunctionTypeAnnotationParamTypeAnnotation
+    | FunctionTypeAnnotationReturn,
+) {
+  switch (type.type) {
+    case 'VoidTypeAnnotation':
+      return 'void';
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'GenericPromiseTypeAnnotation':
+      return 'void';
+    case 'ArrayTypeAnnotation':
+      // Ideally we'd get more information about the expected type of the array
+      // But the current schema doesn't seem to provide the necessary information.
+      return 'JSValueArray';
+    case 'GenericObjectTypeAnnotation':
+      return 'JSValueObject';
+    default:
+      throw new Error(`Unhandled type: ${type.type}`);
+  }
+}
+
+function translateImplReturnType(
+  type:
+    | FunctionTypeAnnotationParamTypeAnnotation
+    | FunctionTypeAnnotationReturn,
+) {
+  switch (type.type) {
+    case 'VoidTypeAnnotation':
+      return 'void';
+    case 'StringTypeAnnotation':
+      return 'std::string';
+    case 'NumberTypeAnnotation':
+    case 'FloatTypeAnnotation':
+      return 'double';
+    case 'Int32TypeAnnotation':
+      return 'int';
+    case 'BooleanTypeAnnotation':
+      return 'bool';
+    case 'GenericPromiseTypeAnnotation':
+      return 'void';
+    case 'ArrayTypeAnnotation':
+      // Ideally we'd get more information about the expected type of the array
+      // But the current schema doesn't seem to provide the necessary information.
+      return 'React::JSValueArray';
+    case 'GenericObjectTypeAnnotation':
+      return 'React::JSValueObject';
+    default:
+      throw new Error(`Unhandled type: ${type.type}`);
+  }
+}
+
+function translateSpecArgs(params: ReadonlyArray<FunctionTypeAnnotationParam>) {
+  return params.map(param => {
+    const translatedParam = translateSpecFunctionParam(param);
+    return `${translatedParam}`;
+  });
+}
+
+function translateArgs(params: ReadonlyArray<FunctionTypeAnnotationParam>) {
+  return params.map(param => {
+    const translatedParam = translateFunctionParam(param);
+    return `${translatedParam} ${param.name}`;
+  });
+}
+
+function isMethodSync(prop: MethodTypeShape) {
+  return (
+    prop.typeAnnotation.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
+    prop.typeAnnotation.returnTypeAnnotation.type !==
+      'GenericPromiseTypeAnnotation'
+  );
+}
+
+function isPromise(prop: MethodTypeShape) {
+  return (
+    prop.typeAnnotation.returnTypeAnnotation.type ===
+    'GenericPromiseTypeAnnotation'
+  );
+}
+
+function getPossibleMethodSignatures(prop: MethodTypeShape): string[] {
+  let args = translateArgs(prop.typeAnnotation.params);
+  if (isPromise(prop)) {
+    // Sadly, currently, the schema doesn't currently provide us information on the type of the promise.
+    args.push('React::ReactPromise<React::JSValue> &&result');
+  }
+
+  // TODO be much more exhastive on the possible method signatures that can be used..
+  let sig = `REACT_${isMethodSync(prop) ? 'SYNC_' : ''}METHOD(${
+    prop.name
+  }) ${translateImplReturnType(prop.typeAnnotation.returnTypeAnnotation)} ${
+    prop.name
+  }(${args.join(', ')}) noexcept { /* implementation */ }}`;
+  let staticsig = `REACT_${isMethodSync(prop) ? 'SYNC_' : ''}METHOD(${
+    prop.name
+  }) static ${translateImplReturnType(
+    prop.typeAnnotation.returnTypeAnnotation,
+  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }}`;
+
+  return [sig, staticsig];
+}
+
+function translatePossibleMethodSignatures(prop: MethodTypeShape): string {
+  return getPossibleMethodSignatures(prop)
+    .map(sig => `"    ${sig}"`)
+    .join(',\n          ');
+}
+
+function renderProperties(
+  properties: ReadonlyArray<MethodTypeShape>,
+  tuple: boolean,
+): string {
+  // We skip the constants for now, since we dont have Spec file validation of them.
+  return properties
+    .filter(prop => prop.name !== 'getConstants')
+    .map((prop, index) => {
+      let params = prop.typeAnnotation.params;
+
+      const traversedArgs = translateSpecArgs(params);
+
+      const translatedReturnParam = translateSpecReturnType(
+        prop.typeAnnotation.returnTypeAnnotation,
+      );
+
+      if (isPromise(prop)) {
+        // Sadly, currently, the schema doesn't currently provide us information on the type of the promise.
+        traversedArgs.push('Promise<JSValue>');
+      }
+
+      if (tuple) {
+        return `      ${
+          isMethodSync(prop) ? 'Sync' : ''
+        }Method<${translatedReturnParam}(${traversedArgs.join(
+          ',',
+        )}) noexcept>{${index}, L"${prop.name}"},`;
+      } else {
+        return `    REACT_SHOW_METHOD_SPEC_ERRORS(
+          ${index},
+          "${prop.name}",
+          ${translatePossibleMethodSignatures(prop)});`;
+      }
+    })
+    .join('\n');
+}
+
+export function createNM2Generator({namespace}: {namespace: string}) {
+  return (
+    _libraryName: string,
+    schema: SchemaType,
+    _moduleSpecName: string,
+  ): FilesOutput => {
+    // console.log(JSON.stringify(schema, null, 2));
+
+    const nativeModules = Object.keys(schema.modules)
+      .map(moduleName => {
+        const modules = schema.modules[moduleName].nativeModules;
+        if (modules == null) {
+          return null;
+        }
+
+        return modules;
+      })
+      .filter(Boolean)
+      .reduce((acc, components) => Object.assign(acc, components), {});
+
+    const modules = Object.keys(nativeModules)
+      .map(name => {
+        const {properties} = nativeModules[name];
+        const traversedProperties = renderProperties(properties, false);
+        const traversedPropertyTuples = renderProperties(properties, true);
+
+        return moduleTemplate
+          .replace(/::_MODULE_PROPERTIES_TUPLE_::/g, traversedPropertyTuples)
+          .replace(/::_MODULE_PROPERTIES_SPEC_ERRORS_::/g, traversedProperties)
+          .replace(/::_MODULE_NAME_::/g, name);
+      })
+      .join('\n');
+
+    const fileName = 'NativeModules.g.h';
+    const replacedTemplate = template
+      .replace(/::_NAMESPACE_::/g, namespace)
+      .replace(/::_MODULES_::/g, modules);
+
+    return new Map([[fileName, replacedTemplate]]);
+  };
+}
diff --git a/packages/react-native-windows-codegen/tsconfig.json b/packages/react-native-windows-codegen/tsconfig.json
new file mode 100644
index 00000000000..955be039942
--- /dev/null
+++ b/packages/react-native-windows-codegen/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "es6",
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "preserveConstEnums": true,
+    "moduleResolution": "node",
+    "noUnusedLocals": true,
+    "skipLibCheck": true,
+    "rootDirs": ["src"],
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}
diff --git a/packages/react-native-windows-init/CHANGELOG.json b/packages/react-native-windows-init/CHANGELOG.json
index 86d5d71e492..779d63823f0 100644
--- a/packages/react-native-windows-init/CHANGELOG.json
+++ b/packages/react-native-windows-init/CHANGELOG.json
@@ -1,6 +1,21 @@
 {
   "name": "react-native-windows-init",
   "entries": [
+    {
+      "date": "Wed, 22 Apr 2020 00:04:29 GMT",
+      "tag": "react-native-windows-init_v0.1.5",
+      "version": "0.1.5",
+      "comments": {
+        "patch": [
+          {
+            "comment": "Fix react-native-windows-init to work with tags (@master)",
+            "author": "acoates@microsoft.com",
+            "commit": "a34e2169b7a0224cd2486fab5bd224077234d5d5",
+            "package": "react-native-windows-init"
+          }
+        ]
+      }
+    },
     {
       "date": "Tue, 07 Apr 2020 18:46:38 GMT",
       "tag": "react-native-windows-init_v0.1.4",
diff --git a/packages/react-native-windows-init/CHANGELOG.md b/packages/react-native-windows-init/CHANGELOG.md
index 27c98ceb7fa..4858be37ae3 100644
--- a/packages/react-native-windows-init/CHANGELOG.md
+++ b/packages/react-native-windows-init/CHANGELOG.md
@@ -1,9 +1,17 @@
 # Change Log - react-native-windows-init
 
-This log was last generated on Tue, 07 Apr 2020 18:46:38 GMT and should not be manually modified.
+This log was last generated on Wed, 22 Apr 2020 00:04:29 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.1.5
+
+Wed, 22 Apr 2020 00:04:29 GMT
+
+### Patches
+
+- Fix react-native-windows-init to work with tags (@master) (acoates@microsoft.com)
+
 ## 0.1.4
 
 Tue, 07 Apr 2020 18:46:38 GMT
diff --git a/packages/react-native-windows-init/package.json b/packages/react-native-windows-init/package.json
index b036c590e4c..362c27f21be 100644
--- a/packages/react-native-windows-init/package.json
+++ b/packages/react-native-windows-init/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows-init",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "CLI to add react-native-windows to an existing react-native project",
   "main": "index.js",
   "repository": "https://github.com/microsoft/react-native-windows",
diff --git a/packages/react-native-windows-init/src/Cli.ts b/packages/react-native-windows-init/src/Cli.ts
index 42c4bd320a4..512a797113a 100644
--- a/packages/react-native-windows-init/src/Cli.ts
+++ b/packages/react-native-windows-init/src/Cli.ts
@@ -8,7 +8,7 @@
 import * as yargs from 'yargs';
 import * as fs from 'fs';
 import * as semver from 'semver';
-import {execSync} from 'child_process';
+import {exec, execSync} from 'child_process';
 import * as validUrl from 'valid-url';
 import * as prompts from 'prompts';
 import * as findUp from 'find-up';
@@ -171,22 +171,38 @@ function getLatestMatchingVersion(
         },
       );
     } else {
-      // Assume that versionSemVer is actually a tag
-      npm.packages.release(
-        pkg,
-        versionSemVer,
-        (err: any, details: {version: string}[]) => {
-          if (err) {
-            reject(err);
-          } else if (details && details.length > 0) {
-            resolve(details[0].version);
-            return;
-          }
-          reject(
-            new Error(`No matching version of ${pkg}@${versionSemVer} found`),
-          );
-        },
-      );
+      try {
+        exec(
+          `npm info ${pkg}@${versionSemVer} version --json`,
+          (err, stdout, _stderr) => {
+            try {
+              if (!err) {
+                let candidates = JSON.parse(stdout);
+                if (typeof candidates === 'string') {
+                  resolve(candidates);
+                  return;
+                }
+                candidates = candidates.sort(semver.rcompare);
+                if (candidates && candidates.length > 0) {
+                  resolve(candidates[0]);
+                  return;
+                }
+              }
+              reject(
+                new Error(
+                  `No matching version of ${pkg}@${versionSemVer} found`,
+                ),
+              );
+            } catch (e) {
+              reject(e);
+            }
+          },
+        );
+      } catch (err) {
+        reject(
+          new Error(`No matching version of ${pkg}@${versionSemVer} found`),
+        );
+      }
     }
   });
 }
diff --git a/vnext/CHANGELOG.json b/vnext/CHANGELOG.json
index aaa03fcc7b3..c709b9e000e 100644
--- a/vnext/CHANGELOG.json
+++ b/vnext/CHANGELOG.json
@@ -1,6 +1,126 @@
 {
   "name": "react-native-windows",
   "entries": [
+    {
+      "date": "Thu, 23 Apr 2020 00:04:37 GMT",
+      "tag": "react-native-windows_v0.0.0-master.46",
+      "version": "0.0.0-master.46",
+      "comments": {
+        "prerelease": [
+          {
+            "comment": "Hook up to packager websocket to allow 'r' to reload instance",
+            "author": "acoates@microsoft.com",
+            "commit": "2fad67bf25bc6eff90417cff91493d9479db5076",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Handle syntax errors in RedBox",
+            "author": "asklar@microsoft.com",
+            "commit": "16a4ede863a147bf2b473b1eb3b85e6b19c3cb72",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Publish ship and debug bits in the nuget",
+            "author": "acoates@microsoft.com",
+            "commit": "b35cc97adef395d7b9886425ef3b12ccd5cec6ee",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Implement String ViewManager Command IDs",
+            "author": "ngerlem@microsoft.com",
+            "commit": "509b9e5a57f6d032f2422ead1e09207f10855cbd",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 22 Apr 2020 00:04:29 GMT",
+      "tag": "react-native-windows_v0.0.0-master.45",
+      "version": "0.0.0-master.45",
+      "comments": {
+        "prerelease": [
+          {
+            "comment": "Make default template build non-dev bundle when not using debug configuration",
+            "author": "acoates@microsoft.com",
+            "commit": "5c98e236066ced8eb314fae9995c288cb2eee798",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Implemented C++ TurboModule compile time spec validation",
+            "author": "vmorozov@microsoft.com",
+            "commit": "21dea64efa55d0cc23d0ad0e33a058b0e3981800",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Fix devtools connection to match RN0.62",
+            "author": "acoates@microsoft.com",
+            "commit": "c779043f0dd5e57f66b7609a8a09270aa78ad1b7",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Sun, 19 Apr 2020 00:04:29 GMT",
+      "tag": "react-native-windows_v0.0.0-master.44",
+      "version": "0.0.0-master.44",
+      "comments": {
+        "prerelease": [
+          {
+            "comment": "fix include paths",
+            "author": "kmelmon@microsoft.com",
+            "commit": "52bf9690a1e48d18f8d36c3f8de8aaa95fdd174a",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Sat, 18 Apr 2020 00:04:34 GMT",
+      "tag": "react-native-windows_v0.0.0-master.43",
+      "version": "0.0.0-master.43",
+      "comments": {
+        "prerelease": [
+          {
+            "comment": "Allow enabling of direct debugging through the CLI.",
+            "author": "12337821+nasadigital@users.noreply.github.com",
+            "commit": "c1a2140928b37d9c761c41bfa0fcc38704a14099",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Implelent Shared StatusBarManagerModule and Do Module Cleanup",
+            "author": "ngerlem@microsoft.com",
+            "commit": "609c18ca016e9e4b5831890bad56309f02280566",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Implement AppearanceModule",
+            "author": "ngerlem@microsoft.com",
+            "commit": "317d9fc1474930ef56c869706707126a78834c8b",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Add support for React Native BackHandler API",
+            "author": "jahiggin@microsoft.com",
+            "commit": "783410677774bcac2b7ada5900e2cec8675e5b2c",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "remove AccessibilityStates",
+            "author": "kmelmon@microsoft.com",
+            "commit": "f3d983eff16d81b60127b67ff8f056d4c6f20e29",
+            "package": "react-native-windows"
+          },
+          {
+            "comment": "Fix issue with yoga layout in x64 release",
+            "author": "acoates@microsoft.com",
+            "commit": "a67124cbd122bc9f90f7a9d5f328c94c504fe283",
+            "package": "react-native-windows"
+          }
+        ]
+      }
+    },
     {
       "date": "Fri, 17 Apr 2020 00:04:27 GMT",
       "tag": "react-native-windows_v0.0.0-master.42",
diff --git a/vnext/CHANGELOG.md b/vnext/CHANGELOG.md
index cb8eebf1c71..aced2707bc0 100644
--- a/vnext/CHANGELOG.md
+++ b/vnext/CHANGELOG.md
@@ -1,9 +1,51 @@
 # Change Log - react-native-windows
 
-This log was last generated on Fri, 17 Apr 2020 00:04:27 GMT and should not be manually modified.
+This log was last generated on Thu, 23 Apr 2020 00:04:37 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.0.0-master.46
+
+Thu, 23 Apr 2020 00:04:37 GMT
+
+### Changes
+
+- Hook up to packager websocket to allow 'r' to reload instance (acoates@microsoft.com)
+- Handle syntax errors in RedBox (asklar@microsoft.com)
+- Publish ship and debug bits in the nuget (acoates@microsoft.com)
+- Implement String ViewManager Command IDs (ngerlem@microsoft.com)
+
+## 0.0.0-master.45
+
+Wed, 22 Apr 2020 00:04:29 GMT
+
+### Changes
+
+- Make default template build non-dev bundle when not using debug configuration (acoates@microsoft.com)
+- Implemented C++ TurboModule compile time spec validation (vmorozov@microsoft.com)
+- Fix devtools connection to match RN0.62 (acoates@microsoft.com)
+
+## 0.0.0-master.44
+
+Sun, 19 Apr 2020 00:04:29 GMT
+
+### Changes
+
+- fix include paths (kmelmon@microsoft.com)
+
+## 0.0.0-master.43
+
+Sat, 18 Apr 2020 00:04:34 GMT
+
+### Changes
+
+- Allow enabling of direct debugging through the CLI. (12337821+nasadigital@users.noreply.github.com)
+- Implelent Shared StatusBarManagerModule and Do Module Cleanup (ngerlem@microsoft.com)
+- Implement AppearanceModule (ngerlem@microsoft.com)
+- Add support for React Native BackHandler API (jahiggin@microsoft.com)
+- remove AccessibilityStates (kmelmon@microsoft.com)
+- Fix issue with yoga layout in x64 release (acoates@microsoft.com)
+
 ## 0.0.0-master.42
 
 Fri, 17 Apr 2020 00:04:27 GMT
diff --git a/vnext/Desktop.DLL/react-native-win32.x64.def b/vnext/Desktop.DLL/react-native-win32.x64.def
index 280de54d461..253bc9d1dfa 100644
--- a/vnext/Desktop.DLL/react-native-win32.x64.def
+++ b/vnext/Desktop.DLL/react-native-win32.x64.def
@@ -34,7 +34,7 @@ EXPORTS
 ?createIUIManager@react@facebook@@YA?AV?$shared_ptr@VIUIManager@react@facebook@@@std@@$$QEAV?$vector@V?$unique_ptr@VIViewManager@react@facebook@@U?$default_delete@VIViewManager@react@facebook@@@std@@@std@@V?$allocator@V?$unique_ptr@VIViewManager@react@facebook@@U?$default_delete@VIViewManager@react@facebook@@@std@@@std@@@2@@4@PEAUINativeUIManager@12@@Z
 ?createUIManagerModule@react@facebook@@YA?AV?$unique_ptr@VCxxModule@module@xplat@facebook@@U?$default_delete@VCxxModule@module@xplat@facebook@@@std@@@std@@V?$shared_ptr@VIUIManager@react@facebook@@@4@@Z
 ?destroy@dynamic@folly@@AEAAXXZ
-?dispatchCommand@ShadowNode@react@facebook@@UEAAX_JAEBUdynamic@folly@@@Z
+?dispatchCommand@ShadowNode@react@facebook@@UEAAXAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@AEBUdynamic@folly@@@Z
 ?getModuleRegistry@Instance@react@facebook@@QEAAAEAVModuleRegistry@23@XZ
 ?get_ptr@dynamic@folly@@QEGBAPEBU12@V?$Range@PEBD@2@@Z
 ?get_ptrImpl@dynamic@folly@@AEGBAPEBU12@AEBU12@@Z
diff --git a/vnext/Desktop.DLL/react-native-win32.x86.def b/vnext/Desktop.DLL/react-native-win32.x86.def
index 9ae703e4de2..8a299514bc9 100644
--- a/vnext/Desktop.DLL/react-native-win32.x86.def
+++ b/vnext/Desktop.DLL/react-native-win32.x86.def
@@ -35,7 +35,7 @@ EXPORTS
 ?createIUIManager@react@facebook@@YG?AV?$shared_ptr@VIUIManager@react@facebook@@@std@@$$QAV?$vector@V?$unique_ptr@VIViewManager@react@facebook@@U?$default_delete@VIViewManager@react@facebook@@@std@@@std@@V?$allocator@V?$unique_ptr@VIViewManager@react@facebook@@U?$default_delete@VIViewManager@react@facebook@@@std@@@std@@@2@@4@PAUINativeUIManager@12@@Z
 ?createUIManagerModule@react@facebook@@YG?AV?$unique_ptr@VCxxModule@module@xplat@facebook@@U?$default_delete@VCxxModule@module@xplat@facebook@@@std@@@std@@V?$shared_ptr@VIUIManager@react@facebook@@@4@@Z
 ?destroy@dynamic@folly@@AAEXXZ
-?dispatchCommand@ShadowNode@react@facebook@@UAEX_JABUdynamic@folly@@@Z
+?dispatchCommand@ShadowNode@react@facebook@@UAEXABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@ABUdynamic@folly@@@Z
 ?getModuleRegistry@Instance@react@facebook@@QAEAAVModuleRegistry@23@XZ
 ?get_ptr@dynamic@folly@@QGBEPBU12@V?$Range@PBD@2@@Z
 ?get_ptrImpl@dynamic@folly@@AGBEPBU12@ABU12@@Z
diff --git a/vnext/Desktop.UnitTests/EmptyUIManagerModule.h b/vnext/Desktop.UnitTests/EmptyUIManagerModule.h
index 6006bb2ca44..f8e333ea0bb 100644
--- a/vnext/Desktop.UnitTests/EmptyUIManagerModule.h
+++ b/vnext/Desktop.UnitTests/EmptyUIManagerModule.h
@@ -63,7 +63,10 @@ class EmptyUIManager {
       std::function<void()> /*final Callback*/ callback);
   void setJSResponder(int64_t reactTag, bool blockNativeResponder);
   void clearJSResponder();
-  void dispatchViewManagerCommand(int64_t reactTag, int64_t commandId, folly::dynamic /*ReadableMap*/ commandArgs);
+  void dispatchViewManagerCommand(
+      int64_t reactTag,
+      const std::string &commandId,
+      folly::dynamic /*ReadableMap*/ commandArgs);
   void showPopupMenu(
       int64_t reactTag,
       folly::dynamic /*ReadableMap*/ items,
diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/Microsoft.ReactNative.Cxx.UnitTests.vcxproj b/vnext/Microsoft.ReactNative.Cxx.UnitTests/Microsoft.ReactNative.Cxx.UnitTests.vcxproj
index 7959860f16f..352c770761e 100644
--- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/Microsoft.ReactNative.Cxx.UnitTests.vcxproj
+++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/Microsoft.ReactNative.Cxx.UnitTests.vcxproj
@@ -112,6 +112,7 @@
     <ClInclude Include="JsonJSValueReader.h" />
     <ClInclude Include="JsonReader.h" />
     <ClInclude Include="pch.h" />
+    <ClInclude Include="Point.h" />
     <ClInclude Include="ReactModuleBuilderMock.h" />
   </ItemGroup>
   <ItemGroup>
@@ -126,6 +127,7 @@
       <PrecompiledHeader>Create</PrecompiledHeader>
     </ClCompile>
     <ClCompile Include="ReactModuleBuilderMock.cpp" />
+    <ClCompile Include="TurboModuleTest.cpp" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
@@ -157,4 +159,4 @@
     <Error Condition="!Exists('$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.props'))" />
     <Error Condition="!Exists('$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets'))" />
   </Target>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp
index 8edd3933795..84eb534ceda 100644
--- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp
+++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NativeModuleTest.cpp
@@ -5,24 +5,15 @@
 #include "ReactModuleBuilderMock.h"
 
 #include <sstream>
-#include "NativeModules.h"
+#include "Point.h"
 #include "future/futureWait.h"
 
-namespace winrt::Microsoft::ReactNative {
-
-REACT_STRUCT(Point)
-struct Point {
-  REACT_FIELD(X)
-  int X;
-
-  REACT_FIELD(Y)
-  int Y;
-};
+namespace ReactNativeTests {
 
 REACT_MODULE(SimpleNativeModule)
 struct SimpleNativeModule {
   REACT_INIT(Initialize)
-  void Initialize(IReactContext const &context) noexcept {
+  void Initialize(React::IReactContext const &context) noexcept {
     IsInitialized = true;
     TestCheck(context != nullptr);
 
@@ -322,46 +313,46 @@ struct SimpleNativeModule {
   }
 
   REACT_METHOD(DividePromise)
-  void DividePromise(int x, int y, ReactPromise<int> const &result) noexcept {
+  void DividePromise(int x, int y, React::ReactPromise<int> const &result) noexcept {
     if (y != 0) {
       result.Resolve(x / y);
     } else {
-      ReactError error{};
+      React::ReactError error{};
       error.Message = "Division by 0";
       result.Reject(std::move(error));
     }
   }
 
   REACT_METHOD(NegatePromise)
-  void NegatePromise(int x, ReactPromise<int> const &result) noexcept {
+  void NegatePromise(int x, React::ReactPromise<int> const &result) noexcept {
     if (x >= 0) {
       result.Resolve(-x);
     } else {
-      ReactError error{};
+      React::ReactError error{};
       error.Message = "Already negative";
       result.Reject(std::move(error));
     }
   }
 
   REACT_METHOD(NegateAsyncPromise)
-  fire_and_forget NegateAsyncPromise(int x, ReactPromise<int> result) noexcept {
+  fire_and_forget NegateAsyncPromise(int x, React::ReactPromise<int> result) noexcept {
     co_await winrt::resume_background();
     if (x >= 0) {
       result.Resolve(-x);
     } else {
-      ReactError error{};
+      React::ReactError error{};
       error.Message = "Already negative";
       result.Reject(std::move(error));
     }
   }
 
   REACT_METHOD(NegateDispatchQueuePromise)
-  void NegateDispatchQueuePromise(int x, ReactPromise<int> const &result) noexcept {
+  void NegateDispatchQueuePromise(int x, React::ReactPromise<int> const &result) noexcept {
     Mso::DispatchQueue::ConcurrentQueue().Post([ x, result ]() noexcept {
       if (x >= 0) {
         result.Resolve(-x);
       } else {
-        ReactError error{};
+        React::ReactError error{};
         error.Message = "Already negative";
         result.Reject(std::move(error));
       }
@@ -369,12 +360,12 @@ struct SimpleNativeModule {
   }
 
   REACT_METHOD(NegateFuturePromise)
-  void NegateFuturePromise(int x, ReactPromise<int> const &result) noexcept {
+  void NegateFuturePromise(int x, React::ReactPromise<int> const &result) noexcept {
     Mso::PostFuture([ x, result ]() noexcept {
       if (x >= 0) {
         result.Resolve(-x);
       } else {
-        ReactError error{};
+        React::ReactError error{};
         error.Message = "Already negative";
         result.Reject(std::move(error));
       }
@@ -383,7 +374,7 @@ struct SimpleNativeModule {
 
   // Each macro has second optional parameter: JS name.
   REACT_METHOD(VoidPromise, L"voidPromise")
-  void VoidPromise(int x, ReactPromise<void> const &result) noexcept {
+  void VoidPromise(int x, React::ReactPromise<void> const &result) noexcept {
     if (x % 2 == 0) {
       result.Resolve();
     } else {
@@ -392,58 +383,58 @@ struct SimpleNativeModule {
   }
 
   REACT_METHOD(ResolveSayHelloPromise)
-  void ResolveSayHelloPromise(ReactPromise<std::string> const &result) noexcept {
+  void ResolveSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
     result.Resolve("Hello_4");
   }
 
   REACT_METHOD(RejectSayHelloPromise)
-  void RejectSayHelloPromise(ReactPromise<std::string> const &result) noexcept {
-    ReactError error{};
+  void RejectSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
+    React::ReactError error{};
     error.Message = "Promise rejected";
     result.Reject(std::move(error));
   }
 
   REACT_METHOD(StaticDividePromise)
-  static void StaticDividePromise(int x, int y, ReactPromise<int> const &result) noexcept {
+  static void StaticDividePromise(int x, int y, React::ReactPromise<int> const &result) noexcept {
     if (y != 0) {
       result.Resolve(x / y);
     } else {
-      ReactError error{};
+      React::ReactError error{};
       error.Message = "Division by 0";
       result.Reject(std::move(error));
     }
   }
 
   REACT_METHOD(StaticNegatePromise)
-  static void StaticNegatePromise(int x, ReactPromise<int> const &result) noexcept {
+  static void StaticNegatePromise(int x, React::ReactPromise<int> const &result) noexcept {
     if (x >= 0) {
       result.Resolve(-x);
     } else {
-      ReactError error{};
+      React::ReactError error{};
       error.Message = "Already negative";
       result.Reject(std::move(error));
     }
   }
 
   REACT_METHOD(StaticNegateAsyncPromise)
-  static fire_and_forget StaticNegateAsyncPromise(int x, ReactPromise<int> result) noexcept {
+  static fire_and_forget StaticNegateAsyncPromise(int x, React::ReactPromise<int> result) noexcept {
     co_await winrt::resume_background();
     if (x >= 0) {
       result.Resolve(-x);
     } else {
-      ReactError error{};
+      React::ReactError error{};
       error.Message = "Already negative";
       result.Reject(std::move(error));
     }
   }
 
   REACT_METHOD(StaticNegateDispatchQueuePromise)
-  static void StaticNegateDispatchQueuePromise(int x, ReactPromise<int> const &result) noexcept {
+  static void StaticNegateDispatchQueuePromise(int x, React::ReactPromise<int> const &result) noexcept {
     Mso::DispatchQueue::ConcurrentQueue().Post([ x, result ]() noexcept {
       if (x >= 0) {
         result.Resolve(-x);
       } else {
-        ReactError error{};
+        React::ReactError error{};
         error.Message = "Already negative";
         result.Reject(std::move(error));
       }
@@ -451,12 +442,12 @@ struct SimpleNativeModule {
   }
 
   REACT_METHOD(StaticNegateFuturePromise)
-  static void StaticNegateFuturePromise(int x, ReactPromise<int> const &result) noexcept {
+  static void StaticNegateFuturePromise(int x, React::ReactPromise<int> const &result) noexcept {
     Mso::PostFuture([ x, result ]() noexcept {
       if (x >= 0) {
         result.Resolve(-x);
       } else {
-        ReactError error{};
+        React::ReactError error{};
         error.Message = "Already negative";
         result.Reject(std::move(error));
       }
@@ -465,7 +456,7 @@ struct SimpleNativeModule {
 
   // Each macro has second optional parameter: JS name.
   REACT_METHOD(StaticVoidPromise, L"staticVoidPromise")
-  void StaticVoidPromise(int x, ReactPromise<void> const &result) noexcept {
+  void StaticVoidPromise(int x, React::ReactPromise<void> const &result) noexcept {
     if (x % 2 == 0) {
       result.Resolve();
     } else {
@@ -474,13 +465,13 @@ struct SimpleNativeModule {
   }
 
   REACT_METHOD(StaticResolveSayHelloPromise)
-  static void StaticResolveSayHelloPromise(ReactPromise<std::string> const &result) noexcept {
+  static void StaticResolveSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
     result.Resolve("Hello_4");
   }
 
   REACT_METHOD(StaticRejectSayHelloPromise)
-  static void StaticRejectSayHelloPromise(ReactPromise<std::string> const &result) noexcept {
-    ReactError error{};
+  static void StaticRejectSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
+    React::ReactError error{};
     error.Message = "Promise rejected";
     result.Reject(std::move(error));
   }
@@ -528,13 +519,13 @@ struct SimpleNativeModule {
   static constexpr Point Constant4{/*X =*/3, /*Y =*/4};
 
   REACT_CONSTANT_PROVIDER(Constant5)
-  void Constant5(ReactConstantProvider &provider) noexcept {
+  void Constant5(React::ReactConstantProvider &provider) noexcept {
     provider.Add(L"const51", Point{/*X =*/12, /*Y =*/14});
     provider.Add(L"const52", "MyConstant52");
   }
 
   REACT_CONSTANT_PROVIDER(Constant6)
-  static void Constant6(ReactConstantProvider &provider) noexcept {
+  static void Constant6(React::ReactConstantProvider &provider) noexcept {
     provider.Add(L"const61", Point{/*X =*/15, /*Y =*/17});
     provider.Add(L"const62", "MyConstant62");
   }
@@ -560,9 +551,9 @@ struct SimpleNativeModule {
   REACT_EVENT(OnStringEvent, L"onStringEvent", L"MyEventEmitter")
   std::function<void(char const *)> OnStringEvent;
 
-  // Use JSValue which is an immutable JSON-like data representation.
+  // Use React::JSValue which is an immutable JSON-like data representation.
   REACT_EVENT(OnJSValueEvent)
-  std::function<void(const JSValue &)> OnJSValueEvent;
+  std::function<void(const React::JSValue &)> OnJSValueEvent;
 
   // Allows to call JS functions.
   REACT_FUNCTION(JSIntFunction)
@@ -585,9 +576,9 @@ struct SimpleNativeModule {
   REACT_FUNCTION(JSStringFunction, L"stringFunc", L"MyModule")
   std::function<void(char const *)> JSStringFunction;
 
-  // Use JSValue which is an immutable JSON-like data representation.
+  // Use React::JSValue which is an immutable JSON-like data representation.
   REACT_FUNCTION(JSValueFunction)
-  std::function<void(const JSValue &)> JSValueFunction;
+  std::function<void(const React::JSValue &)> JSValueFunction;
 
  public: // Used to report some test messages
   bool IsInitialized{false};
@@ -598,17 +589,17 @@ struct SimpleNativeModule {
 /*static*/ std::string SimpleNativeModule::StaticMessage;
 
 TEST_CLASS (NativeModuleTest) {
-  ReactModuleBuilderMock m_builderMock{};
-  IReactModuleBuilder m_moduleBuilder;
+  React::ReactModuleBuilderMock m_builderMock{};
+  React::IReactModuleBuilder m_moduleBuilder;
   Windows::Foundation::IInspectable m_moduleObject{nullptr};
   SimpleNativeModule *m_module;
 
   NativeModuleTest() {
-    m_moduleBuilder = make<ReactModuleBuilderImpl>(m_builderMock);
-    auto provider = MakeModuleProvider<SimpleNativeModule>();
+    m_moduleBuilder = winrt::make<React::ReactModuleBuilderImpl>(m_builderMock);
+    auto provider = React::MakeModuleProvider<SimpleNativeModule>();
     m_moduleObject = m_builderMock.CreateModule(provider, m_moduleBuilder);
-    auto reactModule = m_moduleObject.as<IBoxedValue>();
-    m_module = &BoxedValue<SimpleNativeModule>::GetImpl(reactModule);
+    auto reactModule = m_moduleObject.as<React::IBoxedValue>();
+    m_module = &React::BoxedValue<SimpleNativeModule>::GetImpl(reactModule);
   }
 
   TEST_METHOD(TestMethodCall_Add) {
@@ -644,7 +635,6 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call1(L"StaticSayHello", std::function<void(const std::string &)>([
                         ](const std::string &result) noexcept { TestCheck(result == "Hello"); }));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
-    TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
 
   TEST_METHOD(TestMethodCall_SayHello0) {
@@ -1005,8 +995,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"DividePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
         6,
         2);
     TestCheck(m_builderMock.IsResolveCallbackCalled());
@@ -1016,8 +1006,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"DividePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
         6,
         0);
     TestCheck(m_builderMock.IsRejectCallbackCalled());
@@ -1027,8 +1017,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"NegatePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5);
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1037,8 +1027,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"NegatePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5);
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1047,8 +1037,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"NegateAsyncPromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1057,8 +1047,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"NegateAsyncPromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1067,8 +1057,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"NegateDispatchQueuePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1077,8 +1067,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"NegateDispatchQueuePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1087,8 +1077,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"NegateFuturePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1097,8 +1087,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"NegateFuturePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1107,8 +1097,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"voidPromise",
         std::function<void()>([]() noexcept {}),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
         2);
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1117,8 +1107,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"voidPromise",
         std::function<void()>([]() noexcept {}),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
         3);
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1128,8 +1118,8 @@ TEST_CLASS (NativeModuleTest) {
         L"ResolveSayHelloPromise",
         std::function<void(const std::string &)>(
             [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
 
@@ -1138,8 +1128,8 @@ TEST_CLASS (NativeModuleTest) {
         L"RejectSayHelloPromise",
         std::function<void(const std::string &)>(
             [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
 
@@ -1147,8 +1137,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"StaticDividePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
         6,
         2);
     TestCheck(m_builderMock.IsResolveCallbackCalled());
@@ -1158,8 +1148,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"StaticDividePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
         6,
         0);
     TestCheck(m_builderMock.IsRejectCallbackCalled());
@@ -1169,8 +1159,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"StaticNegatePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5);
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1179,8 +1169,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"StaticNegateAsyncPromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1189,8 +1179,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"StaticNegateAsyncPromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1199,8 +1189,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"StaticNegatePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5);
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1209,8 +1199,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"StaticNegateDispatchQueuePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1219,8 +1209,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"StaticNegateDispatchQueuePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1229,8 +1219,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"StaticNegateFuturePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         5));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1239,8 +1229,8 @@ TEST_CLASS (NativeModuleTest) {
     Mso::FutureWait(m_builderMock.Call2(
         L"StaticNegateFuturePromise",
         std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
         -5));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1249,8 +1239,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"staticVoidPromise",
         std::function<void()>([]() noexcept {}),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
         2);
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
@@ -1259,8 +1249,8 @@ TEST_CLASS (NativeModuleTest) {
     m_builderMock.Call2(
         L"staticVoidPromise",
         std::function<void()>([]() noexcept {}),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
         3);
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
@@ -1270,8 +1260,8 @@ TEST_CLASS (NativeModuleTest) {
         L"StaticResolveSayHelloPromise",
         std::function<void(const std::string &)>(
             [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
     TestCheck(m_builderMock.IsResolveCallbackCalled());
   }
 
@@ -1280,8 +1270,8 @@ TEST_CLASS (NativeModuleTest) {
         L"StaticRejectSayHelloPromise",
         std::function<void(const std::string &)>(
             [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
-        std::function<void(JSValue const &)>(
-            [](JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
     TestCheck(m_builderMock.IsRejectCallbackCalled());
   }
 
@@ -1340,7 +1330,7 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestEvent_IntEventField) {
     bool eventRaised = false;
     m_builderMock.ExpectEvent(
-        L"RCTDeviceEventEmitter", L"OnIntEvent", [&eventRaised](JSValueArray const &args) noexcept {
+        L"RCTDeviceEventEmitter", L"OnIntEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
           TestCheck(args[0] == 42);
           eventRaised = true;
         });
@@ -1352,7 +1342,7 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestEvent_OnNoArgEventField) {
     bool eventRaised = false;
     m_builderMock.ExpectEvent(
-        L"RCTDeviceEventEmitter", L"OnNoArgEvent", [&eventRaised](JSValueArray const &args) noexcept {
+        L"RCTDeviceEventEmitter", L"OnNoArgEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
           TestCheckEqual(0, args.size());
           eventRaised = true;
         });
@@ -1364,7 +1354,7 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestEvent_TwoArgsEventField) {
     bool eventRaised = false;
     m_builderMock.ExpectEvent(
-        L"RCTDeviceEventEmitter", L"OnTwoArgsEvent", [&eventRaised](JSValueArray const &args) noexcept {
+        L"RCTDeviceEventEmitter", L"OnTwoArgsEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
           TestCheckEqual(4, args[0]["X"]);
           TestCheckEqual(2, args[0]["Y"]);
           TestCheckEqual(12, args[1]["X"]);
@@ -1379,7 +1369,7 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestEvent_JSNameEventField) {
     bool eventRaised = false;
     m_builderMock.ExpectEvent(
-        L"RCTDeviceEventEmitter", L"onPointEvent", [&eventRaised](JSValueArray const &args) noexcept {
+        L"RCTDeviceEventEmitter", L"onPointEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
           TestCheck(args[0]["X"] == 4);
           TestCheck(args[0]["Y"] == 2);
           eventRaised = true;
@@ -1391,10 +1381,11 @@ TEST_CLASS (NativeModuleTest) {
 
   TEST_METHOD(TestEvent_JSEventEmitterEventField) {
     bool eventRaised = false;
-    m_builderMock.ExpectEvent(L"MyEventEmitter", L"onStringEvent", [&eventRaised](JSValueArray const &args) noexcept {
-      TestCheckEqual("Hello World!", args[0]);
-      eventRaised = true;
-    });
+    m_builderMock.ExpectEvent(
+        L"MyEventEmitter", L"onStringEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheckEqual("Hello World!", args[0]);
+          eventRaised = true;
+        });
 
     m_module->OnStringEvent("Hello World!");
     TestCheck(eventRaised == true);
@@ -1403,20 +1394,20 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestEvent_JSValueObjectEventField) {
     bool eventRaised = false;
     m_builderMock.ExpectEvent(
-        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](JSValueArray const &args) noexcept {
+        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](React::JSValueArray const &args) noexcept {
           TestCheck(args[0]["X"] == 4);
           TestCheck(args[0]["Y"] == 2);
           eventRaised = true;
         }));
 
-    m_module->OnJSValueEvent(JSValueObject{{"X", 4}, {"Y", 2}});
+    m_module->OnJSValueEvent(React::JSValueObject{{"X", 4}, {"Y", 2}});
     TestCheck(eventRaised == true);
   }
 
   TEST_METHOD(TestEvent_JSValueArrayEventField) {
     bool eventRaised = false;
     m_builderMock.ExpectEvent(
-        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](JSValueArray const &args) noexcept {
+        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](React::JSValueArray const &args) noexcept {
           TestCheck(args[0][0] == "X");
           TestCheck(args[0][1] == 4);
           TestCheck(args[0][2] == true);
@@ -1424,26 +1415,26 @@ TEST_CLASS (NativeModuleTest) {
           eventRaised = true;
         }));
 
-    m_module->OnJSValueEvent(JSValueArray{"X", 4, true, JSValueObject{{"Id", 42}}});
+    m_module->OnJSValueEvent(React::JSValueArray{"X", 4, true, React::JSValueObject{{"Id", 42}}});
     TestCheck(eventRaised == true);
   }
 
   TEST_METHOD(TestEvent_JSValueArray1EventField) {
     bool eventRaised = false;
     m_builderMock.ExpectEvent(
-        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](JSValueArray const &args) noexcept {
+        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](React::JSValueArray const &args) noexcept {
           TestCheck(args[0][0] == 4);
           eventRaised = true;
         }));
 
-    m_module->OnJSValueEvent(JSValueArray{4});
+    m_module->OnJSValueEvent(React::JSValueArray{4});
     TestCheck(eventRaised == true);
   }
 
   TEST_METHOD(TestFunction_JSIntFunctionField) {
     bool functionCalled = false;
     m_builderMock.ExpectFunction(
-        L"SimpleNativeModule", L"JSIntFunction", [&functionCalled](JSValueArray const &args) noexcept {
+        L"SimpleNativeModule", L"JSIntFunction", [&functionCalled](React::JSValueArray const &args) noexcept {
           TestCheck(args[0] == 42);
           functionCalled = true;
         });
@@ -1455,7 +1446,7 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestFunction_JSNameFunctionField) {
     bool functionCalled = false;
     m_builderMock.ExpectFunction(
-        L"SimpleNativeModule", L"pointFunc", [&functionCalled](JSValueArray const &args) noexcept {
+        L"SimpleNativeModule", L"pointFunc", [&functionCalled](React::JSValueArray const &args) noexcept {
           TestCheck(args[0]["X"] == 4);
           TestCheck(args[0]["Y"] == 2);
           functionCalled = true;
@@ -1468,7 +1459,7 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestFunction_TwoArgFunctionField) {
     bool functionCalled = false;
     m_builderMock.ExpectFunction(
-        L"SimpleNativeModule", L"lineFunc", [&functionCalled](JSValueArray const &args) noexcept {
+        L"SimpleNativeModule", L"lineFunc", [&functionCalled](React::JSValueArray const &args) noexcept {
           TestCheck(args[0]["X"] == 4);
           TestCheck(args[0]["Y"] == 2);
           TestCheck(args[1]["X"] == 12);
@@ -1483,7 +1474,7 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestFunction_NoArgFunctionField) {
     bool functionCalled = false;
     m_builderMock.ExpectFunction(
-        L"SimpleNativeModule", L"JSNoArgFunction", [&functionCalled](JSValueArray const &args) noexcept {
+        L"SimpleNativeModule", L"JSNoArgFunction", [&functionCalled](React::JSValueArray const &args) noexcept {
           TestCheckEqual(0, args.size());
           functionCalled = true;
         });
@@ -1494,10 +1485,11 @@ TEST_CLASS (NativeModuleTest) {
 
   TEST_METHOD(TestFunction_JSModuleNameFunctionField) {
     bool functionCalled = false;
-    m_builderMock.ExpectFunction(L"MyModule", L"stringFunc", [&functionCalled](JSValueArray const &args) noexcept {
-      TestCheck(args[0] == "Hello World!");
-      functionCalled = true;
-    });
+    m_builderMock.ExpectFunction(
+        L"MyModule", L"stringFunc", [&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0] == "Hello World!");
+          functionCalled = true;
+        });
 
     m_module->JSStringFunction("Hello World!");
     TestCheck(functionCalled == true);
@@ -1506,20 +1498,20 @@ TEST_CLASS (NativeModuleTest) {
   TEST_METHOD(TestFunction_JSValueObjectFunctionField) {
     bool functionCalled = false;
     m_builderMock.ExpectFunction(
-        L"SimpleNativeModule", L"JSValueFunction", ([&functionCalled](JSValueArray const &args) noexcept {
+        L"SimpleNativeModule", L"JSValueFunction", ([&functionCalled](React::JSValueArray const &args) noexcept {
           TestCheck(args[0]["X"] == 4);
           TestCheck(args[0]["Y"] == 2);
           functionCalled = true;
         }));
 
-    m_module->JSValueFunction(JSValueObject{{"X", 4}, {"Y", 2}});
+    m_module->JSValueFunction(React::JSValueObject{{"X", 4}, {"Y", 2}});
     TestCheck(functionCalled == true);
   }
 
   TEST_METHOD(TestFunction_JSValueArrayFunctionField) {
     bool functionCalled = false;
     m_builderMock.ExpectFunction(
-        L"SimpleNativeModule", L"JSValueFunction", ([&functionCalled](JSValueArray const &args) noexcept {
+        L"SimpleNativeModule", L"JSValueFunction", ([&functionCalled](React::JSValueArray const &args) noexcept {
           TestCheck(args[0][0] == "X");
           TestCheck(args[0][1] == 4);
           TestCheck(args[0][2] == true);
@@ -1527,7 +1519,7 @@ TEST_CLASS (NativeModuleTest) {
           functionCalled = true;
         }));
 
-    m_module->JSValueFunction(JSValueArray{"X", 4, true, JSValueObject{{"Id", 42}}});
+    m_module->JSValueFunction(React::JSValueArray{"X", 4, true, React::JSValueObject{{"Id", 42}}});
     TestCheck(functionCalled == true);
   }
 
@@ -1536,4 +1528,4 @@ TEST_CLASS (NativeModuleTest) {
   }
 };
 
-} // namespace winrt::Microsoft::ReactNative
+} // namespace ReactNativeTests
diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp
index 149e39eec87..35c2af283aa 100644
--- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp
+++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/NoAttributeNativeModuleTest.cpp
@@ -507,7 +507,7 @@ struct SimpleNativeModule2 {
 
 /*static*/ std::string SimpleNativeModule2::StaticMessage;
 
-void RegisterModule(ReactModuleBuilder<SimpleNativeModule2> &moduleBuilder) noexcept {
+void GetReactModuleInfo(SimpleNativeModule2 *, ReactModuleBuilder<SimpleNativeModule2> &moduleBuilder) noexcept {
   moduleBuilder.RegisterModuleName(L"SimpleNativeModule2");
   moduleBuilder.RegisterInitMethod(&SimpleNativeModule2::Initialize);
   moduleBuilder.RegisterMethod(&SimpleNativeModule2::Add, L"Add");
@@ -577,8 +577,8 @@ void RegisterModule(ReactModuleBuilder<SimpleNativeModule2> &moduleBuilder) noex
   moduleBuilder.RegisterConstantField(&SimpleNativeModule2::Constant2, L"const2");
   moduleBuilder.RegisterConstantField(&SimpleNativeModule2::Constant3, L"const3");
   moduleBuilder.RegisterConstantField(&SimpleNativeModule2::Constant4, L"Constant4");
-  moduleBuilder.RegisterConstantMethod(&SimpleNativeModule2::Constant5, L"Constant5");
-  moduleBuilder.RegisterConstantMethod(&SimpleNativeModule2::Constant6, L"Constant6");
+  moduleBuilder.RegisterConstantMethod(&SimpleNativeModule2::Constant5);
+  moduleBuilder.RegisterConstantMethod(&SimpleNativeModule2::Constant6);
   moduleBuilder.RegisterEventField(&SimpleNativeModule2::OnIntEvent, L"OnIntEvent");
   moduleBuilder.RegisterEventField(&SimpleNativeModule2::OnNoArgEvent, L"OnNoArgEvent");
   moduleBuilder.RegisterEventField(&SimpleNativeModule2::OnTwoArgsEvent, L"OnTwoArgsEvent");
diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/Point.h b/vnext/Microsoft.ReactNative.Cxx.UnitTests/Point.h
new file mode 100644
index 00000000000..d711b247c33
--- /dev/null
+++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/Point.h
@@ -0,0 +1,15 @@
+#pragma once
+#include "NativeModules.h"
+
+namespace ReactNativeTests {
+
+REACT_STRUCT(Point)
+struct Point {
+  REACT_FIELD(X)
+  int X;
+
+  REACT_FIELD(Y)
+  int Y;
+};
+
+} // namespace ReactNativeTests
diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h b/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h
index ded81090484..88ec6935f02 100644
--- a/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h
+++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/ReactModuleBuilderMock.h
@@ -112,8 +112,8 @@ struct ReactModuleBuilderMock {
   std::vector<ConstantProviderDelegate> m_constantProviders;
   std::map<std::wstring, std::tuple<MethodReturnType, MethodDelegate>> m_methods;
   std::map<std::wstring, SyncMethodDelegate> m_syncMethods;
-  bool m_isResolveCallbackCalled;
-  bool m_isRejectCallbackCalled;
+  bool m_isResolveCallbackCalled{false};
+  bool m_isRejectCallbackCalled{false};
   Mso::Functor<void(std::wstring_view, std::wstring_view, JSValue const &)> m_jsFunctionHandler;
   Mso::Functor<void(std::wstring_view, std::wstring_view, JSValue const &)> m_jsEventHandler;
 };
diff --git a/vnext/Microsoft.ReactNative.Cxx.UnitTests/TurboModuleTest.cpp b/vnext/Microsoft.ReactNative.Cxx.UnitTests/TurboModuleTest.cpp
new file mode 100644
index 00000000000..7564168c4dd
--- /dev/null
+++ b/vnext/Microsoft.ReactNative.Cxx.UnitTests/TurboModuleTest.cpp
@@ -0,0 +1,2050 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "ReactModuleBuilderMock.h"
+
+#include <sstream>
+#include "Point.h"
+#include "future/futureWait.h"
+
+namespace ReactNativeTests {
+REACT_MODULE(MyTurboModule)
+struct MyTurboModule {
+  REACT_INIT(Initialize)
+  void Initialize(React::IReactContext const &context) noexcept {
+    IsInitialized = true;
+    TestCheck(context != nullptr);
+
+    // Event and Function fields are initialized before REACT_INIT method call.
+    TestCheck(this->OnIntEvent != nullptr);
+    TestCheck(this->JSIntFunction != nullptr);
+  }
+
+  REACT_METHOD(Add)
+  int Add(int x, int y) noexcept {
+    return x + y;
+  }
+
+  REACT_METHOD(Negate)
+  int Negate(int x) noexcept {
+    return -x;
+  }
+
+  REACT_METHOD(SayHello)
+  std::string SayHello() noexcept {
+    return "Hello";
+  }
+
+  REACT_METHOD(StaticAdd)
+  static int StaticAdd(int x, int y) noexcept {
+    return x + y;
+  }
+
+  REACT_METHOD(StaticNegate)
+  static int StaticNegate(int x) noexcept {
+    return -x;
+  }
+
+  REACT_METHOD(StaticSayHello)
+  static std::string StaticSayHello() noexcept {
+    return "Hello";
+  }
+
+  REACT_METHOD(SayHello0)
+  void SayHello0() noexcept {
+    Message = "Hello_0";
+  }
+
+  REACT_METHOD(PrintPoint)
+  void PrintPoint(Point pt) noexcept {
+    std::stringstream ss;
+    ss << "Point: (" << pt.X << ", " << pt.Y << ")";
+    Message = ss.str();
+  }
+
+  REACT_METHOD(PrintLine)
+  void PrintLine(Point start, Point end) noexcept {
+    std::stringstream ss;
+    ss << "Line: (" << start.X << ", " << start.Y << ")-(" << end.X << ", " << end.Y << ")";
+    Message = ss.str();
+  }
+
+  REACT_METHOD(StaticSayHello0)
+  static void StaticSayHello0() noexcept {
+    StaticMessage = "Hello_0";
+  }
+
+  REACT_METHOD(StaticPrintPoint)
+  static void StaticPrintPoint(Point pt) noexcept {
+    std::stringstream ss;
+    ss << "Static Point: (" << pt.X << ", " << pt.Y << ")";
+    StaticMessage = ss.str();
+  }
+
+  REACT_METHOD(StaticPrintLine)
+  static void StaticPrintLine(Point start, Point end) noexcept {
+    std::stringstream ss;
+    ss << "Static Line: (" << start.X << ", " << start.Y << ")-(" << end.X << ", " << end.Y << ")";
+    StaticMessage = ss.str();
+  }
+
+  REACT_METHOD(AddCallback)
+  void AddCallback(int x, int y, std::function<void(int)> const &resolve) noexcept {
+    resolve(x + y);
+  }
+
+  REACT_METHOD(NegateCallback)
+  void NegateCallback(int x, std::function<void(int)> const &resolve) noexcept {
+    resolve(-x);
+  }
+
+  REACT_METHOD(NegateAsyncCallback)
+  fire_and_forget NegateAsyncCallback(int x, std::function<void(int)> resolve) noexcept {
+    co_await winrt::resume_background();
+    resolve(-x);
+  }
+
+  REACT_METHOD(NegateDispatchQueueCallback)
+  void NegateDispatchQueueCallback(int x, std::function<void(int)> const &resolve) noexcept {
+    Mso::DispatchQueue::ConcurrentQueue().Post([ x, resolve ]() noexcept { resolve(-x); });
+  }
+
+  REACT_METHOD(NegateFutureCallback)
+  void NegateFutureCallback(int x, std::function<void(int)> const &resolve) noexcept {
+    Mso::PostFuture([ x, resolve ]() noexcept { resolve(-x); });
+  }
+
+  REACT_METHOD(SayHelloCallback)
+  void SayHelloCallback(std::function<void(const std::string &)> const &resolve) noexcept {
+    resolve("Hello_2");
+  }
+
+  REACT_METHOD(StaticAddCallback)
+  static void StaticAddCallback(int x, int y, std::function<void(int)> const &resolve) noexcept {
+    resolve(x + y);
+  }
+
+  REACT_METHOD(StaticNegateCallback)
+  static void StaticNegateCallback(int x, std::function<void(int)> const &resolve) noexcept {
+    resolve(-x);
+  }
+
+  REACT_METHOD(StaticNegateAsyncCallback)
+  static fire_and_forget StaticNegateAsyncCallback(int x, std::function<void(int)> resolve) noexcept {
+    co_await winrt::resume_background();
+    resolve(-x);
+  }
+
+  REACT_METHOD(StaticNegateDispatchQueueCallback)
+  static void StaticNegateDispatchQueueCallback(int x, std::function<void(int)> const &resolve) noexcept {
+    Mso::DispatchQueue::ConcurrentQueue().Post([ x, resolve ]() noexcept { resolve(-x); });
+  }
+
+  REACT_METHOD(StaticNegateFutureCallback)
+  static void StaticNegateFutureCallback(int x, std::function<void(int)> const &resolve) noexcept {
+    Mso::PostFuture([ x, resolve ]() noexcept { resolve(-x); });
+  }
+
+  REACT_METHOD(StaticSayHelloCallback)
+  static void StaticSayHelloCallback(std::function<void(const std::string &)> const &resolve) noexcept {
+    resolve("Static Hello_2");
+  }
+
+  REACT_METHOD(DivideCallbacks)
+  void DivideCallbacks(
+      int x,
+      int y,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    if (y != 0) {
+      resolve(x / y);
+    } else {
+      reject("Division by 0");
+    }
+  }
+
+  REACT_METHOD(NegateCallbacks)
+  void NegateCallbacks(
+      int x,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    if (x >= 0) {
+      resolve(-x);
+    } else {
+      reject("Already negative");
+    }
+  }
+
+  REACT_METHOD(NegateAsyncCallbacks)
+  fire_and_forget NegateAsyncCallbacks(
+      int x,
+      std::function<void(int)> resolve,
+      std::function<void(std::string const &)> reject) noexcept {
+    co_await winrt::resume_background();
+    if (x >= 0) {
+      resolve(-x);
+    } else {
+      reject("Already negative");
+    }
+  }
+
+  REACT_METHOD(NegateDispatchQueueCallbacks)
+  void NegateDispatchQueueCallbacks(
+      int x,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    Mso::DispatchQueue::ConcurrentQueue().Post([ x, resolve, reject ]() noexcept {
+      if (x >= 0) {
+        resolve(-x);
+      } else {
+        reject("Already negative");
+      }
+    });
+  }
+
+  REACT_METHOD(NegateFutureCallbacks)
+  void NegateFutureCallbacks(
+      int x,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    Mso::PostFuture([ x, resolve, reject ]() noexcept {
+      if (x >= 0) {
+        resolve(-x);
+      } else {
+        reject("Already negative");
+      }
+    });
+  }
+
+  REACT_METHOD(ResolveSayHelloCallbacks)
+  void ResolveSayHelloCallbacks(
+      std::function<void(std::string const &)> const &resolve,
+      std::function<void(std::string const &)> const & /*reject*/) noexcept {
+    resolve("Hello_3");
+  }
+
+  REACT_METHOD(RejectSayHelloCallbacks)
+  void RejectSayHelloCallbacks(
+      std::function<void(std::string const &)> const & /*resolve*/,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    reject("Goodbye");
+  }
+
+  REACT_METHOD(StaticDivideCallbacks)
+  static void StaticDivideCallbacks(
+      int x,
+      int y,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    if (y != 0) {
+      resolve(x / y);
+    } else {
+      reject("Division by 0");
+    }
+  }
+
+  REACT_METHOD(StaticNegateCallbacks)
+  static void StaticNegateCallbacks(
+      int x,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    if (x >= 0) {
+      resolve(-x);
+    } else {
+      reject("Already negative");
+    }
+  }
+
+  REACT_METHOD(StaticNegateAsyncCallbacks)
+  static fire_and_forget StaticNegateAsyncCallbacks(
+      int x,
+      std::function<void(int)> resolve,
+      std::function<void(std::string const &)> reject) noexcept {
+    co_await winrt::resume_background();
+    if (x >= 0) {
+      resolve(-x);
+    } else {
+      reject("Already negative");
+    }
+  }
+
+  REACT_METHOD(StaticNegateDispatchQueueCallbacks)
+  static void StaticNegateDispatchQueueCallbacks(
+      int x,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    Mso::DispatchQueue::ConcurrentQueue().Post([ x, resolve, reject ]() noexcept {
+      if (x >= 0) {
+        resolve(-x);
+      } else {
+        reject("Already negative");
+      }
+    });
+  }
+
+  REACT_METHOD(StaticNegateFutureCallbacks)
+  static void StaticNegateFutureCallbacks(
+      int x,
+      std::function<void(int)> const &resolve,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    Mso::PostFuture([ x, resolve, reject ]() noexcept {
+      if (x >= 0) {
+        resolve(-x);
+      } else {
+        reject("Already negative");
+      }
+    });
+  }
+
+  REACT_METHOD(StaticResolveSayHelloCallbacks)
+  static void StaticResolveSayHelloCallbacks(
+      std::function<void(std::string const &)> const &resolve,
+      std::function<void(std::string const &)> const & /*reject*/) noexcept {
+    resolve("Hello_3");
+  }
+
+  REACT_METHOD(StaticRejectSayHelloCallbacks)
+  static void StaticRejectSayHelloCallbacks(
+      std::function<void(std::string const &)> const & /*resolve*/,
+      std::function<void(std::string const &)> const &reject) noexcept {
+    reject("Goodbye");
+  }
+
+  REACT_METHOD(DividePromise)
+  void DividePromise(int x, int y, React::ReactPromise<int> const &result) noexcept {
+    if (y != 0) {
+      result.Resolve(x / y);
+    } else {
+      React::ReactError error{};
+      error.Message = "Division by 0";
+      result.Reject(std::move(error));
+    }
+  }
+
+  REACT_METHOD(NegatePromise)
+  void NegatePromise(int x, React::ReactPromise<int> const &result) noexcept {
+    if (x >= 0) {
+      result.Resolve(-x);
+    } else {
+      React::ReactError error{};
+      error.Message = "Already negative";
+      result.Reject(std::move(error));
+    }
+  }
+
+  REACT_METHOD(NegateAsyncPromise)
+  fire_and_forget NegateAsyncPromise(int x, React::ReactPromise<int> result) noexcept {
+    co_await winrt::resume_background();
+    if (x >= 0) {
+      result.Resolve(-x);
+    } else {
+      React::ReactError error{};
+      error.Message = "Already negative";
+      result.Reject(std::move(error));
+    }
+  }
+
+  REACT_METHOD(NegateDispatchQueuePromise)
+  void NegateDispatchQueuePromise(int x, React::ReactPromise<int> const &result) noexcept {
+    Mso::DispatchQueue::ConcurrentQueue().Post([ x, result ]() noexcept {
+      if (x >= 0) {
+        result.Resolve(-x);
+      } else {
+        React::ReactError error{};
+        error.Message = "Already negative";
+        result.Reject(std::move(error));
+      }
+    });
+  }
+
+  REACT_METHOD(NegateFuturePromise)
+  void NegateFuturePromise(int x, React::ReactPromise<int> const &result) noexcept {
+    Mso::PostFuture([ x, result ]() noexcept {
+      if (x >= 0) {
+        result.Resolve(-x);
+      } else {
+        React::ReactError error{};
+        error.Message = "Already negative";
+        result.Reject(std::move(error));
+      }
+    });
+  }
+
+  // Each macro has second optional parameter: JS name.
+  REACT_METHOD(VoidPromise, L"voidPromise")
+  void VoidPromise(int x, React::ReactPromise<void> const &result) noexcept {
+    if (x % 2 == 0) {
+      result.Resolve();
+    } else {
+      result.Reject("Odd unexpected");
+    }
+  }
+
+  REACT_METHOD(ResolveSayHelloPromise)
+  void ResolveSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
+    result.Resolve("Hello_4");
+  }
+
+  REACT_METHOD(RejectSayHelloPromise)
+  void RejectSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
+    React::ReactError error{};
+    error.Message = "Promise rejected";
+    result.Reject(std::move(error));
+  }
+
+  REACT_METHOD(StaticDividePromise)
+  static void StaticDividePromise(int x, int y, React::ReactPromise<int> const &result) noexcept {
+    if (y != 0) {
+      result.Resolve(x / y);
+    } else {
+      React::ReactError error{};
+      error.Message = "Division by 0";
+      result.Reject(std::move(error));
+    }
+  }
+
+  REACT_METHOD(StaticNegatePromise)
+  static void StaticNegatePromise(int x, React::ReactPromise<int> const &result) noexcept {
+    if (x >= 0) {
+      result.Resolve(-x);
+    } else {
+      React::ReactError error{};
+      error.Message = "Already negative";
+      result.Reject(std::move(error));
+    }
+  }
+
+  REACT_METHOD(StaticNegateAsyncPromise)
+  static fire_and_forget StaticNegateAsyncPromise(int x, React::ReactPromise<int> result) noexcept {
+    co_await winrt::resume_background();
+    if (x >= 0) {
+      result.Resolve(-x);
+    } else {
+      React::ReactError error{};
+      error.Message = "Already negative";
+      result.Reject(std::move(error));
+    }
+  }
+
+  REACT_METHOD(StaticNegateDispatchQueuePromise)
+  static void StaticNegateDispatchQueuePromise(int x, React::ReactPromise<int> const &result) noexcept {
+    Mso::DispatchQueue::ConcurrentQueue().Post([ x, result ]() noexcept {
+      if (x >= 0) {
+        result.Resolve(-x);
+      } else {
+        React::ReactError error{};
+        error.Message = "Already negative";
+        result.Reject(std::move(error));
+      }
+    });
+  }
+
+  REACT_METHOD(StaticNegateFuturePromise)
+  static void StaticNegateFuturePromise(int x, React::ReactPromise<int> const &result) noexcept {
+    Mso::PostFuture([ x, result ]() noexcept {
+      if (x >= 0) {
+        result.Resolve(-x);
+      } else {
+        React::ReactError error{};
+        error.Message = "Already negative";
+        result.Reject(std::move(error));
+      }
+    });
+  }
+
+  // Each macro has second optional parameter: JS name.
+  REACT_METHOD(StaticVoidPromise, L"staticVoidPromise")
+  void StaticVoidPromise(int x, React::ReactPromise<void> const &result) noexcept {
+    if (x % 2 == 0) {
+      result.Resolve();
+    } else {
+      result.Reject("Odd unexpected");
+    }
+  }
+
+  REACT_METHOD(StaticResolveSayHelloPromise)
+  static void StaticResolveSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
+    result.Resolve("Hello_4");
+  }
+
+  REACT_METHOD(StaticRejectSayHelloPromise)
+  static void StaticRejectSayHelloPromise(React::ReactPromise<std::string> const &result) noexcept {
+    React::ReactError error{};
+    error.Message = "Promise rejected";
+    result.Reject(std::move(error));
+  }
+
+  REACT_SYNC_METHOD(AddSync)
+  int AddSync(int x, int y) noexcept {
+    return x + y;
+  }
+
+  REACT_SYNC_METHOD(NegateSync)
+  int NegateSync(int x) noexcept {
+    return -x;
+  }
+
+  REACT_SYNC_METHOD(SayHelloSync)
+  std::string SayHelloSync() noexcept {
+    return "Hello";
+  }
+
+  REACT_SYNC_METHOD(StaticAddSync)
+  static int StaticAddSync(int x, int y) noexcept {
+    return x + y;
+  }
+
+  REACT_SYNC_METHOD(StaticNegateSync)
+  static int StaticNegateSync(int x) noexcept {
+    return -x;
+  }
+
+  REACT_SYNC_METHOD(StaticSayHelloSync)
+  static std::string StaticSayHelloSync() noexcept {
+    return "Hello";
+  }
+
+  REACT_CONSTANT(Constant1)
+  const std::string Constant1{"MyConstant1"};
+
+  REACT_CONSTANT(Constant2, L"const2")
+  const std::string Constant2{"MyConstant2"};
+
+  REACT_CONSTANT(Constant3, L"const3")
+  static constexpr Point Constant3{/*X =*/2, /*Y =*/3};
+
+  REACT_CONSTANT(Constant4)
+  static constexpr Point Constant4{/*X =*/3, /*Y =*/4};
+
+  REACT_CONSTANT_PROVIDER(Constant5)
+  void Constant5(React::ReactConstantProvider &provider) noexcept {
+    provider.Add(L"const51", Point{/*X =*/12, /*Y =*/14});
+    provider.Add(L"const52", "MyConstant52");
+  }
+
+  REACT_CONSTANT_PROVIDER(Constant6)
+  static void Constant6(React::ReactConstantProvider &provider) noexcept {
+    provider.Add(L"const61", Point{/*X =*/15, /*Y =*/17});
+    provider.Add(L"const62", "MyConstant62");
+  }
+
+  // Allows to emit native module events
+  REACT_EVENT(OnIntEvent)
+  std::function<void(int)> OnIntEvent;
+
+  // An event without arguments
+  REACT_EVENT(OnNoArgEvent)
+  std::function<void()> OnNoArgEvent;
+
+  // An event with two arguments
+  REACT_EVENT(OnTwoArgsEvent)
+  std::function<void(Point const &, Point const &)> OnTwoArgsEvent;
+
+  // Specify event name different from the field name.
+  REACT_EVENT(OnPointEvent, L"onPointEvent")
+  std::function<void(Point const &)> OnPointEvent;
+
+  // By default we use the event emitter name from REACT_MODULE which is by default 'RCTDeviceEventEmitter'.
+  // Here we specify event emitter name local for this event.
+  REACT_EVENT(OnStringEvent, L"onStringEvent", L"MyEventEmitter")
+  std::function<void(char const *)> OnStringEvent;
+
+  // Use React::JSValue which is an immutable JSON-like data representation.
+  REACT_EVENT(OnJSValueEvent)
+  std::function<void(const React::JSValue &)> OnJSValueEvent;
+
+  // Allows to call JS functions.
+  REACT_FUNCTION(JSIntFunction)
+  std::function<void(int)> JSIntFunction;
+
+  // Specify JS function name different from the field name.
+  REACT_FUNCTION(JSPointFunction, L"pointFunc")
+  std::function<void(Point const &)> JSPointFunction;
+
+  // Use two arguments. Specify JS function name different from the field name.
+  REACT_FUNCTION(JSLineFunction, L"lineFunc")
+  std::function<void(Point const &, Point const &)> JSLineFunction;
+
+  // Use no arguments.
+  REACT_FUNCTION(JSNoArgFunction)
+  std::function<void()> JSNoArgFunction;
+
+  // By default we use the module name from REACT_MODULE which is by default the struct name.
+  // Here we specify module name local for this function.
+  REACT_FUNCTION(JSStringFunction, L"stringFunc", L"MyModule")
+  std::function<void(char const *)> JSStringFunction;
+
+  // Use React::JSValue which is an immutable JSON-like data representation.
+  REACT_FUNCTION(JSValueFunction)
+  std::function<void(const React::JSValue &)> JSValueFunction;
+
+ public: // Used to report some test messages
+  bool IsInitialized{false};
+  std::string Message;
+  static std::string StaticMessage;
+};
+
+/*static*/ std::string MyTurboModule::StaticMessage;
+
+// The TurboModule spec is going to be generated from the Flow spec file.
+// It verifies that:
+// - module methods names are unique;
+// - method names are matching to the module spec method names;
+// - method signatures match the spec method signatures.
+struct MyTurboModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto methods = std::tuple{
+      Method<void(int, int, Callback<int>) noexcept>{0, L"Add"},
+      Method<void(int, Callback<int>) noexcept>{1, L"Negate"},
+      Method<void(Callback<std::string>) noexcept>{2, L"SayHello"},
+      Method<void(int, int, Callback<int>) noexcept>{3, L"StaticAdd"},
+      Method<void(int, Callback<int>) noexcept>{4, L"StaticNegate"},
+      Method<void(Callback<std::string>) noexcept>{5, L"StaticSayHello"},
+      Method<void() noexcept>{6, L"SayHello0"},
+      Method<void(Point) noexcept>{7, L"PrintPoint"},
+      Method<void(Point, Point) noexcept>{8, L"PrintLine"},
+      Method<void() noexcept>{9, L"StaticSayHello0"},
+      Method<void(Point) noexcept>{10, L"StaticPrintPoint"},
+      Method<void(Point, Point) noexcept>{11, L"StaticPrintLine"},
+      Method<void(int, int, Callback<int>) noexcept>{12, L"AddCallback"},
+      Method<void(int, Callback<int>) noexcept>{13, L"NegateCallback"},
+      Method<void(int, Callback<int>) noexcept>{14, L"NegateAsyncCallback"},
+      Method<void(int, Callback<int>) noexcept>{15, L"NegateDispatchQueueCallback"},
+      Method<void(int, Callback<int>) noexcept>{16, L"NegateFutureCallback"},
+      Method<void(Callback<std::string>) noexcept>{17, L"SayHelloCallback"},
+      Method<void(int, int, Callback<int>) noexcept>{18, L"StaticAddCallback"},
+      Method<void(int, Callback<int>) noexcept>{19, L"StaticNegateCallback"},
+      Method<void(int, Callback<int>) noexcept>{20, L"StaticNegateAsyncCallback"},
+      Method<void(int, Callback<int>) noexcept>{21, L"StaticNegateDispatchQueueCallback"},
+      Method<void(int, Callback<int>) noexcept>{22, L"StaticNegateFutureCallback"},
+      Method<void(Callback<std::string>) noexcept>{23, L"StaticSayHelloCallback"},
+      Method<void(int, int, Callback<int>, Callback<std::string>) noexcept>{24, L"DivideCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{25, L"NegateCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{26, L"NegateAsyncCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{27, L"NegateDispatchQueueCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{28, L"NegateFutureCallbacks"},
+      Method<void(Callback<std::string>, Callback<std::string>) noexcept>{29, L"ResolveSayHelloCallbacks"},
+      Method<void(Callback<std::string>, Callback<std::string>) noexcept>{30, L"RejectSayHelloCallbacks"},
+      Method<void(int, int, Callback<int>, Callback<std::string>) noexcept>{31, L"StaticDivideCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{32, L"StaticNegateCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{33, L"StaticNegateAsyncCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{34, L"StaticNegateDispatchQueueCallbacks"},
+      Method<void(int, Callback<int>, Callback<std::string>) noexcept>{35, L"StaticNegateFutureCallbacks"},
+      Method<void(Callback<std::string>, Callback<std::string>) noexcept>{36, L"StaticResolveSayHelloCallbacks"},
+      Method<void(Callback<std::string>, Callback<std::string>) noexcept>{37, L"StaticRejectSayHelloCallbacks"},
+      Method<void(int, int, Promise<int>) noexcept>{38, L"DividePromise"},
+      Method<void(int, Promise<int>) noexcept>{39, L"NegatePromise"},
+      Method<void(int, Promise<int>) noexcept>{40, L"NegateAsyncPromise"},
+      Method<void(int, Promise<int>) noexcept>{41, L"NegateDispatchQueuePromise"},
+      Method<void(int, Promise<int>) noexcept>{42, L"NegateFuturePromise"},
+      Method<void(int, Promise<void>) noexcept>{43, L"voidPromise"},
+      Method<void(Promise<std::string>) noexcept>{44, L"ResolveSayHelloPromise"},
+      Method<void(Promise<std::string>) noexcept>{45, L"RejectSayHelloPromise"},
+      Method<void(int, int, Promise<int>) noexcept>{46, L"StaticDividePromise"},
+      Method<void(int, Promise<int>) noexcept>{47, L"StaticNegatePromise"},
+      Method<void(int, Promise<int>) noexcept>{48, L"StaticNegateAsyncPromise"},
+      Method<void(int, Promise<int>) noexcept>{49, L"StaticNegateDispatchQueuePromise"},
+      Method<void(int, Promise<int>) noexcept>{50, L"StaticNegateFuturePromise"},
+      Method<void(int, Promise<void>) noexcept>{51, L"staticVoidPromise"},
+      Method<void(Promise<std::string>) noexcept>{52, L"StaticResolveSayHelloPromise"},
+      Method<void(Promise<std::string>) noexcept>{53, L"StaticRejectSayHelloPromise"},
+      SyncMethod<int(int, int) noexcept>{54, L"AddSync"},
+      SyncMethod<int(int) noexcept>{55, L"NegateSync"},
+      SyncMethod<std::string() noexcept>{56, L"SayHelloSync"},
+      SyncMethod<int(int, int) noexcept>{57, L"StaticAddSync"},
+      SyncMethod<int(int) noexcept>{58, L"StaticNegateSync"},
+      SyncMethod<std::string() noexcept>{59, L"StaticSayHelloSync"},
+  };
+
+  template <class TModule>
+  static constexpr void ValidateModule() noexcept {
+    constexpr auto methodCheckResults = CheckMethods<TModule, MyTurboModuleSpec>();
+
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        0,
+        "Add",
+        "    REACT_METHOD(Add) int Add(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Add) void Add(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Add) winrt::fire_and_forget Add(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Add) static int Add(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Add) static void Add(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Add) static React::Coroutine Add(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        1,
+        "Negate",
+        "    REACT_METHOD(Negate) int Negate(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Negate) void Negate(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Negate) winrt::fire_and_forget Negate(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Negate) static int Negate(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Negate) static void Negate(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(Negate) static winrt::fire_and_forget Negate(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        2,
+        "SayHello",
+        "    REACT_METHOD(SayHello) std::string SayHello() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello) void SayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello) winrt::fire_and_forget SayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello) static std::string SayHello() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello) static void SayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello) static winrt::fire_and_forget SayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        3,
+        "StaticAdd",
+        "    REACT_METHOD(StaticAdd) int StaticAdd(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAdd) void StaticAdd(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAdd) winrt::fire_and_forget StaticAdd(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAdd) static int StaticAdd(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAdd) static void StaticAdd(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAdd) static winrt::fire_and_forget StaticAdd(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        4,
+        "StaticNegate",
+        "    REACT_METHOD(StaticNegate) int StaticNegate(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegate) void StaticNegate(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegate) winrt::fire_and_forget StaticNegate(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegate) static int StaticNegate(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegate) static void StaticNegate(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegate) static winrt::fire_and_forget StaticNegate(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        5,
+        "StaticSayHello",
+        "    REACT_METHOD(StaticSayHello) std::string StaticSayHello() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello) void StaticSayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello) winrt::fire_and_forget StaticSayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello) static std::string StaticSayHello() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello) static void StaticSayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello) static winrt::fire_and_forget StaticSayHello(ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        6,
+        "SayHello0",
+        "    REACT_METHOD(SayHello0) void SayHello0() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello0) winrt::fire_and_forget SayHello0() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello0) static void SayHello0() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHello0) static winrt::fire_and_forget SayHello0() noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        7,
+        "PrintPoint",
+        "    REACT_METHOD(PrintPoint) void PrintPoint(Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(PrintPoint) winrt::fire_and_forget PrintPoint(Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(PrintPoint) static void PrintPoint(Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(PrintPoint) static winrt::fire_and_forget PrintPoint(Point) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        8,
+        "PrintLine",
+        "    REACT_METHOD(PrintPoint) void PrintLine(Point, Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(PrintPoint) winrt::fire_and_forget PrintLine(Point, Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(PrintPoint) static void PrintLine(Point, Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(PrintPoint) static winrt::fire_and_forget PrintLine(Point, Point) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        9,
+        "StaticSayHello0",
+        "    REACT_METHOD(StaticSayHello0) void StaticSayHello0() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello0) winrt::fire_and_forget StaticSayHello0() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello0) static void StaticSayHello0() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHello0) static winrt::fire_and_forget StaticSayHello0() noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        10,
+        "StaticPrintPoint",
+        "    REACT_METHOD(StaticPrintPoint) void StaticPrintPoint(Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticPrintPoint) winrt::fire_and_forget StaticPrintPoint(Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticPrintPoint) static void StaticPrintPoint(Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticPrintPoint) static winrt::fire_and_forget StaticPrintPoint(Point) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        11,
+        "StaticPrintLine",
+        "    REACT_METHOD(StaticPrintPoint) void StaticPrintLine(Point, Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticPrintPoint) winrt::fire_and_forget StaticPrintLine(Point, Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticPrintPoint) static void StaticPrintLine(Point, Point) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticPrintPoint) static winrt::fire_and_forget StaticPrintLine(Point, Point) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        12,
+        "AddCallback",
+        "    REACT_METHOD(AddCallback) int AddCallback(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(AddCallback) void AddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(AddCallback) winrt::fire_and_forget AddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(AddCallback) static int AddCallback(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(AddCallback) static void AddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(AddCallback) static winrt::fire_and_forget AddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        13,
+        "NegateCallback",
+        "    REACT_METHOD(NegateCallback) int NegateCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallback) void NegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallback) winrt::fire_and_forget NegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallback) static int NegateCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallback) static void NegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallback) static winrt::fire_and_forget NegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        14,
+        "NegateAsyncCallback",
+        "    REACT_METHOD(NegateAsyncCallback) int NegateAsyncCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallback) void NegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallback) winrt::fire_and_forget NegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallback) static int NegateAsyncCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallback) static void NegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallback) static winrt::fire_and_forget NegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        15,
+        "NegateDispatchQueueCallback",
+        "    REACT_METHOD(NegateDispatchQueueCallback) int NegateDispatchQueueCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallback) void NegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallback) winrt::fire_and_forget NegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallback) static int NegateDispatchQueueCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallback) static void NegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallback) static winrt::fire_and_forget NegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        16,
+        "NegateFutureCallback",
+        "    REACT_METHOD(NegateFutureCallback) int NegateFutureCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallback) void NegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallback) winrt::fire_and_forget NegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallback) static int NegateFutureCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallback) static void NegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallback) static winrt::fire_and_forget NegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        17,
+        "SayHelloCallback",
+        "    REACT_METHOD(SayHelloCallback) std::string SayHelloCallback() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHelloCallback) void SayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHelloCallback) winrt::fire_and_forget SayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHelloCallback) static std::string SayHelloCallback() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHelloCallback) static void SayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHelloCallback) static winrt::fire_and_forget SayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        18,
+        "StaticAddCallback",
+        "    REACT_METHOD(StaticAddCallback) int StaticAddCallback(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAddCallback) void StaticAddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAddCallback) winrt::fire_and_forget StaticAddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAddCallback) static int StaticAddCallback(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAddCallback) static void StaticAddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAddCallback) static winrt::fire_and_forget StaticAddCallback(int, int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        19,
+        "StaticNegateCallback",
+        "    REACT_METHOD(StaticNegateCallback) int StaticNegateCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallback) void StaticNegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallback) winrt::fire_and_forget StaticNegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallback) static int StaticNegateCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallback) static void StaticNegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallback) static winrt::fire_and_forget StaticNegateCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        20,
+        "StaticNegateAsyncCallback",
+        "    REACT_METHOD(StaticNegateAsyncCallback) int StaticNegateAsyncCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallback) void StaticNegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallback) winrt::fire_and_forget StaticNegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallback) static int StaticNegateAsyncCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallback) static void StaticNegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallback) static winrt::fire_and_forget StaticNegateAsyncCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        21,
+        "StaticNegateDispatchQueueCallback",
+        "    REACT_METHOD(StaticNegateDispatchQueueCallback) int StaticNegateDispatchQueueCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallback) void StaticNegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallback) winrt::fire_and_forget StaticNegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallback) static int StaticNegateDispatchQueueCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallback) static void StaticNegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallback) static winrt::fire_and_forget StaticNegateDispatchQueueCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        22,
+        "StaticNegateFutureCallback",
+        "    REACT_METHOD(StaticNegateFutureCallback) int StaticNegateFutureCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallback) void StaticNegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallback) winrt::fire_and_forget StaticNegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallback) static int StaticNegateFutureCallback(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallback) static void StaticNegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallback) static winrt::fire_and_forget StaticNegateFutureCallback(int, ReactCallback<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        23,
+        "StaticSayHelloCallback",
+        "    REACT_METHOD(StaticSayHelloCallback) std::string StaticSayHelloCallback() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHelloCallback) void StaticSayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHelloCallback) winrt::fire_and_forget StaticSayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHelloCallback) static std::string StaticSayHelloCallback() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHelloCallback) static void StaticSayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHelloCallback) static winrt::fire_and_forget StaticSayHelloCallback(ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        24,
+        "DivideCallbacks",
+        "    REACT_METHOD(DivideCallbacks) void DivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(DivideCallbacks) winrt::fire_and_forget DivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(DivideCallbacks) static void DivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(DivideCallbacks) static winrt::fire_and_forget DivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        25,
+        "NegateCallbacks",
+        "    REACT_METHOD(NegateCallbacks) void NegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallbacks) winrt::fire_and_forget NegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallbacks) static void NegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateCallbacks) static winrt::fire_and_forget NegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        26,
+        "NegateAsyncCallbacks",
+        "    REACT_METHOD(NegateAsyncCallbacks) void NegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallbacks) winrt::fire_and_forget NegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallbacks) static void NegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncCallbacks) static winrt::fire_and_forget NegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        27,
+        "NegateDispatchQueueCallbacks",
+        "    REACT_METHOD(NegateDispatchQueueCallbacks) void NegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallbacks) winrt::fire_and_forget NegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallbacks) static void NegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueueCallbacks) static winrt::fire_and_forget NegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        28,
+        "NegateFutureCallbacks",
+        "    REACT_METHOD(NegateFutureCallbacks) void NegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallbacks) winrt::fire_and_forget NegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallbacks) static void NegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFutureCallbacks) static winrt::fire_and_forget NegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        29,
+        "ResolveSayHelloCallbacks",
+        "    REACT_METHOD(ResolveSayHelloCallbacks) void ResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(ResolveSayHelloCallbacks) winrt::fire_and_forget ResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(ResolveSayHelloCallbacks) static void ResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(ResolveSayHelloCallbacks) static winrt::fire_and_forget ResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        30,
+        "RejectSayHelloCallbacks",
+        "    REACT_METHOD(RejectSayHelloCallbacks) void RejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(RejectSayHelloCallbacks) winrt::fire_and_forget RejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(RejectSayHelloCallbacks) static void RejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(RejectSayHelloCallbacks) static winrt::fire_and_forget RejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        31,
+        "StaticDivideCallbacks",
+        "    REACT_METHOD(StaticDivideCallbacks) void StaticDivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticDivideCallbacks) winrt::fire_and_forget StaticDivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticDivideCallbacks) static void StaticDivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticDivideCallbacks) static winrt::fire_and_forget StaticDivideCallbacks(int, int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        32,
+        "StaticNegateCallbacks",
+        "    REACT_METHOD(StaticNegateCallbacks) void StaticNegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallbacks) winrt::fire_and_forget StaticNegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallbacks) static void StaticNegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateCallbacks) static winrt::fire_and_forget StaticNegateCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        33,
+        "StaticNegateAsyncCallbacks",
+        "    REACT_METHOD(StaticNegateAsyncCallbacks) void StaticNegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallbacks) winrt::fire_and_forget StaticNegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallbacks) static void StaticNegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncCallbacks) static winrt::fire_and_forget StaticNegateAsyncCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        34,
+        "StaticNegateDispatchQueueCallbacks",
+        "    REACT_METHOD(StaticNegateDispatchQueueCallbacks) void StaticNegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallbacks) winrt::fire_and_forget StaticNegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallbacks) static void StaticNegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueueCallbacks) static winrt::fire_and_forget StaticNegateDispatchQueueCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        35,
+        "StaticNegateFutureCallbacks",
+        "    REACT_METHOD(StaticNegateFutureCallbacks) void StaticNegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallbacks) winrt::fire_and_forget StaticNegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallbacks) static void StaticNegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFutureCallbacks) static winrt::fire_and_forget StaticNegateFutureCallbacks(int, ReactCallback<int>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        36,
+        "StaticResolveSayHelloCallbacks",
+        "    REACT_METHOD(StaticResolveSayHelloCallbacks) void StaticResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticResolveSayHelloCallbacks) winrt::fire_and_forget StaticResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticResolveSayHelloCallbacks) static void StaticResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticResolveSayHelloCallbacks) static winrt::fire_and_forget StaticResolveSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        37,
+        "StaticRejectSayHelloCallbacks",
+        "    REACT_METHOD(StaticRejectSayHelloCallbacks) void StaticRejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticRejectSayHelloCallbacks) winrt::fire_and_forget StaticRejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticRejectSayHelloCallbacks) static void StaticRejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticRejectSayHelloCallbacks) static winrt::fire_and_forget StaticRejectSayHelloCallbacks(ReactCallback<std::string>, ReactCallback<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        38,
+        "DividePromise",
+        "    REACT_METHOD(DividePromise) void DividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(DividePromise) winrt::fire_and_forget DividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(DividePromise) static void DividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(DividePromise) static winrt::fire_and_forget DividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        39,
+        "NegatePromise",
+        "    REACT_METHOD(NegatePromise) void NegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegatePromise) winrt::fire_and_forget NegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegatePromise) static void NegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegatePromise) static winrt::fire_and_forget NegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        40,
+        "NegateAsyncPromise",
+        "    REACT_METHOD(NegateAsyncPromise) void NegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncPromise) winrt::fire_and_forget NegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncPromise) static void NegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateAsyncPromise) static winrt::fire_and_forget NegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        41,
+        "NegateDispatchQueuePromise",
+        "    REACT_METHOD(NegateDispatchQueuePromise) void NegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueuePromise) winrt::fire_and_forget NegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueuePromise) static void NegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateDispatchQueuePromise) static winrt::fire_and_forget NegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        42,
+        "NegateFuturePromise",
+        "    REACT_METHOD(NegateFuturePromise) void NegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFuturePromise) winrt::fire_and_forget NegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFuturePromise) static void NegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateFuturePromise) static winrt::fire_and_forget NegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        43,
+        "voidPromise",
+        "    REACT_METHOD(voidPromise) void voidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(voidPromise) winrt::fire_and_forget voidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(voidPromise) static void voidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(voidPromise) static winrt::fire_and_forget voidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        44,
+        "ResolveSayHelloPromise",
+        "    REACT_METHOD(ResolveSayHelloPromise) void ResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(ResolveSayHelloPromise) winrt::fire_and_forget ResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(ResolveSayHelloPromise) static void ResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(ResolveSayHelloPromise) static winrt::fire_and_forget ResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        45,
+        "RejectSayHelloPromise",
+        "    REACT_METHOD(RejectSayHelloPromise) void RejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(RejectSayHelloPromise) winrt::fire_and_forget RejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(RejectSayHelloPromise) static void RejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(RejectSayHelloPromise) static winrt::fire_and_forget RejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        46,
+        "StaticDividePromise",
+        "    REACT_METHOD(StaticDividePromise) void StaticDividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticDividePromise) winrt::fire_and_forget StaticDividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticDividePromise) static void StaticDividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticDividePromise) static winrt::fire_and_forget StaticDividePromise(int, int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        47,
+        "StaticNegatePromise",
+        "    REACT_METHOD(StaticNegatePromise) void StaticNegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegatePromise) winrt::fire_and_forget StaticNegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegatePromise) static void StaticNegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegatePromise) static winrt::fire_and_forget StaticNegatePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        48,
+        "StaticNegateAsyncPromise",
+        "    REACT_METHOD(StaticNegateAsyncPromise) void StaticNegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncPromise) winrt::fire_and_forget StaticNegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncPromise) static void StaticNegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateAsyncPromise) static winrt::fire_and_forget StaticNegateAsyncPromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        49,
+        "StaticNegateDispatchQueuePromise",
+        "    REACT_METHOD(StaticNegateDispatchQueuePromise) void StaticNegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueuePromise) winrt::fire_and_forget StaticNegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueuePromise) static void StaticNegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateDispatchQueuePromise) static winrt::fire_and_forget StaticNegateDispatchQueuePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        50,
+        "StaticNegateFuturePromise",
+        "    REACT_METHOD(StaticNegateFuturePromise) void StaticNegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFuturePromise) winrt::fire_and_forget StaticNegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFuturePromise) static void StaticNegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateFuturePromise) static winrt::fire_and_forget StaticNegateFuturePromise(int, ReactPromise<int>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        51,
+        "staticVoidPromise",
+        "    REACT_METHOD(staticVoidPromise) void staticVoidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(staticVoidPromise) winrt::fire_and_forget staticVoidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(staticVoidPromise) static void staticVoidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(staticVoidPromise) static winrt::fire_and_forget staticVoidPromise(int, ReactPromise<void>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        52,
+        "StaticResolveSayHelloPromise",
+        "    REACT_METHOD(StaticResolveSayHelloPromise) void StaticResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticResolveSayHelloPromise) winrt::fire_and_forget StaticResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticResolveSayHelloPromise) static void StaticResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticResolveSayHelloPromise) static winrt::fire_and_forget StaticResolveSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+        53,
+        "StaticRejectSayHelloPromise",
+        "    REACT_METHOD(StaticRejectSayHelloPromise) void StaticRejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticRejectSayHelloPromise) winrt::fire_and_forget StaticRejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticRejectSayHelloPromise) static void StaticRejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticRejectSayHelloPromise) static winrt::fire_and_forget StaticRejectSayHelloPromise(ReactPromise<std::string>) noexcept {/*implementation*/}\n");
+    REACT_SHOW_SYNC_METHOD_SPEC_ERRORS(
+        54,
+        "AddSync",
+        "    REACT_METHOD(AddSync) int AddSync(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(AddSync) static int AddSync(int, int) noexcept {/*implementation*/}\n");
+    REACT_SHOW_SYNC_METHOD_SPEC_ERRORS(
+        55,
+        "NegateSync",
+        "    REACT_METHOD(NegateSync) int NegateSync(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(NegateSync) static int NegateSync(int) noexcept {/*implementation*/}\n");
+    REACT_SHOW_SYNC_METHOD_SPEC_ERRORS(
+        56,
+        "SayHelloSync",
+        "    REACT_METHOD(SayHelloSync) std::string SayHelloSync() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(SayHelloSync) static std::string SayHelloSync() noexcept {/*implementation*/}\n");
+    REACT_SHOW_SYNC_METHOD_SPEC_ERRORS(
+        57,
+        "StaticAddSync",
+        "    REACT_METHOD(StaticAddSync) int StaticAddSync(int, int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticAddSync) static int StaticAddSync(int, int) noexcept {/*implementation*/}\n");
+    REACT_SHOW_SYNC_METHOD_SPEC_ERRORS(
+        58,
+        "StaticNegateSync",
+        "    REACT_METHOD(StaticNegateSync) int StaticNegateSync(int) noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticNegateSync) static int StaticNegateSync(int) noexcept {/*implementation*/}\n");
+    REACT_SHOW_SYNC_METHOD_SPEC_ERRORS(
+        59,
+        "StaticSayHelloSync",
+        "    REACT_METHOD(StaticSayHelloSync) std::string StaticSayHelloSync() noexcept {/*implementation*/}\n"
+        "    REACT_METHOD(StaticSayHelloSync) static std::string StaticSayHelloSync() noexcept {/*implementation*/}\n");
+  }
+};
+
+TEST_CLASS (TurboModuleTest) {
+  winrt::Microsoft::ReactNative::ReactModuleBuilderMock m_builderMock{};
+  winrt::Microsoft::ReactNative::IReactModuleBuilder m_moduleBuilder;
+  Windows::Foundation::IInspectable m_moduleObject{nullptr};
+  MyTurboModule *m_module;
+
+  TurboModuleTest() {
+    m_moduleBuilder = winrt::make<winrt::Microsoft::ReactNative::ReactModuleBuilderImpl>(m_builderMock);
+    auto provider = winrt::Microsoft::ReactNative::MakeTurboModuleProvider<MyTurboModule, MyTurboModuleSpec>();
+    m_moduleObject = m_builderMock.CreateModule(provider, m_moduleBuilder);
+    auto reactModule = m_moduleObject.as<winrt::Microsoft::ReactNative::IBoxedValue>();
+    m_module = &winrt::Microsoft::ReactNative::BoxedValue<MyTurboModule>::GetImpl(reactModule);
+  }
+
+  TEST_METHOD(TestMethodCall_Add) {
+    m_builderMock.Call1(L"Add", std::function<void(int)>([](int result) noexcept { TestCheckEqual(8, result); }), 3, 5);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_Negate) {
+    m_builderMock.Call1(L"Negate", std::function<void(int)>([](int result) noexcept { TestCheck(result == -3); }), 3);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_SayHello) {
+    m_builderMock.Call1(L"SayHello", std::function<void(const std::string &)>([](const std::string &result) noexcept {
+                          TestCheck(result == "Hello");
+                        }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticAdd) {
+    m_builderMock.Call1(
+        L"StaticAdd", std::function<void(int)>([](int result) noexcept { TestCheck(result == 25); }), 20, 5);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegate) {
+    m_builderMock.Call1(
+        L"StaticNegate", std::function<void(int)>([](int result) noexcept { TestCheck(result == -7); }), 7);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticSayHello) {
+    m_builderMock.Call1(L"StaticSayHello", std::function<void(const std::string &)>([
+                        ](const std::string &result) noexcept { TestCheck(result == "Hello"); }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_SayHello0) {
+    m_builderMock.Call0(L"SayHello0");
+    TestCheck(m_module->Message == "Hello_0");
+  }
+
+  TEST_METHOD(TestMethodCall_PrintPoint) {
+    m_builderMock.Call0(L"PrintPoint", Point{/*X =*/3, /*Y =*/5});
+    TestCheck(m_module->Message == "Point: (3, 5)");
+  }
+
+  TEST_METHOD(TestMethodCall_PrintLine) {
+    m_builderMock.Call0(L"PrintLine", Point{/*X =*/3, /*Y =*/5}, Point{/*X =*/6, /*Y =*/8});
+    TestCheck(m_module->Message == "Line: (3, 5)-(6, 8)");
+  }
+
+  TEST_METHOD(TestMethodCall_StaticSayHello0) {
+    m_builderMock.Call0(L"StaticSayHello0");
+    TestCheck(MyTurboModule::StaticMessage == "Hello_0");
+  }
+
+  TEST_METHOD(TestMethodCall_StaticPrintPoint) {
+    m_builderMock.Call0(L"StaticPrintPoint", Point{/*X =*/13, /*Y =*/15});
+    TestCheck(MyTurboModule::StaticMessage == "Static Point: (13, 15)");
+  }
+
+  TEST_METHOD(TestMethodCall_StaticPrintLine) {
+    m_builderMock.Call0(L"StaticPrintLine", Point{/*X =*/13, /*Y =*/15}, Point{/*X =*/16, /*Y =*/18});
+    TestCheck(MyTurboModule::StaticMessage == "Static Line: (13, 15)-(16, 18)");
+  }
+
+  TEST_METHOD(TestMethodCall_AddCallback) {
+    m_builderMock.Call1(
+        L"AddCallback", std::function<void(int)>([](int result) noexcept { TestCheck(result == -1); }), 7, -8);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateCallback) {
+    m_builderMock.Call1(
+        L"NegateCallback", std::function<void(int)>([](int result) noexcept { TestCheck(result == -4); }), 4);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateAsyncCallback) {
+    Mso::FutureWait(m_builderMock.Call1(
+        L"NegateAsyncCallback", std::function<void(int)>([](int result) noexcept { TestCheck(result == -4); }), 4));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateDispatchQueueCallback) {
+    Mso::FutureWait(m_builderMock.Call1(
+        L"NegateDispatchQueueCallback",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -4); }),
+        4));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateFutureCallback) {
+    Mso::FutureWait(m_builderMock.Call1(
+        L"NegateFutureCallback", std::function<void(int)>([](int result) noexcept { TestCheck(result == -4); }), 4));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_SayHelloCallback) {
+    m_builderMock.Call1(L"SayHelloCallback", std::function<void(const std::string &)>([
+                        ](const std::string &result) noexcept { TestCheck(result == "Hello_2"); }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticAddCallback) {
+    m_builderMock.Call1(
+        L"StaticAddCallback", std::function<void(int)>([](int result) noexcept { TestCheck(result == 60); }), 4, 56);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateCallback) {
+    m_builderMock.Call1(
+        L"StaticNegateCallback", std::function<void(int)>([](int result) noexcept { TestCheck(result == -33); }), 33);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateAsyncCallback) {
+    Mso::FutureWait(m_builderMock.Call1(
+        L"StaticNegateAsyncCallback",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -4); }),
+        4));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateDispatchQueueCallback) {
+    Mso::FutureWait(m_builderMock.Call1(
+        L"StaticNegateDispatchQueueCallback",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -4); }),
+        4));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateFutureCallback) {
+    Mso::FutureWait(m_builderMock.Call1(
+        L"StaticNegateFutureCallback",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -4); }),
+        4));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticSayHelloCallback) {
+    m_builderMock.Call1(L"StaticSayHelloCallback", std::function<void(const std::string &)>([
+                        ](const std::string &result) noexcept { TestCheck(result == "Static Hello_2"); }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_DivideCallbacks) {
+    m_builderMock.Call2(
+        L"DivideCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Division by 0"); }),
+        6,
+        2);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_DivideCallbacksError) {
+    m_builderMock.Call2(
+        L"DivideCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Division by 0"); }),
+        6,
+        0);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateCallbacks) {
+    m_builderMock.Call2(
+        L"NegateCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateCallbacksError) {
+    m_builderMock.Call2(
+        L"NegateCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateAsyncCallbacks) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateAsyncCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateAsyncCallbacksError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateAsyncCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateDispatchQueueCallbacks) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateDispatchQueueCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateDispatchQueueCallbacksError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateDispatchQueueCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateFutureCallbacks) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateFutureCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateFutureCallbacksError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateFutureCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_ResolveSayHelloCallbacks) {
+    m_builderMock.Call2(
+        L"ResolveSayHelloCallbacks",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_3"); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Goodbye"); }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_RejectSayHelloCallbacks) {
+    m_builderMock.Call2(
+        L"RejectSayHelloCallbacks",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_3"); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Goodbye"); }));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticDivideCallbacks) {
+    m_builderMock.Call2(
+        L"StaticDivideCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Division by 0"); }),
+        6,
+        2);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticDivideCallbacksError) {
+    m_builderMock.Call2(
+        L"StaticDivideCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Division by 0"); }),
+        6,
+        0);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateCallbacks) {
+    m_builderMock.Call2(
+        L"StaticNegateCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateCallbacksError) {
+    m_builderMock.Call2(
+        L"StaticNegateCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateAsyncCallbacks) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateAsyncCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateAsyncCallbacksError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateAsyncCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateDispatchQueueCallbacks) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateDispatchQueueCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateDispatchQueueCallbacksError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateDispatchQueueCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateFutureCallbacks) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateFutureCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateFutureCallbacksError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateFutureCallbacks",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticResolveSayHelloCallbacks) {
+    m_builderMock.Call2(
+        L"StaticResolveSayHelloCallbacks",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_3"); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Goodbye"); }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticRejectSayHelloCallbacks) {
+    m_builderMock.Call2(
+        L"StaticRejectSayHelloCallbacks",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_3"); }),
+        std::function<void(std::string const &)>(
+            [](std::string const &error) noexcept { TestCheck(error == "Goodbye"); }));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_DividePromise) {
+    m_builderMock.Call2(
+        L"DividePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        6,
+        2);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_DividePromiseError) {
+    m_builderMock.Call2(
+        L"DividePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        6,
+        0);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegatePromise) {
+    m_builderMock.Call2(
+        L"NegatePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegatePromiseError) {
+    m_builderMock.Call2(
+        L"NegatePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateAsyncPromise) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateAsyncPromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateAsyncPromiseError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateAsyncPromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateDispatchQueuePromise) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateDispatchQueuePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateDispatchQueuePromiseError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateDispatchQueuePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateFuturePromise) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateFuturePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_NegateFuturePromiseError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"NegateFuturePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_VoidPromise) {
+    m_builderMock.Call2(
+        L"voidPromise",
+        std::function<void()>([]() noexcept {}),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        2);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_VoidError) {
+    m_builderMock.Call2(
+        L"voidPromise",
+        std::function<void()>([]() noexcept {}),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        3);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_ResolveSayHelloPromise) {
+    m_builderMock.Call2(
+        L"ResolveSayHelloPromise",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_RejectSayHelloPromise) {
+    m_builderMock.Call2(
+        L"RejectSayHelloPromise",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticDividePromise) {
+    m_builderMock.Call2(
+        L"StaticDividePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        6,
+        2);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticDividePromiseError) {
+    m_builderMock.Call2(
+        L"StaticDividePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == 3); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Division by 0"); }),
+        6,
+        0);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegatePromise) {
+    m_builderMock.Call2(
+        L"StaticNegatePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegatePromiseError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateAsyncPromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateAsyncPromise) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateAsyncPromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateAsyncPromiseError) {
+    m_builderMock.Call2(
+        L"StaticNegatePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateDispatchQueuePromise) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateDispatchQueuePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateDispatchQueuePromiseError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateDispatchQueuePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateFuturePromise) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateFuturePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        5));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticNegateFuturePromiseError) {
+    Mso::FutureWait(m_builderMock.Call2(
+        L"StaticNegateFuturePromise",
+        std::function<void(int)>([](int result) noexcept { TestCheck(result == -5); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Already negative"); }),
+        -5));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticVoidPromise) {
+    m_builderMock.Call2(
+        L"staticVoidPromise",
+        std::function<void()>([]() noexcept {}),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        2);
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticVoidPromiseError) {
+    m_builderMock.Call2(
+        L"staticVoidPromise",
+        std::function<void()>([]() noexcept {}),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Odd unexpected"); }),
+        3);
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticResolveSayHelloPromise) {
+    m_builderMock.Call2(
+        L"StaticResolveSayHelloPromise",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+    TestCheck(m_builderMock.IsResolveCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodCall_StaticRejectSayHelloPromise) {
+    m_builderMock.Call2(
+        L"StaticRejectSayHelloPromise",
+        std::function<void(const std::string &)>(
+            [](const std::string &result) noexcept { TestCheck(result == "Hello_4"); }),
+        std::function<void(React::JSValue const &)>(
+            [](React::JSValue const &error) noexcept { TestCheck(error["message"] == "Promise rejected"); }));
+    TestCheck(m_builderMock.IsRejectCallbackCalled());
+  }
+
+  TEST_METHOD(TestMethodSyncCall_AddSync) {
+    int result;
+    m_builderMock.CallSync(L"AddSync", /*out*/ result, 3, 5);
+    TestCheck(result == 8);
+  }
+
+  TEST_METHOD(TestMethodSyncCall_NegateSync) {
+    int result;
+    m_builderMock.CallSync(L"NegateSync", /*out*/ result, 7);
+    TestCheck(result == -7);
+  }
+
+  TEST_METHOD(TestMethodSyncCall_SayHelloSync) {
+    std::string result;
+    m_builderMock.CallSync(L"SayHelloSync", /*out*/ result);
+    TestCheck(result == "Hello");
+  }
+
+  TEST_METHOD(TestMethodSyncCall_StaticAddSync) {
+    int result;
+    m_builderMock.CallSync(L"StaticAddSync", /*out*/ result, 3, 5);
+    TestCheck(result == 8);
+  }
+
+  TEST_METHOD(TestMethodSyncCall_StaticNegateSync) {
+    int result;
+    m_builderMock.CallSync(L"StaticNegateSync", /*out*/ result, 7);
+    TestCheck(result == -7);
+  }
+
+  TEST_METHOD(TestMethodSyncCall_StaticSayHelloSync) {
+    std::string result;
+    m_builderMock.CallSync(L"StaticSayHelloSync", /*out*/ result);
+    TestCheck(result == "Hello");
+  }
+
+  TEST_METHOD(TestConstants) {
+    auto constants = m_builderMock.GetConstants();
+    TestCheck(constants["Constant1"] == "MyConstant1");
+    TestCheck(constants["const2"] == "MyConstant2");
+    TestCheck(constants["const3"]["X"] == 2);
+    TestCheck(constants["const3"]["Y"] == 3);
+    TestCheck(constants["Constant4"]["X"] == 3);
+    TestCheck(constants["Constant4"]["Y"] == 4);
+    TestCheck(constants["const51"]["X"] == 12);
+    TestCheck(constants["const51"]["Y"] == 14);
+    TestCheck(constants["const52"] == "MyConstant52");
+    TestCheck(constants["const61"]["X"] == 15);
+    TestCheck(constants["const61"]["Y"] == 17);
+    TestCheck(constants["const62"] == "MyConstant62");
+  }
+
+  TEST_METHOD(TestEvent_IntEventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"RCTDeviceEventEmitter", L"OnIntEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0] == 42);
+          eventRaised = true;
+        });
+
+    m_module->OnIntEvent(42);
+    TestCheck(eventRaised);
+  }
+
+  TEST_METHOD(TestEvent_OnNoArgEventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"RCTDeviceEventEmitter", L"OnNoArgEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheckEqual(0, args.size());
+          eventRaised = true;
+        });
+
+    m_module->OnNoArgEvent();
+    TestCheck(eventRaised);
+  }
+
+  TEST_METHOD(TestEvent_TwoArgsEventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"RCTDeviceEventEmitter", L"OnTwoArgsEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheckEqual(4, args[0]["X"]);
+          TestCheckEqual(2, args[0]["Y"]);
+          TestCheckEqual(12, args[1]["X"]);
+          TestCheckEqual(18, args[1]["Y"]);
+          eventRaised = true;
+        });
+
+    m_module->OnTwoArgsEvent(Point{/*X =*/4, /*Y =*/2}, Point{/*X =*/12, /*Y =*/18});
+    TestCheck(eventRaised);
+  }
+
+  TEST_METHOD(TestEvent_JSNameEventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"RCTDeviceEventEmitter", L"onPointEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0]["X"] == 4);
+          TestCheck(args[0]["Y"] == 2);
+          eventRaised = true;
+        });
+
+    m_module->OnPointEvent(Point{/*X =*/4, /*Y =*/2});
+    TestCheck(eventRaised == true);
+  }
+
+  TEST_METHOD(TestEvent_JSEventEmitterEventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"MyEventEmitter", L"onStringEvent", [&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheckEqual("Hello World!", args[0]);
+          eventRaised = true;
+        });
+
+    m_module->OnStringEvent("Hello World!");
+    TestCheck(eventRaised == true);
+  }
+
+  TEST_METHOD(TestEvent_JSValueObjectEventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0]["X"] == 4);
+          TestCheck(args[0]["Y"] == 2);
+          eventRaised = true;
+        }));
+
+    m_module->OnJSValueEvent(React::JSValueObject{{"X", 4}, {"Y", 2}});
+    TestCheck(eventRaised == true);
+  }
+
+  TEST_METHOD(TestEvent_JSValueArrayEventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0][0] == "X");
+          TestCheck(args[0][1] == 4);
+          TestCheck(args[0][2] == true);
+          TestCheck(args[0][3]["Id"] == 42);
+          eventRaised = true;
+        }));
+
+    m_module->OnJSValueEvent(React::JSValueArray{"X", 4, true, React::JSValueObject{{"Id", 42}}});
+    TestCheck(eventRaised == true);
+  }
+
+  TEST_METHOD(TestEvent_JSValueArray1EventField) {
+    bool eventRaised = false;
+    m_builderMock.ExpectEvent(
+        L"RCTDeviceEventEmitter", L"OnJSValueEvent", ([&eventRaised](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0][0] == 4);
+          eventRaised = true;
+        }));
+
+    m_module->OnJSValueEvent(React::JSValueArray{4});
+    TestCheck(eventRaised == true);
+  }
+
+  TEST_METHOD(TestFunction_JSIntFunctionField) {
+    bool functionCalled = false;
+    m_builderMock.ExpectFunction(
+        L"MyTurboModule", L"JSIntFunction", [&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0] == 42);
+          functionCalled = true;
+        });
+
+    m_module->JSIntFunction(42);
+    TestCheck(functionCalled);
+  }
+
+  TEST_METHOD(TestFunction_JSNameFunctionField) {
+    bool functionCalled = false;
+    m_builderMock.ExpectFunction(
+        L"MyTurboModule", L"pointFunc", [&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0]["X"] == 4);
+          TestCheck(args[0]["Y"] == 2);
+          functionCalled = true;
+        });
+
+    m_module->JSPointFunction(Point{/*X =*/4, /*Y =*/2});
+    TestCheck(functionCalled == true);
+  }
+
+  TEST_METHOD(TestFunction_TwoArgFunctionField) {
+    bool functionCalled = false;
+    m_builderMock.ExpectFunction(
+        L"MyTurboModule", L"lineFunc", [&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0]["X"] == 4);
+          TestCheck(args[0]["Y"] == 2);
+          TestCheck(args[1]["X"] == 12);
+          TestCheck(args[1]["Y"] == 18);
+          functionCalled = true;
+        });
+
+    m_module->JSLineFunction(Point{/*X =*/4, /*Y =*/2}, Point{/*X =*/12, /*Y =*/18});
+    TestCheck(functionCalled == true);
+  }
+
+  TEST_METHOD(TestFunction_NoArgFunctionField) {
+    bool functionCalled = false;
+    m_builderMock.ExpectFunction(
+        L"MyTurboModule", L"JSNoArgFunction", [&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheckEqual(0, args.size());
+          functionCalled = true;
+        });
+
+    m_module->JSNoArgFunction();
+    TestCheck(functionCalled);
+  }
+
+  TEST_METHOD(TestFunction_JSModuleNameFunctionField) {
+    bool functionCalled = false;
+    m_builderMock.ExpectFunction(
+        L"MyModule", L"stringFunc", [&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0] == "Hello World!");
+          functionCalled = true;
+        });
+
+    m_module->JSStringFunction("Hello World!");
+    TestCheck(functionCalled == true);
+  }
+
+  TEST_METHOD(TestFunction_JSValueObjectFunctionField) {
+    bool functionCalled = false;
+    m_builderMock.ExpectFunction(
+        L"MyTurboModule", L"JSValueFunction", ([&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0]["X"] == 4);
+          TestCheck(args[0]["Y"] == 2);
+          functionCalled = true;
+        }));
+
+    m_module->JSValueFunction(React::JSValueObject{{"X", 4}, {"Y", 2}});
+    TestCheck(functionCalled == true);
+  }
+
+  TEST_METHOD(TestFunction_JSValueArrayFunctionField) {
+    bool functionCalled = false;
+    m_builderMock.ExpectFunction(
+        L"MyTurboModule", L"JSValueFunction", ([&functionCalled](React::JSValueArray const &args) noexcept {
+          TestCheck(args[0][0] == "X");
+          TestCheck(args[0][1] == 4);
+          TestCheck(args[0][2] == true);
+          TestCheck(args[0][3]["Id"] == 42);
+          functionCalled = true;
+        }));
+
+    m_module->JSValueFunction(React::JSValueArray{"X", 4, true, React::JSValueObject{{"Id", 42}}});
+    TestCheck(functionCalled == true);
+  }
+
+  TEST_METHOD(TestInitialized) {
+    TestCheck(m_module->IsInitialized);
+  }
+};
+
+} // namespace ReactNativeTests
diff --git a/vnext/Microsoft.ReactNative.Cxx/ModuleRegistration.h b/vnext/Microsoft.ReactNative.Cxx/ModuleRegistration.h
index 03916ce88e4..9f8979006d0 100644
--- a/vnext/Microsoft.ReactNative.Cxx/ModuleRegistration.h
+++ b/vnext/Microsoft.ReactNative.Cxx/ModuleRegistration.h
@@ -34,13 +34,13 @@
   template struct moduleStruct##_ModuleRegistration<int>;                                                           \
                                                                                                                     \
   template <class TRegistry>                                                                                        \
-  constexpr void RegisterModule(TRegistry &registry) noexcept {                                                     \
+  constexpr void GetReactModuleInfo(moduleStruct *, TRegistry &registry) noexcept {                                 \
     registry.RegisterModule(                                                                                        \
-        moduleName, eventEmitterName, winrt::Microsoft::ReactNative::ReactMemberId<__COUNTER__>{});                 \
+        moduleName, eventEmitterName, winrt::Microsoft::ReactNative::ReactAttributeId<__COUNTER__>{});              \
   }
 
 #define INTERNAL_REACT_MODULE_2_ARGS(moduleStruct, moduleName) \
-  INTERNAL_REACT_MODULE_3_ARGS(moduleStruct, moduleName, nullptr)
+  INTERNAL_REACT_MODULE_3_ARGS(moduleStruct, moduleName, L"")
 
 #define INTERNAL_REACT_MODULE_1_ARG(moduleStruct) INTERNAL_REACT_MODULE_2_ARGS(moduleStruct, L## #moduleStruct)
 
@@ -48,21 +48,24 @@
   INTERNAL_REACT_RECOMPOSER_4(     \
       (__VA_ARGS__, INTERNAL_REACT_MODULE_3_ARGS, INTERNAL_REACT_MODULE_2_ARGS, INTERNAL_REACT_MODULE_1_ARG, ))
 
-// Register struct member.
-// For each registered member we create a static method that registers it.
+// Provide meta data information about struct member.
+// For each member with a 'custom attribute' macro we create a static method to provide meta data.
 // The member Id is generated as a ReactMemberId<__COUNTER__> type.
-// To invoke the static registration methods, we increment ReactMemberId while static member exists.
-#define INTERNAL_REACT_MEMBER_4_ARGS(memberType, member, memberName, moduleName)                 \
-  template <class TClass, class TRegistry>                                                       \
-  constexpr static void RegisterMember(                                                          \
-      TRegistry &registry, winrt::Microsoft::ReactNative::ReactMemberId<__COUNTER__>) noexcept { \
-    registry.Register##memberType(&TClass::member, memberName, moduleName);                      \
+// To enumerate the static methods, we can increment ReactMemberId while static member exists.
+#define INTERNAL_REACT_MEMBER_4_ARGS(memberKind, member, jsMemberName, jsModuleName)                          \
+  template <class TStruct, class TVisitor>                                                                    \
+  constexpr static void GetReactMemberAttribute(                                                              \
+      TVisitor &visitor, winrt::Microsoft::ReactNative::ReactAttributeId<__COUNTER__> attributeId) noexcept { \
+    visitor.Visit(                                                                                            \
+        &TStruct::member,                                                                                     \
+        attributeId,                                                                                          \
+        winrt::Microsoft::ReactNative::React##memberKind##Attribute{jsMemberName, jsModuleName});             \
   }
 
-#define INTERNAL_REACT_MEMBER_3_ARGS(memberType, member, memberName) \
-  INTERNAL_REACT_MEMBER_4_ARGS(memberType, member, memberName, nullptr)
+#define INTERNAL_REACT_MEMBER_3_ARGS(memberKind, member, jsMemberName) \
+  INTERNAL_REACT_MEMBER_4_ARGS(memberKind, member, jsMemberName, L"")
 
-#define INTERNAL_REACT_MEMBER_2_ARGS(memberType, member) INTERNAL_REACT_MEMBER_3_ARGS(memberType, member, L## #member)
+#define INTERNAL_REACT_MEMBER_2_ARGS(memberKind, member) INTERNAL_REACT_MEMBER_3_ARGS(memberKind, member, L## #member)
 
 #define INTERNAL_REACT_MEMBER(...) \
   INTERNAL_REACT_RECOMPOSER_4(     \
diff --git a/vnext/Microsoft.ReactNative.Cxx/NativeModules.h b/vnext/Microsoft.ReactNative.Cxx/NativeModules.h
index 305709f3aa6..a7070651b62 100644
--- a/vnext/Microsoft.ReactNative.Cxx/NativeModules.h
+++ b/vnext/Microsoft.ReactNative.Cxx/NativeModules.h
@@ -9,6 +9,7 @@
 #include "ModuleRegistration.h"
 #include "ReactPromise.h"
 
+#include <functional>
 #include <type_traits>
 
 // REACT_MODULE(moduleStruct, [opt] moduleName, [opt] eventEmitterName)
@@ -47,7 +48,7 @@
 // - Return non-void value. In JavaScript it is treated as a method with one Callback. Return std::pair<Error, Value> to
 //   be able to communicate error condition.
 // It can be an instance or static method.
-#define REACT_METHOD(/* method, [opt] methodName */...) INTERNAL_REACT_MEMBER(__VA_ARGS__)(Method, __VA_ARGS__)
+#define REACT_METHOD(/* method, [opt] methodName */...) INTERNAL_REACT_MEMBER(__VA_ARGS__)(AsyncMethod, __VA_ARGS__)
 
 // REACT_SYNC_METHOD(method, [opt] methodName)
 // Arguments:
@@ -105,39 +106,165 @@
 #define REACT_FUNCTION(/* field, [opt] functionName, [opt] moduleName */...) \
   INTERNAL_REACT_MEMBER(__VA_ARGS__)(FunctionField, __VA_ARGS__)
 
+#define REACT_SHOW_METHOD_SIGNATURES(methodName, signatures)                      \
+  " (see details below in output).\n"                                             \
+  "  It must be one of the following:\n" signatures                               \
+  "  The C++ method name could be different. In that case add the L\"" methodName \
+  "\" to the attribute:\n"                                                        \
+  "    REACT_METHOD(method, L\"" methodName "\")\n...\n"
+
+#define REACT_SHOW_SYNC_METHOD_SIGNATURES(methodName, signatures)                 \
+  " (see details below in output).\n"                                             \
+  "  It must be one of the following:\n" signatures                               \
+  "  The C++ method name could be different. In that case add the L\"" methodName \
+  "\" to the attribute:\n"                                                        \
+  "    REACT_SYNC_METHOD(method, L\"" methodName "\")\n...\n"
+
+#define REACT_SHOW_METHOD_SPEC_ERRORS(index, methodName, signatures)                                        \
+  static_assert(methodCheckResults[index].IsUniqueName, "Name '" methodName "' used for multiple methods"); \
+  static_assert(                                                                                            \
+      methodCheckResults[index].IsMethodFound,                                                              \
+      "Method '" methodName "' is not defined" REACT_SHOW_METHOD_SIGNATURES(methodName, signatures));       \
+  static_assert(                                                                                            \
+      methodCheckResults[index].IsSignatureMatching,                                                        \
+      "Method '" methodName "' does not match signature" REACT_SHOW_METHOD_SIGNATURES(methodName, signatures));
+
+#define REACT_SHOW_SYNC_METHOD_SPEC_ERRORS(index, methodName, signatures)                                   \
+  static_assert(methodCheckResults[index].IsUniqueName, "Name '" methodName "' used for multiple methods"); \
+  static_assert(                                                                                            \
+      methodCheckResults[index].IsMethodFound,                                                              \
+      "Method '" methodName "' is not defined" REACT_SHOW_SYNC_METHOD_SIGNATURES(methodName, signatures));  \
+  static_assert(                                                                                            \
+      methodCheckResults[index].IsSignatureMatching,                                                        \
+      "Method '" methodName "' does not match signature" REACT_SHOW_SYNC_METHOD_SIGNATURES(methodName, signatures));
+
+//
+// Code below helps to register React native modules and verify method signatures
+// against specification.
+//
+
 namespace winrt::Microsoft::ReactNative {
 
-namespace Internal {
+// Often used to create a tuple with arguments or to create a method signature.
+template <class T>
+using RemoveConstRef = std::remove_const_t<std::remove_reference_t<T>>;
 
-// Checks if provided type has a callback-like signature TFunc<void(TArgs...)
+// Checks if type T has a callback-like signature TFunc<void(TArgs...)
 template <class T>
 struct IsCallback : std::false_type {};
-template <template <class...> class TFunc, class... TArgs>
+template <template <class> class TFunc, class... TArgs>
 struct IsCallback<TFunc<void(TArgs...)>> : std::true_type {};
 #if defined(__cpp_noexcept_function_type) || (_HAS_NOEXCEPT_FUNCTION_TYPES == 1)
-template <template <class...> class TFunc, class... TArgs>
+template <template <class> class TFunc, class... TArgs>
 struct IsCallback<TFunc<void(TArgs...) noexcept>> : std::true_type {};
 #endif
 
-// Finds how many callbacks the function signature has.
-template <class... TArgs>
+// Finds how many callbacks the function signature has in the end: 0, 1, or 2.
+template <class TArgsTuple>
 constexpr size_t GetCallbackCount() noexcept {
-  using TupleType = std::tuple<std::remove_const_t<std::remove_reference_t<TArgs>>...>;
-  if constexpr (sizeof...(TArgs) >= 2) {
-    return (IsCallback<std::tuple_element_t<sizeof...(TArgs) - 1u, TupleType>>::value ? 1 : 0) +
-        (IsCallback<std::tuple_element_t<sizeof...(TArgs) - 2u, TupleType>>::value ? 1 : 0);
-  } else if constexpr (sizeof...(TArgs) == 1) {
-    return IsCallback<std::tuple_element_t<0, TupleType>>::value ? 1 : 0;
+  if constexpr (std::tuple_size_v<TArgsTuple> >= 2) {
+    return (IsCallback<std::tuple_element_t<std::tuple_size_v<TArgsTuple> - 1, TArgsTuple>>::value ? 1 : 0) +
+        (IsCallback<std::tuple_element_t<std::tuple_size_v<TArgsTuple> - 2, TArgsTuple>>::value ? 1 : 0);
+  } else if constexpr (std::tuple_size_v<TArgsTuple> == 1) {
+    return IsCallback<std::tuple_element_t<0, TArgsTuple>>::value ? 1 : 0;
   } else {
     return 0;
   }
 }
 
+// Callback is any std::function<void(TArgs...)> like type.
+// For the signature comparison we want to use only input arguments.
+template <class... TArgs>
+struct CallbackSignature {};
+
+// ==== GetCallbackSignature ===================================================
+
+template <class T>
+struct GetCallbackSignatureImpl {};
+
+// Get callback signature from a callback.
+template <class TCallback>
+using GetCallbackSignature = typename GetCallbackSignatureImpl<TCallback>::Type;
+
+template <template <class> class TCallback, class... TArgs>
+struct GetCallbackSignatureImpl<TCallback<void(TArgs...)>> {
+  using Type = CallbackSignature<RemoveConstRef<TArgs>...>;
+};
+
+#if defined(__cpp_noexcept_function_type) || (_HAS_NOEXCEPT_FUNCTION_TYPES == 1)
+template <template <class> class TCallback, class... TArgs>
+struct GetCallbackSignatureImpl<TCallback<void(TArgs...) noexcept>> {
+  using Type = CallbackSignature<RemoveConstRef<TArgs>...>;
+};
+#endif
+
+// ==== CallbackCreator ========================================================
+
+template <class T>
+struct CallbackCreator;
+
+template <template <class> class TCallback, class... TArgs>
+struct CallbackCreator<TCallback<void(TArgs...)>> {
+  static TCallback<void(TArgs...)> Create(
+      IJSValueWriter const &argWriter,
+      MethodResultCallback const &callback) noexcept {
+    return TCallback([ callback, argWriter ](TArgs... args) noexcept {
+      WriteArgs(argWriter, std::move(args)...);
+      callback(argWriter);
+    });
+  }
+};
+
+template <template <class> class TCallback, class... TArgs>
+struct CallbackCreator<TCallback<void(TArgs...) noexcept>> {
+  static TCallback<void(TArgs...)> Create(
+      IJSValueWriter const &argWriter,
+      MethodResultCallback const &callback) noexcept {
+    return TCallback([ callback, argWriter ](TArgs... args) noexcept {
+      WriteArgs(argWriter, std::move(args)...);
+      callback(argWriter);
+    });
+  }
+};
+
+// ==== TupleElementOrVoid =====================================================
+
+template <bool, size_t Index, class TTuple>
+struct TupleElementOrVoidImpl {
+  using Type = void;
+};
+
+template <size_t Index, class TTuple>
+struct TupleElementOrVoidImpl<true, Index, TTuple> {
+  using Type = std::tuple_element_t<Index, TTuple>;
+};
+
+template <size_t Index, class TTuple>
+using TupleElementOrVoid = typename TupleElementOrVoidImpl<(Index < std::tuple_size_v<TTuple>), Index, TTuple>::Type;
+
+// Checks if type T is a has a ReactPromise
 template <class T>
 struct IsPromise : std::false_type {};
 template <class T>
 struct IsPromise<ReactPromise<T>> : std::true_type {};
 
+// Return 1 if last parameter is Promise, otherwise 0.
+template <class TArgsTuple>
+constexpr size_t GetPromiseCount() noexcept {
+  if constexpr (
+      std::tuple_size_v<TArgsTuple>> 0 &&
+      IsPromise<TupleElementOrVoid<std::tuple_size_v<TArgsTuple> - 1, TArgsTuple>>::value) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+template <class TResult>
+constexpr bool IsVoidResult() noexcept {
+  return std::is_void_v<TResult> || std::is_same_v<TResult, winrt::fire_and_forget>;
+}
+
 template <class TResult, class TArg>
 constexpr void ValidateCoroutineArg() noexcept {
   if constexpr (std::is_same_v<TResult, fire_and_forget>) {
@@ -147,7 +274,106 @@ constexpr void ValidateCoroutineArg() noexcept {
   }
 }
 
-} // namespace Internal
+// ==== TransformListItems =====================================================
+
+template <template <class...> class TFunc, class TList>
+struct TransformListItemsImpl;
+
+// TransformListItems transforms each variadic item parameter type using TFunc.
+// E.g. std::tuple<int, double> ==> std::tuple<TFunc<int>, TFunc<double>>.
+template <template <class...> class TFunc, class TList>
+using TransformListItems = typename TransformListItemsImpl<TFunc, TList>::Type;
+
+template <template <class...> class TFunc, template <class...> class TList, class... TItems>
+struct TransformListItemsImpl<TFunc, TList<TItems...>> {
+  using Type = TList<TFunc<TItems>...>;
+};
+
+// ==== TakeTupleElements ======================================================
+
+template <size_t StartIndex, class TIndexSequence, class TTuple>
+struct TakeTupleElementsImpl;
+
+// Take Count tuple type parameters starting with StartIndex from TTuple.
+template <size_t StartIndex, size_t Count, class TTuple>
+using TakeTupleElements = typename TakeTupleElementsImpl<StartIndex, std::make_index_sequence<Count>, TTuple>::Type;
+
+template <size_t StartIndex, class TTuple, size_t... Index>
+struct TakeTupleElementsImpl<StartIndex, std::index_sequence<Index...>, TTuple> {
+  using Type = std::tuple<std::tuple_element_t<StartIndex + Index, TTuple>...>;
+};
+
+//==============================================================================
+// MethodSignature is used to compare method signatures.
+//==============================================================================
+
+struct MethodSignatureMatchResult {
+  int ArgCountCompare;
+  int CallbackCountCompare;
+  bool IsResultMatching;
+  bool AreArgsMatching;
+  bool AreCallbacksMatching;
+  bool IsPromiseMathcing;
+  bool IsSucceeded;
+};
+
+template <class TResult, class TInputArgs, class TOutputCallbacks, class TOutputPromises>
+struct MethodSignature {
+  using Result = TResult;
+  using InputArgs = TInputArgs;
+  using OutputCallbacks = TOutputCallbacks;
+  using OutputPromises = TOutputPromises;
+  constexpr static size_t ArgCount = std::tuple_size_v<InputArgs>;
+  constexpr static size_t CallbackCount = std::tuple_size_v<TOutputCallbacks>;
+
+  static constexpr int CompareSize(size_t left, size_t right) noexcept {
+    if (left < right) {
+      return -1;
+    } else if (right < left) {
+      return 1;
+    } else {
+      return 0;
+    }
+  }
+
+  template <class TOtherInputArgs, size_t... I>
+  static constexpr bool MatchInputArgs(std::index_sequence<I...>) noexcept {
+    return (std::is_same_v<std::tuple_element_t<I, InputArgs>, std::tuple_element_t<I, TOtherInputArgs>> && ...);
+  }
+
+  template <class TOtherOutputCallbacks, size_t... I>
+  static constexpr bool MatchOutputCallbacks(std::index_sequence<I...>) noexcept {
+    return (
+        std::is_same_v<std::tuple_element_t<I, OutputCallbacks>, std::tuple_element_t<I, TOtherOutputCallbacks>> &&
+        ...);
+  }
+
+  template <class TOtherMethodSignature>
+  static constexpr MethodSignatureMatchResult Match() noexcept {
+    MethodSignatureMatchResult result{};
+
+    result.IsResultMatching = std::is_same_v<Result, typename TOtherMethodSignature::Result>;
+
+    result.ArgCountCompare = CompareSize(ArgCount, TOtherMethodSignature::ArgCount);
+    if (result.ArgCountCompare == 0) {
+      result.AreArgsMatching =
+          MatchInputArgs<typename TOtherMethodSignature::InputArgs>(std::make_index_sequence<ArgCount>{});
+    }
+
+    result.CallbackCountCompare = CompareSize(CallbackCount, TOtherMethodSignature::CallbackCount);
+    if (result.CallbackCountCompare == 0) {
+      result.AreCallbacksMatching = MatchOutputCallbacks<typename TOtherMethodSignature::OutputCallbacks>(
+          std::make_index_sequence<CallbackCount>{});
+    }
+
+    result.IsPromiseMathcing = std::is_same_v<OutputPromises, typename TOtherMethodSignature::OutputPromises>;
+
+    result.IsSucceeded = result.IsResultMatching && result.ArgCountCompare == 0 && result.AreArgsMatching &&
+        result.CallbackCountCompare == 0 && result.AreCallbacksMatching && result.IsPromiseMathcing;
+
+    return result;
+  }
+};
 
 //==============================================================================
 // Module registration helpers
@@ -168,438 +394,266 @@ struct ModuleInitMethodInfo<void (TModule::*)(IReactContext const &) noexcept> {
   }
 };
 
-template <class TFunc>
-struct ModuleMethodInfo;
+// ==== MakeCallbackSignatures =================================================
 
-// Instance asynchronous method
-template <class TModule, class TResult, class... TArgs>
-struct ModuleMethodInfo<TResult (TModule::*)(TArgs...) noexcept> {
-  constexpr static bool HasPromise() noexcept {
-    if constexpr (sizeof...(TArgs) > 0) {
-      return Internal::IsPromise<std::remove_const_t<std::remove_reference_t<
-          std::tuple_element_t<sizeof...(TArgs) - 1, std::tuple<std::remove_reference_t<TArgs>...>>>>>::value;
-    }
-    return false;
-  }
+template <class TResult, class TOutputCallbackTuple>
+struct MakeCallbackSignaturesImpl {
+  using Type = std::tuple<CallbackSignature<TResult>>;
+};
 
-  constexpr static size_t CallbackCount = Internal::GetCallbackCount<TArgs...>();
-  using ModuleType = TModule;
-  using MethodType = TResult (TModule::*)(TArgs...) noexcept;
-  using IndexSequence = std::make_index_sequence<sizeof...(TArgs) - (HasPromise() ? 1 : CallbackCount)>;
+template <class TOutputCallbackTuple>
+struct MakeCallbackSignaturesImpl<void, TOutputCallbackTuple> {
+  using Type = TransformListItems<GetCallbackSignature, TOutputCallbackTuple>;
+};
 
-  template <class>
-  struct Invoker;
+template <class TOutputCallbackTuple>
+struct MakeCallbackSignaturesImpl<winrt::fire_and_forget, TOutputCallbackTuple> {
+  using Type = TransformListItems<GetCallbackSignature, TOutputCallbackTuple>;
+};
 
-  template <size_t... I>
-  struct Invoker<std::index_sequence<I...>> {
-    // Fire and forget method
-    static MethodDelegate GetFunc(ModuleType *module, MethodType method, std::integral_constant<size_t, 0>) noexcept {
-      return [ module, method ](
-          IJSValueReader const &argReader,
-          IJSValueWriter const & /*argWriter*/,
-          MethodResultCallback const &,
-          MethodResultCallback const &) mutable noexcept {
-        std::tuple<std::remove_reference_t<TArgs>...> typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        (module->*method)(std::get<I>(std::move(typedArgs))...);
-      };
-    }
+template <class TResult, class TOutputCallbackTuple>
+using MakeCallbackSignatures = typename MakeCallbackSignaturesImpl<TResult, TOutputCallbackTuple>::Type;
 
-    template <class T>
-    struct CallbackCreator;
-
-    template <template <class...> class TCallback, class... TArgs>
-    struct CallbackCreator<TCallback<void(TArgs...)>> {
-      static TCallback<void(TArgs...)> Create(
-          const IJSValueWriter &argWriter,
-          const MethodResultCallback &callback) noexcept {
-        return TCallback([ callback = std::move(callback), argWriter ](TArgs... args) noexcept {
-          WriteArgs(argWriter, std::move(args)...);
-          callback(argWriter);
-        });
-      }
-    };
+template <class TMethodSignature, class TMethodSpecSignature>
+constexpr static bool MatchMethodSignature() noexcept {
+  constexpr MethodSignatureMatchResult matchResult = TMethodSignature::template Match<TMethodSpecSignature>();
 
-    template <class T, class TDummy>
-    struct RejectCallbackCreator;
-
-    template <template <class...> class TCallback, class TArg>
-    struct RejectCallbackCreator<
-        TCallback<void(TArg)>,
-        std::enable_if_t<std::is_assignable_v<std::string, TArg> || std::is_assignable_v<std::wstring, TArg>>> {
-      static TCallback<void(TArg)> Create(
-          const IJSValueWriter &argWriter,
-          const MethodResultCallback &callback) noexcept {
-        return TCallback([ callback = std::move(callback), argWriter ](TArg arg) noexcept {
-          argWriter.WriteArrayBegin();
-          argWriter.WriteObjectBegin();
-          argWriter.WritePropertyName(L"message");
-          WriteValue(argWriter, arg);
-          argWriter.WriteObjectEnd();
-          argWriter.WriteArrayEnd();
-          callback(argWriter);
-        });
-      }
-    };
+  static_assert(matchResult.IsResultMatching, "Method return type is different from the method spec.");
 
-    template <template <class...> class TCallback>
-    struct RejectCallbackCreator<TCallback<void()>, void> : CallbackCreator<TCallback<void()>> {};
-
-    template <template <class...> class TCallback, class TArg>
-    struct RejectCallbackCreator<
-        TCallback<void(TArg)>,
-        std::enable_if_t<!std::is_assignable_v<std::string, TArg> && !std::is_assignable_v<std::wstring, TArg>>>
-        : CallbackCreator<TCallback<void(TArg)>> {};
-
-    template <template <class...> class TCallback, class TArg0, class TArg1, class... TArgs>
-    struct RejectCallbackCreator<TCallback<void(TArg0, TArg1, TArgs...)>, void>
-        : CallbackCreator<TCallback<void(TArg0, TArg1, TArgs...)>> {};
-
-    template <class T>
-    struct PromiseCreator;
-
-    template <class T>
-    struct PromiseCreator<ReactPromise<T>> {
-      static ReactPromise<T> Create(
-          const IJSValueWriter &argWriter,
-          const MethodResultCallback &resolve,
-          const MethodResultCallback &reject) noexcept {
-        return ReactPromise<T>(argWriter, resolve, reject);
-      }
-    };
+  static_assert(matchResult.ArgCountCompare >= 0, "Method has less arguments than method spec.");
+  static_assert(matchResult.ArgCountCompare <= 0, "Method has more arguments than method spec.");
+  if constexpr (matchResult.ArgCountCompare == 0) {
+    static_assert(matchResult.AreArgsMatching, "Method argument types are different from the method spec.");
+  }
 
-    // Method with one callback
-    static MethodDelegate GetFunc(ModuleType *module, MethodType method, std::integral_constant<size_t, 1>) noexcept {
-      return [ module, method ](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &callback,
-          MethodResultCallback const &) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        auto cb = CallbackCreator<std::remove_const_t<std::remove_reference_t<
-            std::tuple_element_t<sizeof...(TArgs) - 1, ArgTuple>>>>::Create(argWriter, callback);
-        (module->*method)(std::get<I>(std::move(typedArgs))..., std::move(cb));
-      };
-    }
+  static_assert(matchResult.CallbackCountCompare >= 0, "Method has less callbacks than method spec.");
+  static_assert(matchResult.CallbackCountCompare <= 0, "Method has more callbacks than method spec.");
+  if constexpr (matchResult.CallbackCountCompare == 0) {
+    static_assert(matchResult.AreCallbacksMatching, "Method callback types are different from the method spec.");
+  }
 
-    // Method with two callbacks
-    static MethodDelegate GetFunc(ModuleType *module, MethodType method, std::integral_constant<size_t, 2>) noexcept {
-      return [ module, method ](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &resolve,
-          MethodResultCallback const &reject) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        // Some native modules use first callback as failure, others use second. We make them both to
-        // behave the same way and let developers to assign meaning to the first and second callbacks.
-        auto firstCallback = CallbackCreator<std::remove_const_t<
-            std::remove_reference_t<std::tuple_element_t<sizeof...(TArgs) - 2, ArgTuple>>>>::Create(argWriter, resolve);
-        auto secondCallback = CallbackCreator<std::remove_const_t<
-            std::remove_reference_t<std::tuple_element_t<sizeof...(TArgs) - 1, ArgTuple>>>>::Create(argWriter, reject);
-        (module->*method)(std::get<I>(std::move(typedArgs))..., std::move(firstCallback), std::move(secondCallback));
-      };
-    }
+  static_assert(matchResult.IsPromiseMathcing, "Method Promise type is different from the method spec.");
 
-    // Method with Promise
-    static MethodDelegate GetFunc(ModuleType *module, MethodType method, std::integral_constant<size_t, 3>) noexcept {
-      return [ module, method ](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &resolve,
-          MethodResultCallback const &reject) mutable noexcept {
-        using AllArgsTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        using ArgsTuple = std::tuple<std::tuple_element_t<I, AllArgsTuple>...>;
-        using PromiseArg = std::remove_const_t<std::tuple_element_t<sizeof...(TArgs) - 1, AllArgsTuple>>;
-        ArgsTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        auto promise = PromiseCreator<PromiseArg>::Create(argWriter, resolve, reject);
-        (module->*method)(std::get<I>(std::move(typedArgs))..., std::move(promise));
-      };
-    }
+  return matchResult.IsSucceeded;
+}
 
-    // Async method with return value
-    static MethodDelegate GetFunc(ModuleType *module, MethodType method, std::integral_constant<size_t, 4>) noexcept {
-      return [ module, method ](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &callback,
-          MethodResultCallback const &) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        TResult result = (module->*method)(std::get<I>(std::move(typedArgs))...);
-        WriteArgs(argWriter, result);
-        callback(argWriter);
-      };
-    }
-  };
+template <class TSignature>
+struct ModuleMethodInfoBase;
 
-  static MethodDelegate GetMethodDelegate(void *module, MethodType method, MethodReturnType &returnType) noexcept {
-    (Internal::ValidateCoroutineArg<TResult, TArgs>(), ...);
-    constexpr bool isVoidResult = std::is_void_v<TResult> || std::is_same_v<TResult, winrt::fire_and_forget>;
-    if constexpr (!isVoidResult) {
-      returnType = MethodReturnType::Callback;
-    } else if constexpr (HasPromise()) {
-      returnType = MethodReturnType::Promise;
+template <class TResult, class... TArgs>
+struct ModuleMethodInfoBase<TResult(TArgs...) noexcept> {
+  constexpr static bool IsVoidResult = IsVoidResult<TResult>();
+  constexpr static size_t ArgCount = sizeof...(TArgs);
+  using ArgTuple = std::tuple<RemoveConstRef<TArgs>...>;
+  constexpr static size_t CallbackCount = GetCallbackCount<ArgTuple>();
+  constexpr static size_t PromiseCount = GetPromiseCount<ArgTuple>();
+  constexpr static size_t InputArgCount = ArgCount - CallbackCount - PromiseCount;
+  using InputArgTuple = TakeTupleElements<0, InputArgCount, ArgTuple>;
+  using OutputCallbackTuple = TakeTupleElements<InputArgCount, CallbackCount, ArgTuple>;
+  using OutputPromiseTuple = TakeTupleElements<InputArgCount, PromiseCount, ArgTuple>;
+
+  using Signature =
+      MethodSignature<void, InputArgTuple, MakeCallbackSignatures<TResult, OutputCallbackTuple>, OutputPromiseTuple>;
+
+  constexpr static MethodReturnType GetMethodReturnType() noexcept {
+    if constexpr (!IsVoidResult) {
+      return MethodReturnType::Callback;
+    } else if constexpr (PromiseCount == 1) {
+      return MethodReturnType::Promise;
     } else if constexpr (CallbackCount == 2) {
-      returnType = MethodReturnType::TwoCallbacks;
+      return MethodReturnType::TwoCallbacks;
     } else if constexpr (CallbackCount == 1) {
-      returnType = MethodReturnType::Callback;
+      return MethodReturnType::Callback;
     } else {
-      returnType = MethodReturnType::Void;
+      return MethodReturnType::Void;
     }
-
-    constexpr int selector = !isVoidResult ? 4 : HasPromise() ? 3 : CallbackCount;
-    return Invoker<IndexSequence>::GetFunc(
-        static_cast<ModuleType *>(module), method, std::integral_constant<size_t, selector>{});
   }
 };
 
-// Static asynchronous method
-template <class TResult, class... TArgs>
-struct ModuleMethodInfo<TResult (*)(TArgs...) noexcept> {
-  constexpr static bool HasPromise() noexcept {
-    if constexpr (sizeof...(TArgs) > 0) {
-      return Internal::IsPromise<std::remove_const_t<std::remove_reference_t<
-          std::tuple_element_t<sizeof...(TArgs) - 1, std::tuple<std::remove_reference_t<TArgs>...>>>>>::value;
-    }
-    return false;
-  }
-
-  constexpr static size_t CallbackCount = Internal::GetCallbackCount<TArgs...>();
-  using MethodType = TResult (*)(TArgs...) noexcept;
-  using IndexSequence = std::make_index_sequence<sizeof...(TArgs) - (HasPromise() ? 1 : CallbackCount)>;
-
-  template <class>
-  struct Invoker;
-
-  template <size_t... I>
-  struct Invoker<std::index_sequence<I...>> {
-    // Fire and forget method
-    static MethodDelegate GetFunc(MethodType method, std::integral_constant<size_t, 0>) noexcept {
-      return [method](
-          IJSValueReader const &argReader,
-          IJSValueWriter const & /*argWriter*/,
-          MethodResultCallback const &,
-          MethodResultCallback const &) mutable noexcept {
-        std::tuple<std::remove_reference_t<TArgs>...> typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        (*method)(std::get<I>(std::move(typedArgs))...);
-      };
-    }
-
-    template <class T>
-    struct CallbackCreator;
-
-    template <template <class...> class TCallback, class... TArgs>
-    struct CallbackCreator<TCallback<void(TArgs...)>> {
-      static TCallback<void(TArgs...)> Create(
-          const IJSValueWriter &argWriter,
-          const MethodResultCallback &callback) noexcept {
-        return TCallback([ callback = std::move(callback), argWriter ](TArgs... args) noexcept {
-          WriteArgs(argWriter, std::move(args)...);
-          callback(argWriter);
-        });
-      }
-    };
+template <class TFunc>
+struct ModuleMethodInfo;
 
-    template <class T, class TDummy>
-    struct RejectCallbackCreator;
-
-    template <template <class...> class TCallback, class TArg>
-    struct RejectCallbackCreator<
-        TCallback<void(TArg)>,
-        std::enable_if_t<std::is_assignable_v<std::string, TArg> || std::is_assignable_v<std::wstring, TArg>>> {
-      static TCallback<void(TArg)> Create(
-          const IJSValueWriter &argWriter,
-          const MethodResultCallback &callback) noexcept {
-        return TCallback([ callback = std::move(callback), argWriter ](TArg arg) noexcept {
-          argWriter.WriteArrayBegin();
-          argWriter.WriteObjectBegin();
-          argWriter.WritePropertyName(L"message");
-          WriteValue(argWriter, arg);
-          argWriter.WriteObjectEnd();
-          argWriter.WriteArrayEnd();
-          callback(argWriter);
-        });
-      }
-    };
+// Instance asynchronous method
+template <class TModule, class TResult, class... TArgs>
+struct ModuleMethodInfo<TResult (TModule::*)(TArgs...) noexcept> : ModuleMethodInfoBase<TResult(TArgs...) noexcept> {
+  using Super = ModuleMethodInfoBase<TResult(TArgs...) noexcept>;
+  using ModuleType = TModule;
+  using MethodType = TResult (TModule::*)(TArgs...) noexcept;
 
-    template <template <class...> class TCallback>
-    struct RejectCallbackCreator<TCallback<void()>, void> : CallbackCreator<TCallback<void()>> {};
-
-    template <template <class...> class TCallback, class TArg>
-    struct RejectCallbackCreator<
-        TCallback<void(TArg)>,
-        std::enable_if_t<!std::is_assignable_v<std::string, TArg> && !std::is_assignable_v<std::wstring, TArg>>>
-        : CallbackCreator<TCallback<void(TArg)>> {};
-
-    template <template <class...> class TCallback, class TArg0, class TArg1, class... TArgs>
-    struct RejectCallbackCreator<TCallback<void(TArg0, TArg1, TArgs...)>, void>
-        : CallbackCreator<TCallback<void(TArg0, TArg1, TArgs...)>> {};
-
-    template <class T>
-    struct PromiseCreator;
-
-    template <class T>
-    struct PromiseCreator<ReactPromise<T>> {
-      static ReactPromise<T> Create(
-          const IJSValueWriter &argWriter,
-          const MethodResultCallback &resolve,
-          const MethodResultCallback &reject) noexcept {
-        return ReactPromise<T>(argWriter, resolve, reject);
+  template <size_t... ArgIndex, size_t... CallbackIndex, size_t... PromiseIndex>
+  static MethodDelegate GetMethodDelegate(
+      ModuleType *module,
+      MethodType method,
+      std::index_sequence<ArgIndex...>,
+      std::index_sequence<CallbackIndex...>,
+      std::index_sequence<PromiseIndex...>) noexcept {
+    return [ module, method ](
+        IJSValueReader const &argReader,
+        [[maybe_unused]] IJSValueWriter const &argWriter,
+        [[maybe_unused]] MethodResultCallback const &resolve,
+        [[maybe_unused]] MethodResultCallback const &reject) mutable noexcept {
+      typename Super::InputArgTuple inputArgs{};
+      ReadArgs(argReader, std::get<ArgIndex>(inputArgs)...);
+      if constexpr (!Super::IsVoidResult) {
+        TResult result = (module->*method)(std::get<ArgIndex>(std::move(inputArgs))...);
+        WriteArgs(argWriter, result);
+        resolve(argWriter);
+      } else if constexpr (Super::PromiseCount == 1) {
+        auto promises = std::tuple{
+            std::tuple_element_t<PromiseIndex, typename Super::OutputPromiseTuple>{argWriter, resolve, reject}...};
+        (module->*method)(std::get<ArgIndex>(std::move(inputArgs))..., std::get<PromiseIndex>(std::move(promises))...);
+      } else {
+        // When method uses two callbacks the order of resolve and reject can be reversed.
+        auto resultCallbacks = std::tuple{resolve, reject};
+        auto callbacks = std::tuple{
+            CallbackCreator<std::tuple_element_t<CallbackIndex, typename Super::OutputCallbackTuple>>::Create(
+                argWriter, std::get<CallbackIndex>(resultCallbacks))...};
+        (module->*method)(
+            std::get<ArgIndex>(std::move(inputArgs))..., std::get<CallbackIndex>(std::move(callbacks))...);
       }
     };
+  }
 
-    // Method with one callback
-    static MethodDelegate GetFunc(MethodType method, std::integral_constant<size_t, 1>) noexcept {
-      return [method](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &callback,
-          MethodResultCallback const &) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        auto cb = CallbackCreator<std::remove_const_t<std::remove_reference_t<
-            std::tuple_element_t<sizeof...(TArgs) - 1, ArgTuple>>>>::Create(argWriter, callback);
-        (*method)(std::get<I>(std::move(typedArgs))..., std::move(cb));
-      };
-    }
+  static MethodDelegate GetMethodDelegate(void *module, MethodType method, MethodReturnType &returnType) noexcept {
+    (ValidateCoroutineArg<TResult, TArgs>(), ...);
+    returnType = Super::GetMethodReturnType();
+    return GetMethodDelegate(
+        static_cast<ModuleType *>(module),
+        method,
+        std::make_index_sequence<Super::InputArgCount>{},
+        std::make_index_sequence<Super::CallbackCount>{},
+        std::make_index_sequence<Super::PromiseCount>{});
+  }
 
-    // Method with two callbacks
-    static MethodDelegate GetFunc(MethodType method, std::integral_constant<size_t, 2>) noexcept {
-      return [method](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &resolve,
-          MethodResultCallback const &reject) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        // Some native modules use first callback as failure, others use second. We make them both to
-        // behave the same way and let developers to assign meaning to the first and second callbacks.
-        auto firstCallback = CallbackCreator<std::remove_const_t<
-            std::remove_reference_t<std::tuple_element_t<sizeof...(TArgs) - 2, ArgTuple>>>>::Create(argWriter, resolve);
-        auto secondCallback = CallbackCreator<std::remove_const_t<
-            std::remove_reference_t<std::tuple_element_t<sizeof...(TArgs) - 1, ArgTuple>>>>::Create(argWriter, reject);
-        (*method)(std::get<I>(std::move(typedArgs))..., std::move(firstCallback), std::move(secondCallback));
-      };
-    }
+  template <class TMethodSpec>
+  static constexpr bool Match() noexcept {
+    // Do not move this method to the ModuleMethodInfoBase for better error reporting.
+    return MatchMethodSignature<typename Super::Signature, typename TMethodSpec::Signature>();
+  }
+};
 
-    // Method with Promise
-    static MethodDelegate GetFunc(MethodType method, std::integral_constant<size_t, 3>) noexcept {
-      return [method](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &resolve,
-          MethodResultCallback const &reject) mutable noexcept {
-        using AllArgsTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        using ArgsTuple = std::tuple<std::tuple_element_t<I, AllArgsTuple>...>;
-        using PromiseArg = std::remove_const_t<std::tuple_element_t<sizeof...(TArgs) - 1, AllArgsTuple>>;
-        ArgsTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        auto promise = PromiseCreator<PromiseArg>::Create(argWriter, resolve, reject);
-        (*method)(std::get<I>(std::move(typedArgs))..., std::move(promise));
-      };
-    }
+// Static asynchronous method
+template <class TResult, class... TArgs>
+struct ModuleMethodInfo<TResult (*)(TArgs...) noexcept> : ModuleMethodInfoBase<TResult(TArgs...) noexcept> {
+  using Super = ModuleMethodInfoBase<TResult(TArgs...) noexcept>;
+  using MethodType = TResult (*)(TArgs...) noexcept;
 
-    // Async method with return value
-    static MethodDelegate GetFunc(MethodType method, std::integral_constant<size_t, 4>) noexcept {
-      return [method](
-          IJSValueReader const &argReader,
-          IJSValueWriter const &argWriter,
-          MethodResultCallback const &callback,
-          MethodResultCallback const &) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        TResult result = (*method)(std::get<I>(typedArgs)...);
+  template <size_t... ArgIndex, size_t... CallbackIndex, size_t... PromiseIndex>
+  static MethodDelegate GetMethodDelegate(
+      MethodType method,
+      std::index_sequence<ArgIndex...>,
+      std::index_sequence<CallbackIndex...>,
+      std::index_sequence<PromiseIndex...>) noexcept {
+    return [method](
+        IJSValueReader const &argReader,
+        [[maybe_unused]] IJSValueWriter const &argWriter,
+        [[maybe_unused]] MethodResultCallback const &resolve,
+        [[maybe_unused]] MethodResultCallback const &reject) mutable noexcept {
+      typename Super::InputArgTuple inputArgs{};
+      ReadArgs(argReader, std::get<ArgIndex>(inputArgs)...);
+      if constexpr (!Super::IsVoidResult) {
+        TResult result = (*method)(std::get<ArgIndex>(std::move(inputArgs))...);
         WriteArgs(argWriter, result);
-        callback(argWriter);
-      };
-    }
-  };
+        resolve(argWriter);
+      } else if constexpr (Super::PromiseCount == 1) {
+        auto promises = std::tuple{
+            std::tuple_element_t<PromiseIndex, typename Super::OutputPromiseTuple>{argWriter, resolve, reject}...};
+        (*method)(std::get<ArgIndex>(std::move(inputArgs))..., std::get<PromiseIndex>(std::move(promises))...);
+      } else {
+        // When method uses two callbacks the order of resolve and reject can be reversed.
+        auto resultCallbacks = std::tuple{resolve, reject};
+        auto callbacks = std::tuple{
+            CallbackCreator<std::tuple_element_t<CallbackIndex, typename Super::OutputCallbackTuple>>::Create(
+                argWriter, std::get<CallbackIndex>(resultCallbacks))...};
+        (*method)(std::get<ArgIndex>(std::move(inputArgs))..., std::get<CallbackIndex>(std::move(callbacks))...);
+      }
+    };
+  }
 
   static MethodDelegate GetMethodDelegate(void * /*module*/, MethodType method, MethodReturnType &returnType) noexcept {
-    (Internal::ValidateCoroutineArg<TResult, TArgs>(), ...);
-    constexpr bool isVoidResult = std::is_void_v<TResult> || std::is_same_v<TResult, winrt::fire_and_forget>;
-    if constexpr (!isVoidResult) {
-      returnType = MethodReturnType::Callback;
-    } else if constexpr (HasPromise()) {
-      returnType = MethodReturnType::Promise;
-    } else if constexpr (CallbackCount == 2) {
-      returnType = MethodReturnType::TwoCallbacks;
-    } else if constexpr (CallbackCount == 1) {
-      returnType = MethodReturnType::Callback;
-    } else {
-      returnType = MethodReturnType::Void;
-    }
+    (ValidateCoroutineArg<TResult, TArgs>(), ...);
+    returnType = Super::GetMethodReturnType();
+    return GetMethodDelegate(
+        method,
+        std::make_index_sequence<Super::InputArgCount>{},
+        std::make_index_sequence<Super::CallbackCount>{},
+        std::make_index_sequence<Super::PromiseCount>{});
+  }
 
-    constexpr int selector = !isVoidResult ? 4 : HasPromise() ? 3 : CallbackCount;
-    return Invoker<IndexSequence>::GetFunc(method, std::integral_constant<size_t, selector>{});
+  template <class TMethodSpec>
+  static constexpr bool Match() noexcept {
+    // Do not move this method to the ModuleMethodInfoBase for better error reporting.
+    return MatchMethodSignature<typename Super::Signature, typename TMethodSpec::Signature>();
   }
 };
 
+template <class TSignature>
+struct ModuleSyncMethodInfoBase;
+
+template <class TResult, class... TArgs>
+struct ModuleSyncMethodInfoBase<TResult(TArgs...) noexcept> {
+  using ArgTuple = std::tuple<RemoveConstRef<TArgs>...>;
+  using Signature = MethodSignature<TResult, ArgTuple, std::tuple<>, std::tuple<>>;
+};
+
 template <class TFunc>
 struct ModuleSyncMethodInfo;
 
 // Instance synchronous method
 template <class TModule, class TResult, class... TArgs>
-struct ModuleSyncMethodInfo<TResult (TModule::*)(TArgs...) noexcept> {
+struct ModuleSyncMethodInfo<TResult (TModule::*)(TArgs...) noexcept>
+    : ModuleSyncMethodInfoBase<TResult(TArgs...) noexcept> {
+  using Super = ModuleSyncMethodInfoBase<TResult(TArgs...) noexcept>;
   using ModuleType = TModule;
   using MethodType = TResult (TModule::*)(TArgs...) noexcept;
-  using IndexSequence = std::make_index_sequence<sizeof...(TArgs)>;
-
-  template <class>
-  struct Invoker;
 
   template <size_t... I>
-  struct Invoker<std::index_sequence<I...>> {
-    static SyncMethodDelegate GetFunc(ModuleType *module, MethodType method) noexcept {
-      return [ module, method ](IJSValueReader const &argReader, IJSValueWriter const &argWriter) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        TResult result = (module->*method)(std::get<I>(std::move(typedArgs))...);
-        WriteArgs(argWriter, result);
-      };
-    }
-  };
+  static SyncMethodDelegate GetFunc(ModuleType *module, MethodType method, std::index_sequence<I...>) noexcept {
+    return [ module, method ](IJSValueReader const &argReader, IJSValueWriter const &argWriter) mutable noexcept {
+      using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
+      ArgTuple typedArgs{};
+      ReadArgs(argReader, std::get<I>(typedArgs)...);
+      TResult result = (module->*method)(std::get<I>(std::move(typedArgs))...);
+      WriteArgs(argWriter, result);
+    };
+  }
 
   static SyncMethodDelegate GetMethodDelegate(void *module, MethodType method) noexcept {
-    return Invoker<IndexSequence>::GetFunc(static_cast<ModuleType *>(module), method);
+    return GetFunc(static_cast<ModuleType *>(module), method, std::make_index_sequence<sizeof...(TArgs)>{});
+  }
+
+  template <class TMethodSpec>
+  static constexpr bool Match() noexcept {
+    // Do not move this method to the ModuleSyncMethodInfoBase for better error reporting.
+    return MatchMethodSignature<typename Super::Signature, typename TMethodSpec::Signature>();
   }
 };
 
 // Static synchronous method
 template <class TResult, class... TArgs>
-struct ModuleSyncMethodInfo<TResult (*)(TArgs...) noexcept> {
+struct ModuleSyncMethodInfo<TResult (*)(TArgs...) noexcept> : ModuleSyncMethodInfoBase<TResult(TArgs...) noexcept> {
+  using Super = ModuleSyncMethodInfoBase<TResult(TArgs...) noexcept>;
   using MethodType = TResult (*)(TArgs...) noexcept;
-  using IndexSequence = std::make_index_sequence<sizeof...(TArgs)>;
-
-  template <class>
-  struct Invoker;
 
   template <size_t... I>
-  struct Invoker<std::index_sequence<I...>> {
-    static SyncMethodDelegate GetFunc(MethodType method) noexcept {
-      return [method](IJSValueReader const &argReader, IJSValueWriter const &argWriter) mutable noexcept {
-        using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
-        ArgTuple typedArgs{};
-        ReadArgs(argReader, std::get<I>(typedArgs)...);
-        TResult result = (*method)(std::get<I>(std::move(typedArgs))...);
-        WriteArgs(argWriter, result);
-      };
-    }
-  };
+  static SyncMethodDelegate GetFunc(MethodType method, std::index_sequence<I...>) noexcept {
+    return [method](IJSValueReader const &argReader, IJSValueWriter const &argWriter) mutable noexcept {
+      using ArgTuple = std::tuple<std::remove_reference_t<TArgs>...>;
+      ArgTuple typedArgs{};
+      ReadArgs(argReader, std::get<I>(typedArgs)...);
+      TResult result = (*method)(std::get<I>(std::move(typedArgs))...);
+      WriteArgs(argWriter, result);
+    };
+  }
 
   static SyncMethodDelegate GetMethodDelegate(void * /*module*/, MethodType method) noexcept {
-    return Invoker<IndexSequence>::GetFunc(method);
+    return GetFunc(method, std::make_index_sequence<sizeof...(TArgs)>{});
+  }
+
+  template <class TMethodSpec>
+  static constexpr bool Match() noexcept {
+    // Do not move this method to the ModuleSyncMethodInfoBase for better error reporting.
+    return MatchMethodSignature<typename Super::Signature, typename TMethodSpec::Signature>();
   }
 };
 
@@ -611,9 +665,9 @@ struct ModuleConstFieldInfo<TValue TModule::*> {
   using ModuleType = TModule;
   using FieldType = TValue TModule::*;
 
-  static ConstantProviderDelegate GetConstantProvider(void *module, wchar_t const *name, FieldType field) noexcept {
-    return [ module = static_cast<ModuleType *>(module), name = std::wstring{name}, field ](
-        IJSValueWriter const &argWriter) mutable noexcept {
+  static ConstantProviderDelegate GetConstantProvider(void *module, std::wstring_view name, FieldType field) noexcept {
+    return
+        [ module = static_cast<ModuleType *>(module), name, field ](IJSValueWriter const &argWriter) mutable noexcept {
       WriteProperty(argWriter, name, module->*field);
     };
   }
@@ -624,8 +678,8 @@ struct ModuleConstFieldInfo<TValue *> {
   using FieldType = TValue *;
 
   static ConstantProviderDelegate
-  GetConstantProvider(void * /*module*/, wchar_t const *name, FieldType field) noexcept {
-    return [ name = std::wstring{name}, field ](IJSValueWriter const &argWriter) mutable noexcept {
+  GetConstantProvider(void * /*module*/, std::wstring_view name, FieldType field) noexcept {
+    return [ name, field ](IJSValueWriter const &argWriter) mutable noexcept {
       WriteProperty(argWriter, name, *field);
     };
   }
@@ -635,7 +689,7 @@ struct ReactConstantProvider {
   ReactConstantProvider(IJSValueWriter const &writer) noexcept : m_writer{writer} {}
 
   template <class T>
-  void Add(const wchar_t *name, const T &value) noexcept {
+  void Add(std::wstring_view name, const T &value) noexcept {
     WriteProperty(m_writer, name, value);
   }
 
@@ -683,8 +737,8 @@ struct ModuleEventFieldInfo<TFunc<void(TArgs...)> TModule::*> {
   static InitializerDelegate GetEventHandlerInitializer(
       void *module,
       FieldType field,
-      wchar_t const *eventName,
-      wchar_t const *eventEmitterName) noexcept {
+      std::wstring_view eventName,
+      std::wstring_view eventEmitterName) noexcept {
     return [ module = static_cast<ModuleType *>(module), field, eventName, eventEmitterName ](
         IReactContext const &reactContext) noexcept {
       module->*field = [ reactContext, eventEmitterName, eventName ](TArgs... args) noexcept {
@@ -710,8 +764,8 @@ struct ModuleFunctionFieldInfo<TFunc<void(TArgs...)> TModule::*> {
   static InitializerDelegate GetFunctionInitializer(
       void *module,
       FieldType field,
-      wchar_t const *functionName,
-      wchar_t const *moduleName) noexcept {
+      std::wstring_view functionName,
+      std::wstring_view moduleName) noexcept {
     return [ module = static_cast<ModuleType *>(module), field, functionName, moduleName ](
         IReactContext const &reactContext) noexcept {
       module->*field = [ reactContext, functionName, moduleName ](TArgs... args) noexcept {
@@ -724,7 +778,69 @@ struct ModuleFunctionFieldInfo<TFunc<void(TArgs...)> TModule::*> {
 };
 
 template <int I>
-using ReactMemberId = std::integral_constant<int, I>;
+using ReactAttributeId = std::integral_constant<int, I>;
+
+template <class TModule>
+struct ReactMemberInfoIterator {
+  template <int StartIndex, class TVisitor>
+  constexpr void ForEachMember(TVisitor &visitor) noexcept {
+    ForEachMember<StartIndex>(visitor, static_cast<std::make_index_sequence<10> *>(nullptr));
+  }
+
+  template <int I, class TVisitor>
+  constexpr void GetMemberInfo(TVisitor &visitor) noexcept {
+    if constexpr (decltype(HasGetReactMemberAttribute(visitor, ReactAttributeId<I>{}))::value) {
+      TModule::template GetReactMemberAttribute<TModule>(visitor, ReactAttributeId<I>{});
+    }
+  }
+
+ private:
+  template <class TVisitor, int I>
+  static auto HasGetReactMemberAttribute(TVisitor &visitor, ReactAttributeId<I> id)
+      -> decltype(TModule::template GetReactMemberAttribute<TModule>(visitor, id), std::true_type{});
+  static auto HasGetReactMemberAttribute(...) -> std::false_type;
+
+  // Visit members in groups of 10 to avoid deep recursion.
+  template <int StartIndex, class TVisitor, int... I>
+  constexpr void ForEachMember(TVisitor &visitor, std::index_sequence<I...> *) noexcept {
+    if constexpr (decltype(HasGetReactMemberAttribute(visitor, ReactAttributeId<StartIndex>{}))::value) {
+      (GetMemberInfo<StartIndex + I>(visitor), ...);
+      ForEachMember<StartIndex + sizeof...(I)>(visitor, static_cast<std::make_index_sequence<10> *>(nullptr));
+    }
+  }
+};
+
+enum class ReactMemberKind {
+  InitMethod,
+  AsyncMethod,
+  SyncMethod,
+  ConstantMethod,
+  ConstantField,
+  EventField,
+  FunctionField,
+};
+
+template <ReactMemberKind MemberKind>
+struct ReactMemberAttribute : std::integral_constant<ReactMemberKind, MemberKind> {
+  constexpr ReactMemberAttribute(std::wstring_view jsMemberName, std::wstring_view jsModuleName) noexcept
+      : JSMemberName{jsMemberName}, JSModuleName{jsModuleName} {}
+
+  std::wstring_view JSMemberName;
+  std::wstring_view JSModuleName;
+};
+
+using ReactInitMethodAttribute = ReactMemberAttribute<ReactMemberKind::InitMethod>;
+using ReactAsyncMethodAttribute = ReactMemberAttribute<ReactMemberKind::AsyncMethod>;
+using ReactSyncMethodAttribute = ReactMemberAttribute<ReactMemberKind::SyncMethod>;
+using ReactConstantMethodAttribute = ReactMemberAttribute<ReactMemberKind::ConstantMethod>;
+using ReactConstantFieldAttribute = ReactMemberAttribute<ReactMemberKind::ConstantField>;
+using ReactEventFieldAttribute = ReactMemberAttribute<ReactMemberKind::EventField>;
+using ReactFunctionFieldAttribute = ReactMemberAttribute<ReactMemberKind::FunctionField>;
+
+template <class T>
+struct IsReactMemberAttribute : std::false_type {};
+template <ReactMemberKind MemberKind>
+struct IsReactMemberAttribute<ReactMemberAttribute<MemberKind>> : std::true_type {};
 
 template <class TModule>
 struct ReactModuleBuilder {
@@ -732,19 +848,14 @@ struct ReactModuleBuilder {
       : m_module{module}, m_moduleBuilder{moduleBuilder} {}
 
   template <int I>
-  void RegisterModule(wchar_t const *moduleName, wchar_t const *eventEmitterName, ReactMemberId<I>) noexcept {
+  void RegisterModule(std::wstring_view moduleName, std::wstring_view eventEmitterName, ReactAttributeId<I>) noexcept {
     RegisterModuleName(moduleName, eventEmitterName);
-    RegisterMembers<I + 1>(static_cast<std::make_index_sequence<10> *>(nullptr));
-  }
-
-  void RegisterModuleName(wchar_t const *moduleName, wchar_t const *eventEmitterName = nullptr) noexcept {
-    m_moduleName = moduleName;
-    m_eventEmitterName = eventEmitterName ? eventEmitterName : L"RCTDeviceEventEmitter";
+    ReactMemberInfoIterator<TModule>{}.ForEachMember<I + 1>(*this);
   }
 
-  void ModuleName(wchar_t const *moduleName, wchar_t const *eventEmitterName = nullptr) noexcept {
+  void RegisterModuleName(std::wstring_view moduleName, std::wstring_view eventEmitterName = L"") noexcept {
     m_moduleName = moduleName;
-    m_eventEmitterName = eventEmitterName ? eventEmitterName : L"RCTDeviceEventEmitter";
+    m_eventEmitterName = !eventEmitterName.empty() ? eventEmitterName : L"RCTDeviceEventEmitter";
   }
 
   void CompleteRegistration() noexcept {
@@ -755,86 +866,240 @@ struct ReactModuleBuilder {
     }
   }
 
-  template <int I>
-  auto HasRegisterMember(ReactModuleBuilder &builder, ReactMemberId<I> id)
-      -> decltype(TModule::template RegisterMember<TModule>(builder, id), std::true_type{});
-  auto HasRegisterMember(...) -> std::false_type;
-
-  template <int I>
-  void RegisterMember() noexcept {
-    if constexpr (decltype(HasRegisterMember(*this, ReactMemberId<I>{}))::value) {
-      TModule::template RegisterMember<TModule>(*this, ReactMemberId<I>{});
-    }
-  }
-
-  // Register members in groups of 10 to avoid deep recursion.
-  template <int StartIndex, int... I>
-  void RegisterMembers(std::index_sequence<I...> *) noexcept {
-    if constexpr (decltype(HasRegisterMember(*this, ReactMemberId<StartIndex>{}))::value) {
-      (RegisterMember<StartIndex + I>(), ...);
-      RegisterMembers<StartIndex + sizeof...(I)>(static_cast<std::make_index_sequence<10> *>(nullptr));
+  template <class TMember, class TAttribute, int I>
+  void Visit(
+      [[maybe_unused]] TMember member,
+      ReactAttributeId<I> /*attributeId*/,
+      [[maybe_unused]] TAttribute attributeInfo) noexcept {
+    if constexpr (std::is_same_v<TAttribute, ReactInitMethodAttribute>) {
+      RegisterInitMethod(member);
+    } else if constexpr (std::is_same_v<TAttribute, ReactAsyncMethodAttribute>) {
+      RegisterMethod(member, attributeInfo.JSMemberName);
+    } else if constexpr (std::is_same_v<TAttribute, ReactSyncMethodAttribute>) {
+      RegisterSyncMethod(member, attributeInfo.JSMemberName);
+    } else if constexpr (std::is_same_v<TAttribute, ReactConstantMethodAttribute>) {
+      RegisterConstantMethod(member);
+    } else if constexpr (std::is_same_v<TAttribute, ReactConstantFieldAttribute>) {
+      RegisterConstantField(member, attributeInfo.JSMemberName);
+    } else if constexpr (std::is_same_v<TAttribute, ReactEventFieldAttribute>) {
+      RegisterEventField(member, attributeInfo.JSMemberName, attributeInfo.JSModuleName);
+    } else if constexpr (std::is_same_v<TAttribute, ReactFunctionFieldAttribute>) {
+      RegisterFunctionField(member, attributeInfo.JSMemberName, attributeInfo.JSModuleName);
     }
   }
 
   template <class TMethod>
-  void RegisterInitMethod(
-      TMethod method,
-      wchar_t const * /*unused*/ = nullptr,
-      wchar_t const * /*unused*/ = nullptr) noexcept {
+  void RegisterInitMethod(TMethod method) noexcept {
     auto initializer = ModuleInitMethodInfo<TMethod>::GetInitializer(m_module, method);
     m_initializers.push_back(std::move(initializer));
   }
 
   template <class TMethod>
-  void RegisterMethod(TMethod method, wchar_t const *name, wchar_t const * /*unused*/ = nullptr) noexcept {
+  void RegisterMethod(TMethod method, std::wstring_view name) noexcept {
     MethodReturnType returnType;
     auto methodDelegate = ModuleMethodInfo<TMethod>::GetMethodDelegate(m_module, method, /*out*/ returnType);
     m_moduleBuilder.AddMethod(name, returnType, methodDelegate);
   }
 
   template <class TMethod>
-  void RegisterSyncMethod(TMethod method, wchar_t const *name, wchar_t const * /*unused*/ = nullptr) noexcept {
+  void RegisterSyncMethod(TMethod method, std::wstring_view name) noexcept {
     auto syncMethodDelegate = ModuleSyncMethodInfo<TMethod>::GetMethodDelegate(m_module, method);
     m_moduleBuilder.AddSyncMethod(name, syncMethodDelegate);
   }
 
   template <class TMethod>
-  void RegisterConstantMethod(
-      TMethod method,
-      wchar_t const * /*unused*/ = nullptr,
-      wchar_t const * /*unused*/ = nullptr) noexcept {
+  void RegisterConstantMethod(TMethod method) noexcept {
     auto constantProvider = ModuleConstantInfo<TMethod>::GetConstantProvider(m_module, method);
     m_moduleBuilder.AddConstantProvider(constantProvider);
   }
 
   template <class TField>
-  void RegisterConstantField(TField field, wchar_t const *name, wchar_t const * /*unused*/ = nullptr) noexcept {
+  void RegisterConstantField(TField field, std::wstring_view name) noexcept {
     auto constantProvider = ModuleConstFieldInfo<TField>::GetConstantProvider(m_module, name, field);
     m_moduleBuilder.AddConstantProvider(constantProvider);
   }
 
   template <class TField>
-  void RegisterEventField(TField field, wchar_t const *eventName, wchar_t const *eventEmitterName = nullptr) noexcept {
+  void
+  RegisterEventField(TField field, std::wstring_view eventName, std::wstring_view eventEmitterName = L"") noexcept {
     auto eventHandlerInitializer = ModuleEventFieldInfo<TField>::GetEventHandlerInitializer(
-        m_module, field, eventName, eventEmitterName ? eventEmitterName : m_eventEmitterName);
+        m_module, field, eventName, !eventEmitterName.empty() ? eventEmitterName : m_eventEmitterName);
     m_moduleBuilder.AddInitializer(eventHandlerInitializer);
   }
 
   template <class TField>
-  void RegisterFunctionField(TField field, wchar_t const *functionName, wchar_t const *moduleName = nullptr) noexcept {
+  void RegisterFunctionField(TField field, std::wstring_view name, std::wstring_view moduleName = L"") noexcept {
     auto functionInitializer = ModuleFunctionFieldInfo<TField>::GetFunctionInitializer(
-        m_module, field, functionName, moduleName ? moduleName : m_moduleName);
+        m_module, field, name, !moduleName.empty() ? moduleName : m_moduleName);
     m_moduleBuilder.AddInitializer(functionInitializer);
   }
 
  private:
   void *m_module;
   IReactModuleBuilder m_moduleBuilder;
-  wchar_t const *m_moduleName{nullptr};
-  wchar_t const *m_eventEmitterName{nullptr};
+  std::wstring_view m_moduleName{L""};
+  std::wstring_view m_eventEmitterName{L""};
   std::vector<InitializerDelegate> m_initializers;
 };
 
+struct VerificationResult {
+  size_t MethodNameCount{0};
+  size_t MatchCount{0};
+  int MatchedMemberId{0};
+};
+
+template <class TModule>
+struct ReactModuleVerifier {
+  static constexpr VerificationResult VerifyMember(std::wstring_view name, ReactMemberKind memberKind) noexcept {
+    ReactModuleVerifier verifier{name, memberKind};
+    GetReactModuleInfo(static_cast<TModule *>(nullptr), verifier);
+    return verifier.m_result;
+  }
+
+  constexpr ReactModuleVerifier(std::wstring_view memberName, ReactMemberKind memberKind) noexcept
+      : m_memberName{memberName}, m_memberKind{memberKind} {}
+
+  template <int I>
+  constexpr void RegisterModule(std::wstring_view /*_*/, std::wstring_view /*_*/, ReactAttributeId<I>) noexcept {
+    ReactMemberInfoIterator<TModule>{}.ForEachMember<I + 1>(*this);
+  }
+
+  template <class TMember, class TAttribute, int I>
+  constexpr void Visit(
+      TMember /*member*/,
+      [[maybe_unused]] ReactAttributeId<I> attributeId,
+      [[maybe_unused]] TAttribute attributeInfo) noexcept {
+    if constexpr (IsReactMemberAttribute<TAttribute>::value) {
+      if (attributeInfo.JSMemberName == m_memberName) {
+        if (IsMethod(attributeInfo())) {
+          ++m_result.MethodNameCount;
+        }
+
+        if (attributeInfo() == m_memberKind) {
+          m_result.MatchedMemberId = attributeId();
+          ++m_result.MatchCount;
+        }
+      }
+    }
+  }
+
+  static bool constexpr IsMethod(ReactMemberKind memberKind) noexcept {
+    return memberKind == ReactMemberKind::AsyncMethod || memberKind == ReactMemberKind::SyncMethod;
+  }
+
+ private:
+  std::wstring_view m_memberName;
+  ReactMemberKind m_memberKind;
+  VerificationResult m_result;
+};
+
+template <class TModule, int I, class TMethodSpec>
+struct ReactMethodVerifier {
+  static constexpr bool Verify() noexcept {
+    ReactMethodVerifier verifier{};
+    ReactMemberInfoIterator<TModule>{}.GetMemberInfo<I>(verifier);
+    return verifier.m_result;
+  }
+
+  template <class TMember, class TAttribute, int I>
+  constexpr void
+  Visit([[maybe_unused]] TMember member, ReactAttributeId<I> /*attributeId*/, TAttribute /*attributeInfo*/) noexcept {
+    m_result = ModuleMethodInfo<TMember>::template Match<TMethodSpec>();
+  }
+
+ private:
+  bool m_result{false};
+};
+
+template <class TModule, int I, class TMethodSpec>
+struct ReactSyncMethodVerifier {
+  static constexpr bool Verify() noexcept {
+    ReactSyncMethodVerifier verifier{};
+    ReactMemberInfoIterator<TModule>{}.GetMemberInfo<I>(verifier);
+    return verifier.m_result;
+  }
+
+  template <class TMember, class TAttribute, int I>
+  constexpr void
+  Visit([[maybe_unused]] TMember member, ReactAttributeId<I> /*attributeId*/, TAttribute /*attributeInfo*/) noexcept {
+    m_result = ModuleSyncMethodInfo<TMember>::template Match<TMethodSpec>();
+  }
+
+ private:
+  bool m_result{false};
+};
+
+struct TurboModuleSpec {
+  struct BaseMethodSpec {
+    constexpr BaseMethodSpec(int index, std::wstring_view name) : Index{index}, Name{name} {}
+
+    int Index;
+    std::wstring_view Name;
+  };
+
+  template <class TSignature>
+  struct Method : BaseMethodSpec {
+    using BaseMethodSpec::BaseMethodSpec;
+    using Signature = typename ModuleMethodInfoBase<TSignature>::Signature;
+    static constexpr bool IsSynchronous = false;
+  };
+
+  template <class TSignature>
+  struct SyncMethod : BaseMethodSpec {
+    using BaseMethodSpec::BaseMethodSpec;
+    using Signature = typename ModuleSyncMethodInfoBase<TSignature>::Signature;
+    static constexpr bool IsSynchronous = true;
+  };
+
+  template <class... TArgs>
+  using Callback = std::function<void(TArgs...)>;
+
+  template <class TArg>
+  using Promise = ReactPromise<TArg>;
+
+  struct MethodCheckResult {
+    bool IsUniqueName{false};
+    bool IsMethodFound{false};
+    bool IsSignatureMatching{true};
+  };
+
+  template <class TModule, class TModuleSpec, size_t I>
+  static constexpr MethodCheckResult CheckMethod() noexcept {
+    constexpr VerificationResult verificationResult = ReactModuleVerifier<TModule>::VerifyMember(
+        std::get<I>(TModuleSpec::methods).Name,
+        std::get<I>(TModuleSpec::methods).IsSynchronous ? ReactMemberKind::SyncMethod : ReactMemberKind::AsyncMethod);
+    MethodCheckResult result{};
+    result.IsUniqueName = verificationResult.MethodNameCount <= 1;
+    result.IsMethodFound = verificationResult.MatchCount == 1;
+    if constexpr (verificationResult.MatchCount == 1) {
+      if constexpr (std::get<I>(TModuleSpec::methods).IsSynchronous) {
+        result.IsSignatureMatching = ReactSyncMethodVerifier<
+            TModule,
+            verificationResult.MatchedMemberId,
+            RemoveConstRef<decltype(std::get<I>(TModuleSpec::methods))>>::Verify();
+      } else {
+        result.IsSignatureMatching = ReactMethodVerifier<
+            TModule,
+            verificationResult.MatchedMemberId,
+            RemoveConstRef<decltype(std::get<I>(TModuleSpec::methods))>>::Verify();
+      }
+    }
+
+    return result;
+  }
+
+  template <class TModule, class TModuleSpec, size_t... I>
+  static constexpr auto CheckMethodsHelper(std::index_sequence<I...>) noexcept {
+    return std::array<MethodCheckResult, sizeof...(I)>{CheckMethod<TModule, TModuleSpec, I>()...};
+  }
+
+  template <class TModule, class TModuleSpec>
+  static constexpr auto CheckMethods() noexcept {
+    return CheckMethodsHelper<TModule, TModuleSpec>(
+        std::make_index_sequence<std::tuple_size_v<decltype(TModuleSpec::methods)>>{});
+  }
+};
+
 template <class T>
 struct BoxedValue : implements<BoxedValue<T>, IBoxedValue> {
   BoxedValue() noexcept {}
@@ -860,10 +1125,27 @@ inline ReactModuleProvider MakeModuleProvider() noexcept {
     auto moduleObject = make<BoxedValue<TModule>>();
     auto module = &BoxedValue<TModule>::GetImpl(moduleObject);
     ReactModuleBuilder builder{module, moduleBuilder};
-    RegisterModule(builder);
+    GetReactModuleInfo(module, builder);
+    builder.CompleteRegistration();
+    return moduleObject;
+  };
+}
+
+template <class TModule, class TModuleSpec>
+inline ReactModuleProvider MakeTurboModuleProvider() noexcept {
+  TModuleSpec::template ValidateModule<TModule>();
+  return [](IReactModuleBuilder const &moduleBuilder) noexcept {
+    auto moduleObject = make<BoxedValue<TModule>>();
+    auto module = &BoxedValue<TModule>::GetImpl(moduleObject);
+    ReactModuleBuilder builder{module, moduleBuilder};
+    GetReactModuleInfo(module, builder);
     builder.CompleteRegistration();
     return moduleObject;
   };
 }
 
 } // namespace winrt::Microsoft::ReactNative
+
+namespace React {
+using namespace winrt::Microsoft::ReactNative;
+}
diff --git a/vnext/Microsoft.ReactNative.Cxx/StructInfo.h b/vnext/Microsoft.ReactNative.Cxx/StructInfo.h
index e68c9e29673..510175140ac 100644
--- a/vnext/Microsoft.ReactNative.Cxx/StructInfo.h
+++ b/vnext/Microsoft.ReactNative.Cxx/StructInfo.h
@@ -20,7 +20,7 @@
 
 #define INTERNAL_REACT_STRUCT(structType)                                                  \
   struct structType;                                                                       \
-  winrt::Microsoft::ReactNative::FieldMap GetStructInfo(structType *) noexcept {           \
+  inline winrt::Microsoft::ReactNative::FieldMap GetStructInfo(structType *) noexcept {    \
     winrt::Microsoft::ReactNative::FieldMap fieldMap{};                                    \
     winrt::Microsoft::ReactNative::CollectStructFields<structType, __COUNTER__>(fieldMap); \
     return fieldMap;                                                                       \
diff --git a/vnext/Microsoft.ReactNative.SharedManaged/AttributedViewManager.cs b/vnext/Microsoft.ReactNative.SharedManaged/AttributedViewManager.cs
index b590c2bfb96..56691b2be2f 100644
--- a/vnext/Microsoft.ReactNative.SharedManaged/AttributedViewManager.cs
+++ b/vnext/Microsoft.ReactNative.SharedManaged/AttributedViewManager.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using Windows.UI.Xaml;
@@ -192,27 +193,21 @@ private static bool IsEnum(Type t)
 
     #region Commands
 
-    public virtual IReadOnlyDictionary<string, long> Commands
+    public virtual IReadOnlyList<string> Commands
     {
       get
       {
         if (null == _commands)
         {
-          var commands = new Dictionary<string, long>();
+          _commands = ViewManagerCommands.Keys.ToList();
 
-          foreach (var kvp in ViewManagerCommands)
-          {
-            commands.Add(kvp.Value.CommandName, kvp.Value.CommandId);
-          }
-
-          _commands = commands;
         }
         return _commands;
       }
     }
-    private IReadOnlyDictionary<string, long> _commands;
+    private IReadOnlyList<string> _commands;
 
-    public virtual void DispatchCommand(FrameworkElement view, long commandId, IJSValueReader commandArgsReader)
+    public virtual void DispatchCommand(FrameworkElement view, string commandId, IJSValueReader commandArgsReader)
     {
       if (view is TFrameworkElement viewAsT)
       {
@@ -227,13 +222,13 @@ public virtual void DispatchCommand(FrameworkElement view, long commandId, IJSVa
       }
     }
 
-    internal Dictionary<long, ViewManagerCommand<TFrameworkElement>> ViewManagerCommands
+    internal Dictionary<string, ViewManagerCommand<TFrameworkElement>> ViewManagerCommands
     {
       get
       {
         if (null == _viewManagerCommands)
         {
-          var viewManagerCommands = new Dictionary<long, ViewManagerCommand<TFrameworkElement>>();
+          var viewManagerCommands = new Dictionary<string, ViewManagerCommand<TFrameworkElement>>();
 
           foreach (var methodInfo in GetType().GetTypeInfo().DeclaredMethods)
           {
@@ -243,10 +238,9 @@ internal Dictionary<long, ViewManagerCommand<TFrameworkElement>> ViewManagerComm
               var command = new ViewManagerCommand<TFrameworkElement>
               {
                 CommandName = commandAttribute.CommandName ?? methodInfo.Name,
-                CommandId = viewManagerCommands.Count,
                 CommandMethod = MakeReaderMethod(methodInfo)
               };
-              viewManagerCommands.Add(command.CommandId, command);
+              viewManagerCommands.Add(command.CommandName, command);
             }
           }
 
@@ -255,12 +249,11 @@ internal Dictionary<long, ViewManagerCommand<TFrameworkElement>> ViewManagerComm
         return _viewManagerCommands;
       }
     }
-    private Dictionary<long, ViewManagerCommand<TFrameworkElement>> _viewManagerCommands;
+    private Dictionary<string, ViewManagerCommand<TFrameworkElement>> _viewManagerCommands;
 
     internal struct ViewManagerCommand<U> where U : TFrameworkElement
     {
       public string CommandName;
-      public long CommandId;
       public Action<U, IJSValueReader> CommandMethod;
     }
 
diff --git a/vnext/Microsoft.ReactNative/ABIViewManager.cpp b/vnext/Microsoft.ReactNative/ABIViewManager.cpp
index 0fd72679c1c..fc85aff39d0 100644
--- a/vnext/Microsoft.ReactNative/ABIViewManager.cpp
+++ b/vnext/Microsoft.ReactNative/ABIViewManager.cpp
@@ -115,29 +115,31 @@ void ABIViewManager::UpdateProperties(react::uwp::ShadowNodeBase *nodeToUpdate,
 }
 
 folly::dynamic ABIViewManager::GetCommands() const {
-  folly::dynamic innerParent = Super::GetCommands();
+  folly::dynamic commandMap = folly::dynamic::object();
 
+  // Why are we providing commands with the same key and value? React Native 0.61 internally introduced string command
+  // IDs which can be dispatched directly without querying the ViewManager for commands. Integer command IDs are
+  // internally deprecated, but querying for command ID is still the documented path. Returning constants as their
+  // string lets us internally only support the string path.
   if (m_viewManagerWithCommands) {
-    auto outerChild = m_viewManagerWithCommands.Commands();
-    for (const auto &pair : outerChild) {
-      std::string key = to_string(pair.Key());
-      folly::dynamic value{pair.Value()};
-      innerParent.insert(key, value);
+    for (const auto &commandName : m_viewManagerWithCommands.Commands()) {
+      auto commandAsStr = to_string(commandName);
+      commandMap[commandAsStr] = commandAsStr;
     }
   }
 
-  return innerParent;
+  return commandMap;
 }
 
 void ABIViewManager::DispatchCommand(
     winrt::Windows::UI::Xaml::DependencyObject viewToUpdate,
-    int64_t commandId,
+    const std::string &commandId,
     const folly::dynamic &commandArgs) {
   if (m_viewManagerWithCommands) {
     auto view = viewToUpdate.as<winrt::FrameworkElement>();
 
     IJSValueReader argReader = winrt::make<DynamicReader>(commandArgs);
-    m_viewManagerWithCommands.DispatchCommand(view, commandId, argReader);
+    m_viewManagerWithCommands.DispatchCommand(view, to_hstring(commandId), argReader);
   }
 }
 
diff --git a/vnext/Microsoft.ReactNative/ABIViewManager.h b/vnext/Microsoft.ReactNative/ABIViewManager.h
index 4356f6dabeb..3b2e55ae57a 100644
--- a/vnext/Microsoft.ReactNative/ABIViewManager.h
+++ b/vnext/Microsoft.ReactNative/ABIViewManager.h
@@ -40,7 +40,7 @@ class ABIViewManager : public react::uwp::FrameworkElementViewManager {
 
   void DispatchCommand(
       winrt::Windows::UI::Xaml::DependencyObject viewToUpdate,
-      int64_t commandId,
+      const std::string &commandId,
       const folly::dynamic &commandArgs) override;
 
   folly::dynamic GetExportedCustomBubblingEventTypeConstants() const override;
diff --git a/vnext/Microsoft.ReactNative/IViewManager.idl b/vnext/Microsoft.ReactNative/IViewManager.idl
index 68598f48659..226bcf9703d 100644
--- a/vnext/Microsoft.ReactNative/IViewManager.idl
+++ b/vnext/Microsoft.ReactNative/IViewManager.idl
@@ -40,7 +40,7 @@ namespace Microsoft.ReactNative
   [webhosthidden]
   interface IViewManagerWithNativeProperties
   {
-    Windows.Foundation.Collections.IMapView<String, ViewManagerPropertyType> NativeProps { get; };
+    IMapView<String, ViewManagerPropertyType> NativeProps { get; };
 
     void UpdateProperties(Windows.UI.Xaml.FrameworkElement view, IJSValueReader propertyMapReader);
   }
@@ -48,9 +48,9 @@ namespace Microsoft.ReactNative
   [webhosthidden]
   interface IViewManagerWithCommands
   {
-    Windows.Foundation.Collections.IMapView<String, Int64> Commands { get; };
+    IVectorView<String> Commands { get; };
 
-    void DispatchCommand(Windows.UI.Xaml.FrameworkElement view, Int64 commandId, IJSValueReader commandArgsReader);
+    void DispatchCommand(Windows.UI.Xaml.FrameworkElement view, String commandId, IJSValueReader commandArgsReader);
   }
 
   [webhosthidden]
diff --git a/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj b/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj
index 2ba8b5f70d5..50a4e0e8f53 100644
--- a/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj
+++ b/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj
@@ -223,15 +223,15 @@
     <ClInclude Include="..\ReactUWP\Polyester\ContentControlViewManager.h" />
     <ClInclude Include="..\ReactUWP\Polyester\HyperlinkViewManager.h" />
     <ClInclude Include="..\ReactUWP\Polyester\IconViewManager.h" />
-    <ClInclude Include="..\ReactUWP\Utils\CppWinrtLessExceptions.h" />
-    <ClInclude Include="..\ReactUWP\Utils\Helpers.h" />
-    <ClInclude Include="..\ReactUWP\Utils\LocalBundleReader.h" />
-    <ClInclude Include="..\ReactUWP\Utils\PropertyHandlerUtils.h" />
-    <ClInclude Include="..\ReactUWP\Utils\PropertyUtils.h" />
-    <ClInclude Include="..\ReactUWP\Utils\ResourceBrushUtils.h" />
-    <ClInclude Include="..\ReactUWP\Utils\StandardControlResourceKeyNames.h" />
-    <ClInclude Include="..\ReactUWP\Utils\UwpPreparedScriptStore.h" />
-    <ClInclude Include="..\ReactUWP\Utils\UwpScriptStore.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\CppWinrtLessExceptions.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\Helpers.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\LocalBundleReader.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\PropertyHandlerUtils.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\PropertyUtils.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\ResourceBrushUtils.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\StandardControlResourceKeyNames.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\UwpPreparedScriptStore.h" />
+    <ClInclude Include="..\include\ReactUWP\Utils\UwpScriptStore.h" />
     <ClInclude Include="..\ReactUWP\Views\ActivityIndicatorViewManager.h" />
     <ClInclude Include="..\ReactUWP\Views\CheckboxViewManager.h" />
     <ClInclude Include="..\ReactUWP\Views\DatePickerViewManager.h" />
diff --git a/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj.filters b/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj.filters
index 3fe649bb226..3b221e531d0 100644
--- a/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj.filters
+++ b/vnext/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj.filters
@@ -458,31 +458,31 @@
     <ClInclude Include="..\ReactUWP\Polyester\IconViewManager.h">
       <Filter>Polyester</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\CppWinrtLessExceptions.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\CppWinrtLessExceptions.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\Helpers.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\Helpers.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\LocalBundleReader.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\LocalBundleReader.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\PropertyHandlerUtils.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\PropertyHandlerUtils.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\PropertyUtils.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\PropertyUtils.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\ResourceBrushUtils.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\ResourceBrushUtils.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\StandardControlResourceKeyNames.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\StandardControlResourceKeyNames.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\UwpPreparedScriptStore.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\UwpPreparedScriptStore.h">
       <Filter>Utils</Filter>
     </ClInclude>
-    <ClInclude Include="..\ReactUWP\Utils\UwpScriptStore.h">
+    <ClInclude Include="..\include\ReactUWP\Utils\UwpScriptStore.h">
       <Filter>Utils</Filter>
     </ClInclude>
     <ClInclude Include="..\include\ReactUWP\Views\ControlViewManager.h">
diff --git a/vnext/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp b/vnext/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp
index 0a6f50829b8..e779e411905 100644
--- a/vnext/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp
+++ b/vnext/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp
@@ -513,7 +513,7 @@ std::shared_ptr<IRedBoxHandler> ReactInstanceWin::GetRedBoxHandler() noexcept {
 
 std::function<void()> ReactInstanceWin::GetLiveReloadCallback() noexcept {
   // Live reload is enabled if we provide a callback function.
-  if (m_options.DeveloperSettings.UseLiveReload) {
+  if (m_options.DeveloperSettings.UseLiveReload || m_options.DeveloperSettings.UseFastRefresh) {
     return Mso::MakeWeakMemberStdFunction(this, &ReactInstanceWin::OnLiveReload);
   }
   return std::function<void()>{};
diff --git a/vnext/Microsoft.ReactNative/RedBox.cpp b/vnext/Microsoft.ReactNative/RedBox.cpp
index 5f95fcbd928..d71808072cf 100644
--- a/vnext/Microsoft.ReactNative/RedBox.cpp
+++ b/vnext/Microsoft.ReactNative/RedBox.cpp
@@ -158,15 +158,13 @@ struct RedBox : public std::enable_shared_from_this<RedBox> {
 #define MAKE_WIDE_STR(x) _MAKE_WIDE_STR(x)
 
   void UpdateErrorMessageUI() noexcept {
+    const std::regex colorsRegex(
+        "\\x1b\\[[0-9;]*m"); // strip out console colors which is often added to JS error messages
+    const std::string plain = std::regex_replace(m_errorInfo.Message, colorsRegex, "");
+
     try {
-      auto json = folly::parseJson(m_errorInfo.Message);
-      if (json.count("name") && json["name"] == "Error") {
-        auto message = json["message"].asString();
-        auto stack = json["stack"].asString().substr(ARRAYSIZE("Error: ") + message.length());
-        m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(message));
-        m_errorStackText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(stack));
-        return;
-      } else if (json.count("type") && json["type"] == "InternalError") {
+      auto json = folly::parseJson(plain);
+      if (json.count("type") && json["type"] == "InternalError") {
         auto message = json["message"].asString();
         m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(message));
 
@@ -187,14 +185,34 @@ struct RedBox : public std::enable_shared_from_this<RedBox> {
           m_errorStackText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(json["type"].asString()));
         }
         return;
+      } else if (json.count("name") && boost::ends_with(json["name"].asString(), "Error")) {
+        auto message = std::regex_replace(json["message"].asString(), colorsRegex, "");
+        const auto originalStack = std::regex_replace(json["stack"].asString(), colorsRegex, "");
+
+        const auto errorName = json["name"].asString();
+        std::string stack;
+
+        const auto prefix = errorName + ": " + message;
+        if (boost::starts_with(originalStack, prefix)) {
+          stack = originalStack.substr(prefix.length());
+        } else {
+          constexpr char startOfStackTrace[] = "\n    at ";
+          stack = originalStack.substr(originalStack.find(startOfStackTrace) + 1);
+        }
+
+        m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(message));
+        // Some messages (like SyntaxError) rely on fixed-width font to be properly formatted and indented.
+        m_errorMessageText.FontFamily(xaml::Media::FontFamily(L"Consolas"));
+
+        m_errorStackText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(stack));
+        return;
       }
     } catch (...) {
       std::string doctype = "<!DOCTYPE HTML>";
-      if (boost::istarts_with(m_errorInfo.Message, doctype)) {
+      if (boost::istarts_with(plain, doctype)) {
         auto webView = xaml::Controls::WebView(xaml::Controls::WebViewExecutionMode::SameThread);
 
-        winrt::hstring content(
-            Microsoft::Common::Unicode::Utf8ToUtf16(m_errorInfo.Message.substr(doctype.length()).c_str()));
+        winrt::hstring content(Microsoft::Common::Unicode::Utf8ToUtf16(plain.substr(doctype.length()).c_str()));
 
         webView.HorizontalAlignment(xaml::HorizontalAlignment::Stretch);
         webView.VerticalAlignment(xaml::VerticalAlignment::Stretch);
@@ -245,10 +263,7 @@ struct RedBox : public std::enable_shared_from_this<RedBox> {
       }
     }
     // fall back to displaying the raw message string
-    const std::regex colorsRegex(
-        "\\x1b\\[[0-9;]*m"); // strip out console colors which is often added to JS error messages
-    const std::string formated = std::regex_replace(m_errorInfo.Message, colorsRegex, "");
-    m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(formated));
+    m_errorMessageText.Text(Microsoft::Common::Unicode::Utf8ToUtf16(plain));
     m_errorStackText.Text(L"");
   }
 
diff --git a/vnext/Microsoft.ReactNative/Views/ReactRootControl.cpp b/vnext/Microsoft.ReactNative/Views/ReactRootControl.cpp
index 0574a0762d3..7b73c9bc060 100644
--- a/vnext/Microsoft.ReactNative/Views/ReactRootControl.cpp
+++ b/vnext/Microsoft.ReactNative/Views/ReactRootControl.cpp
@@ -184,6 +184,7 @@ void ReactRootControl::InitRootView(
   m_SIPEventHandler->AttachView(xamlRootView, /*fireKeyboradEvents:*/ true);
 
   UpdateRootViewInternal();
+  AttachBackHandlers(xamlRootView);
 
   m_isInitialized = true;
 }
@@ -232,6 +233,8 @@ void ReactRootControl::UninitRootView() noexcept {
     m_previewKeyboardEventHandlerOnRoot->unhook();
   }
 
+  RemoveBackHandlers();
+
   // If the redbox error UI is shown we need to remove it, otherwise let the
   // natural teardown process do this
   if (m_redBoxGrid) {
@@ -561,6 +564,12 @@ void ReactRootControl::ShowDeveloperMenu() noexcept {
     auto xamlRootGrid{xamlRootView.as<winrt::Grid>()};
     xamlRootGrid.Children().Append(m_developerMenuRoot);
   }
+
+  // Notify instance that dev menu is shown -- This is used to trigger a connection to dev tools
+  if (auto instance = m_weakReactInstance.GetStrongPtr()) {
+    query_cast<Mso::React::ILegacyReactInstance &>(*instance).CallJsFunction(
+        "RCTNativeAppEventEmitter", "emit", folly::dynamic::array("RCTDevMenuShown"));
+  }
 }
 
 void ReactRootControl::DismissDeveloperMenu() noexcept {
@@ -607,6 +616,73 @@ void ReactRootControl::ReloadViewHost() noexcept {
   }
 }
 
+void ReactRootControl::AttachBackHandlers(XamlView const &rootView) noexcept {
+  auto weakThis = weak_from_this();
+  m_backRequestedRevoker = winrt::Windows::UI::Core::SystemNavigationManager::GetForCurrentView().BackRequested(
+      winrt::auto_revoke,
+      [weakThis](winrt::IInspectable const & /*sender*/, winrt::BackRequestedEventArgs const &args) {
+        if (auto self = weakThis.lock()) {
+          args.Handled(self->OnBackRequested());
+        }
+      });
+
+  // In addition to handling the BackRequested event, UWP suggests that we listen for other user inputs that should
+  // trigger back navigation that don't fire that event:
+  // https://docs.microsoft.com/en-us/windows/uwp/design/basics/navigation-history-and-backwards-navigation
+  auto rootElement(rootView.try_as<winrt::UIElement>());
+  if (rootElement == nullptr) {
+    assert(false);
+    return;
+  }
+
+  // Handle keyboard "back" button press
+  winrt::KeyboardAccelerator goBack{};
+  goBack.Key(winrt::VirtualKey::GoBack);
+  goBack.Invoked(
+      [weakThis](
+          winrt::KeyboardAccelerator const & /*sender*/, winrt::KeyboardAcceleratorInvokedEventArgs const &args) {
+        if (auto self = weakThis.lock()) {
+          args.Handled(self->OnBackRequested());
+        }
+      });
+  rootElement.KeyboardAccelerators().Append(goBack);
+
+  // Handle Alt+Left keyboard shortcut
+  winrt::KeyboardAccelerator altLeft{};
+  altLeft.Key(winrt::VirtualKey::Left);
+  altLeft.Invoked(
+      [weakThis](
+          winrt::KeyboardAccelerator const & /*sender*/, winrt::KeyboardAcceleratorInvokedEventArgs const &args) {
+        if (auto self = weakThis.lock()) {
+          args.Handled(self->OnBackRequested());
+        }
+      });
+  rootElement.KeyboardAccelerators().Append(altLeft);
+  altLeft.Modifiers(winrt::VirtualKeyModifiers::Menu);
+
+  // Hide keyboard accelerator tooltips
+  rootElement.KeyboardAcceleratorPlacementMode(winrt::KeyboardAcceleratorPlacementMode::Hidden);
+}
+
+void ReactRootControl::RemoveBackHandlers() noexcept {
+  m_backRequestedRevoker.revoke();
+  if (auto rootView = m_weakRootView.get()) {
+    if (auto element = rootView.try_as<winrt::UIElement>()) {
+      element.KeyboardAccelerators().Clear();
+    }
+  }
+}
+
+bool ReactRootControl::OnBackRequested() noexcept {
+  if (auto reactInstance = m_weakReactInstance.GetStrongPtr()) {
+    query_cast<Mso::React::ILegacyReactInstance &>(*reactInstance)
+        .CallJsFunction("RCTDeviceEventEmitter", "emit", folly::dynamic::array("hardwareBackPress"));
+    return true;
+  }
+
+  return false;
+}
+
 Mso::React::IReactViewHost *ReactRootControl::ReactViewHost() noexcept {
   return m_reactViewHost.Get();
 }
diff --git a/vnext/Microsoft.ReactNative/Views/ReactRootControl.h b/vnext/Microsoft.ReactNative/Views/ReactRootControl.h
index 3166195164b..26bb5948cc2 100644
--- a/vnext/Microsoft.ReactNative/Views/ReactRootControl.h
+++ b/vnext/Microsoft.ReactNative/Views/ReactRootControl.h
@@ -15,6 +15,7 @@
 
 namespace winrt {
 using namespace Windows::UI;
+using namespace Windows::UI::Core;
 using namespace Windows::UI::Xaml;
 using namespace Windows::UI::Xaml::Controls;
 using namespace Windows::UI::Xaml::Input;
@@ -83,6 +84,10 @@ struct ReactRootControl final : std::enable_shared_from_this<ReactRootControl>,
   void ReloadHost() noexcept;
   void ReloadViewHost() noexcept;
 
+  void AttachBackHandlers(XamlView const &rootView) noexcept;
+  void RemoveBackHandlers() noexcept;
+  bool OnBackRequested() noexcept;
+
  private:
   int64_t m_rootTag{-1};
 
@@ -130,6 +135,7 @@ struct ReactRootControl final : std::enable_shared_from_this<ReactRootControl>,
   winrt::Button::Click_revoker m_directDebuggingRevoker{};
   winrt::Button::Click_revoker m_breakOnNextLineRevoker{};
   winrt::CoreDispatcher::AcceleratorKeyActivated_revoker m_coreDispatcherAKARevoker{};
+  winrt::SystemNavigationManager::BackRequested_revoker m_backRequestedRevoker{};
 };
 
 //! This class ensures that we access ReactRootView from UI thread.
diff --git a/vnext/PropertySheets/Bundle.Common.targets b/vnext/PropertySheets/Bundle.Common.targets
index 971bf63aecf..c3f08007f8b 100644
--- a/vnext/PropertySheets/Bundle.Common.targets
+++ b/vnext/PropertySheets/Bundle.Common.targets
@@ -4,12 +4,12 @@
  Licensed under the MIT License.. 
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildThisFileDirectory)\Bundle.props"/>
-
   <Target Name="MakeBundle" BeforeTargets="PrepareForBuild" 
       Condition="'$(UseBundle)' == 'true'">
-        <MakeDir Directories="$(BundleContentRoot)" Condition=" !Exists('$(BundleContentRoot') and '$(BundleContentRoot)' != '' " />
-        <Warning Text="BundleCommand is not defined, and you should execute 'react-native bundle' by yourself" Condition="'$(BundleCommand)' == ''" />
-        <Exec Condition="'$(BundleCommand)' != ''" Command="$(BundleCommand)" ConsoleToMSBuild="true" WorkingDirectory="$([System.IO.Path]::GetDirectoryName($(ProjectDir)))" />
+        <MakeDir Directories="$(BundleContentRoot)" Condition=" !Exists('$(BundleContentRoot)') and '$(BundleContentRoot)' != '' " />
+        <MakeDir Directories="$([MSBuild]::MakeRelative($(ProjectDir), $(BundleSourceMapDir)))" Condition=" !Exists('$([MSBuild]::MakeRelative($(ProjectDir), $(BundleSourceMapDir)))') and '$(BundleSourceMapDir)' != '' " />
+        <Message Importance="High" Text="Running [$(BundleCliCommand) --platform windows --entry-file $(BundleEntryFile) --bundle-output $([MSBuild]::NormalizePath('$(BundleOutputPath)\$(BundleAssetName)')) --assets-dest $(BundleContentRoot) --dev $(UseDevBundle) --reset-cache --sourcemap-output $([MSBuild]::MakeRelative($(BundleCommandWorkingDir), $([MSBuild]::NormalizePath('$(BundleSourceMapDir)\$(BundleAssetName).map')))) $(BundlerExtraArgs)] to build bundle file." />
+        <!-- Hermes will need more code here to build source maps (Call to node_modules/react-native/scripts/compose-source-maps.js) -->
+        <Exec Command="$(BundleCliCommand) --platform windows --entry-file $(BundleEntryFile) --bundle-output $([MSBuild]::NormalizePath('$(BundleOutputPath)\$(BundleAssetName)')) --assets-dest $(BundleContentRoot) --dev $(UseDevBundle) --reset-cache --sourcemap-output $([MSBuild]::MakeRelative($(BundleCommandWorkingDir), $([MSBuild]::NormalizePath('$(BundleSourceMapDir)\$(BundleAssetName).map')))) $(BundlerExtraArgs)" ConsoleToMSBuild="true" WorkingDirectory="$(BundleCommandWorkingDir)" />
   </Target>
 </Project>
\ No newline at end of file
diff --git a/vnext/PropertySheets/Bundle.Cpp.targets b/vnext/PropertySheets/Bundle.Cpp.targets
index 1ad7e09acf6..ef11a97b368 100644
--- a/vnext/PropertySheets/Bundle.Cpp.targets
+++ b/vnext/PropertySheets/Bundle.Cpp.targets
@@ -10,7 +10,7 @@
     <ItemGroup Condition="'$(UseBundle)' == 'true' and '$(BundleContent)' != '' and '$(BundleContentRoot)' != '' ">
       <BundleContentToBePackaged Include="$(BundleContent)" />
       <None Include="@(BundleContentToBePackaged)">
-        <Link>$(BundleContentRoot)\%(RecursiveDir)%(Filename)%(Extension)</Link>
+        <Link>$([MSBuild]::MakeRelative($(ProjectDir),'$(BundleContentRoot)\%(RecursiveDir)%(Filename)%(Extension)'))</Link>
         <DeploymentContent>true</DeploymentContent>
       </None>
    </ItemGroup>
diff --git a/vnext/PropertySheets/Bundle.props b/vnext/PropertySheets/Bundle.props
index 64f7c7eb244..883379ace3d 100644
--- a/vnext/PropertySheets/Bundle.props
+++ b/vnext/PropertySheets/Bundle.props
@@ -6,10 +6,49 @@
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 
   <PropertyGroup>
+
+    <!-- 
+      UseBundle causes the bundle to be created and included inside the application install.  And defines the BUNDLE #define in code,
+      which causes the app to load from the bundle file rather than loading the bundle from a bundle server
+    -->
     <UseBundle Condition=" '$(Configuration)' == 'Debug' and '$(UseBundle)' == '' ">false</UseBundle>
     <UseBundle Condition=" '$(Configuration)' == 'Release' and '$(UseBundle)' == '' ">true</UseBundle>
-    <BundleContentRoot Condition=" '$(BundleContentRoot)' == '' ">Bundle</BundleContentRoot>
-    <BundleContent Condition = " '$(BundleContent)' == '' and '$(BundleContentRoot)' != '' ">$(BundleContentRoot)\**\*</BundleContent>
+
+    <!-- Root directory where bundle assets will be copied to, be sure to update BundleContent if you change this -->
+    <BundleContentRoot Condition=" '$(BundleContentRoot)' == '' ">$([MSBuild]::NormalizePath('$(ProjectDir)\Bundle'))</BundleContentRoot>
+
+    <!-- Files included in BundleContent will be included in the application install - by default this includes the bundle file, and assets from the bundler  -->
+    <BundleContent Condition=" '$(BundleContent)' == '' and '$(BundleContentRoot)' != '' ">$(BundleContentRoot)\**\*</BundleContent>
+
+    <!-- The name of the JS bundle assert to be placed in $(BundleOutputPath)-->
+    <BundleAssetName Condition="'$(BundleAssetName)' == ''">index.windows.bundle</BundleAssetName>
+
+    <!-- Where should be final JS bundle be written to -->
+    <BundleOutputPath Condition="'$(BundleOutputPath)' == ''">$([MSBuild]::NormalizePath('$(ProjectDir)\Bundle'))</BundleOutputPath>
+
+    <!-- Should the bundle created be a dev bundle -->
+    <UseDevBundle Condition="'$(UseDevBundle)' == '' and '$(Configuration)' == 'Debug'">true</UseDevBundle>
+    <UseDevBundle Condition="'$(UseDevBundle)' == '' and '$(Configuration)' != 'Debug'">false</UseDevBundle>
+
+    <!-- Extra arguments to pass to the bundler command -->
+    <BundlerExtraArgs Condition="'$(BundlerExtraArgs)' == ''"></BundlerExtraArgs>
+
+    <!-- Command to use to create a bundle -->
+    <BundleCliCommand Condition="'$(BundleCliCommand)' == ''">npx --no-install react-native bundle</BundleCliCommand>
+
+    <!-- This should be the app package root, this is where the bundle command will be run from -->
+    <BundleCommandWorkingDir Condition="'$(BundleCommandWorkingDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(ProjectDir), 'package.json'))</BundleCommandWorkingDir>
+
+    <!-- Entry file of the JS bundle. Defaults to use index.windows.js if it exists, otherwise index.js -->
+    <BundleEntryFile Condition="'$(BundleEntryFile)' == '' and Exists('$(BundleCommandWorkingDir)\index.windows.js')">index.windows.js</BundleEntryFile>
+    <BundleEntryFile Condition="'$(BundleEntryFile)' == ''">index.js</BundleEntryFile>
+
+    <!-- Optional config file for the bundle command (metro will use metro.config.js by default) -->
+    <BundleConfigFile Condition="'$(BundleConfigFile)' == ''"></BundleConfigFile>
+
+    <!-- Location where source map file for the JS bundle will be created -->
+    <BundleSourceMapDir Condition="'$(BundleSourceMapDir)' == ''">$(OutDir)\sourcemaps\react</BundleSourceMapDir>
+
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/vnext/ReactUWP/Modules/DevSupportManagerUwp.cpp b/vnext/ReactUWP/Modules/DevSupportManagerUwp.cpp
index 5cb7e348178..84280333503 100644
--- a/vnext/ReactUWP/Modules/DevSupportManagerUwp.cpp
+++ b/vnext/ReactUWP/Modules/DevSupportManagerUwp.cpp
@@ -16,6 +16,7 @@
 #include "Utilities.h"
 
 #include <Utils/CppWinrtLessExceptions.h>
+#include <winrt/Windows.Data.Json.h>
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.Web.Http.Filters.h>
 #include <winrt/Windows.Web.Http.Headers.h>
@@ -73,12 +74,64 @@ void DevSupportManager::LaunchDevTools(const facebook::react::DevSettings &setti
   DownloadFromAsync(facebook::react::DevServerHelper::get_LaunchDevToolsCommandUrl(settings.debugHost)).get();
 }
 
+std::future<void> DevSupportManager::CreatePackagerConnection(const facebook::react::DevSettings &settings) {
+  m_ws = winrt::Windows::Networking::Sockets::MessageWebSocket();
+
+  m_wsMessageRevoker = m_ws.MessageReceived(
+      winrt::auto_revoke, [reloadCallback = settings.liveReloadCallback](auto && /*sender*/, auto &&args) noexcept {
+        try {
+          auto reader = args.GetDataReader();
+
+          uint32_t len = reader.UnconsumedBufferLength();
+          if (args.MessageType() == winrt::Windows::Networking::Sockets::SocketMessageType::Utf8) {
+            reader.UnicodeEncoding(winrt::Windows::Storage::Streams::UnicodeEncoding::Utf8);
+            std::vector<uint8_t> data(len);
+            reader.ReadBytes(data);
+
+            auto response =
+                std::string(Microsoft::Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+            auto json =
+                winrt::Windows::Data::Json::JsonObject::Parse(Microsoft::Common::Unicode::Utf8ToUtf16(response));
+
+            auto version = (int)json.GetNamedNumber(L"version", 0.0);
+            if (version != 2) {
+              return;
+            }
+            auto method = std::wstring(json.GetNamedString(L"method", L""));
+            if (method.empty()) {
+              return;
+            }
+
+            if (!method.compare(L"reload")) {
+              reloadCallback();
+            } else if (!method.compare(L"devMenu")) {
+              // TODO showDevMenu
+            } else if (!method.compare(L"captureHeap")) {
+              // TODO captureHeap
+            }
+          }
+        } catch (winrt::hresult_error const &e) {
+        }
+      });
+
+  winrt::Windows::Foundation::Uri uri(
+      Microsoft::Common::Unicode::Utf8ToUtf16("ws://" + settings.debugHost + "/message"));
+  auto async = m_ws.ConnectAsync(uri);
+
+#ifdef DEFAULT_CPPWINRT_EXCEPTIONS
+  co_await async;
+#else
+  co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncAction>{async};
+#endif
+}
+
 facebook::react::JSECreator DevSupportManager::LoadJavaScriptInProxyMode(const facebook::react::DevSettings &settings) {
   // Reset exception state since client is requesting new service
   m_exceptionCaught = false;
 
   try {
     LaunchDevTools(settings);
+    CreatePackagerConnection(settings);
 
     return [this, settings](
                std::shared_ptr<facebook::react::ExecutorDelegate> delegate,
diff --git a/vnext/ReactUWP/Modules/DevSupportManagerUwp.h b/vnext/ReactUWP/Modules/DevSupportManagerUwp.h
index 13ccda97aca..be3aa05b994 100644
--- a/vnext/ReactUWP/Modules/DevSupportManagerUwp.h
+++ b/vnext/ReactUWP/Modules/DevSupportManagerUwp.h
@@ -7,6 +7,7 @@
 
 #include <DevServerHelper.h>
 
+#include <winrt/Windows.Networking.Sockets.h>
 #include <atomic>
 #include <functional>
 #include <memory>
@@ -39,8 +40,11 @@ class DevSupportManager : public facebook::react::IDevSupportManager {
 
  private:
   void LaunchDevTools(const facebook::react::DevSettings &settings);
+  std::future<void> CreatePackagerConnection(const facebook::react::DevSettings &settings);
 
  private:
+  winrt::Windows::Networking::Sockets::MessageWebSocket m_ws{nullptr};
+  winrt::Windows::Networking::Sockets::MessageWebSocket::MessageReceived_revoker m_wsMessageRevoker;
   bool m_exceptionCaught = false;
   std::atomic_bool m_cancellation_token;
 };
diff --git a/vnext/ReactUWP/Modules/NativeUIManager.cpp b/vnext/ReactUWP/Modules/NativeUIManager.cpp
index b26fdc7a602..64b9183f940 100644
--- a/vnext/ReactUWP/Modules/NativeUIManager.cpp
+++ b/vnext/ReactUWP/Modules/NativeUIManager.cpp
@@ -507,13 +507,12 @@ static void StyleYogaNode(ShadowNodeBase &shadowNode, const YGNodeRef yogaNode,
 
       YGNodeStyleSetDisplay(yogaNode, display);
     } else if (key == "direction") {
-      YGDirection direction = YGDirectionInherit;
-      if (value == "inherit" || value.isNull())
-        direction = YGDirectionInherit;
-      else if (value == "ltr" || value.isNull())
-        direction = YGDirectionLTR;
-      else if (value == "rtl")
-        direction = YGDirectionRTL;
+      // https://github.com/microsoft/react-native-windows/issues/4668
+      // In order to support the direction property, we tell yoga to always layout
+      // in LTR direction, then push the appropriate FlowDirection into XAML.
+      // This way XAML handles flipping in RTL mode, which works both for RN components
+      // as well as native components that have purely XAML sub-trees (eg ComboBox).
+      YGDirection direction = YGDirectionLTR;
 
       YGNodeStyleSetDirection(yogaNode, direction);
     } else if (key == "aspectRatio") {
diff --git a/vnext/ReactUWP/Views/ScrollViewManager.cpp b/vnext/ReactUWP/Views/ScrollViewManager.cpp
index 8e3a021ab84..bbe699e9e4b 100644
--- a/vnext/ReactUWP/Views/ScrollViewManager.cpp
+++ b/vnext/ReactUWP/Views/ScrollViewManager.cpp
@@ -11,10 +11,10 @@
 namespace react {
 namespace uwp {
 
-enum class ScrollViewCommands {
-  ScrollTo = 1,
-  ScrollToEnd,
-};
+namespace ScrollViewCommands {
+constexpr const char *ScrollTo = "scrollTo";
+constexpr const char *ScrollToEnd = "scrollToEnd";
+}; // namespace ScrollViewCommands
 
 class ScrollViewShadowNode : public ShadowNodeBase {
   using Super = ShadowNodeBase;
@@ -22,7 +22,7 @@ class ScrollViewShadowNode : public ShadowNodeBase {
  public:
   ScrollViewShadowNode();
   ~ScrollViewShadowNode();
-  void dispatchCommand(int64_t commandId, const folly::dynamic &commandArgs) override;
+  void dispatchCommand(const std::string &commandId, const folly::dynamic &commandArgs) override;
   void createView() override;
   void updateProperties(const folly::dynamic &&props) override;
 
@@ -65,28 +65,23 @@ ScrollViewShadowNode::~ScrollViewShadowNode() {
   m_SIPEventHandler.reset();
 }
 
-void ScrollViewShadowNode::dispatchCommand(int64_t commandId, const folly::dynamic &commandArgs) {
+void ScrollViewShadowNode::dispatchCommand(const std::string &commandId, const folly::dynamic &commandArgs) {
   const auto scrollViewer = GetView().as<winrt::ScrollViewer>();
   if (scrollViewer == nullptr)
     return;
 
-  switch (commandId) {
-    case static_cast<int64_t>(ScrollViewCommands::ScrollTo): {
-      double x = commandArgs[0].asDouble();
-      double y = commandArgs[1].asDouble();
-      bool animated = commandArgs[2].asBool();
-      scrollViewer.ChangeView(x, y, nullptr, !animated /*disableAnimation*/);
-      break;
-    }
-    case static_cast<int64_t>(ScrollViewCommands::ScrollToEnd): {
-      bool animated = commandArgs[0].asBool();
-      bool horiz = scrollViewer.HorizontalScrollMode() == winrt::ScrollMode::Auto;
-      if (horiz)
-        scrollViewer.ChangeView(scrollViewer.ScrollableWidth(), nullptr, nullptr, !animated /*disableAnimation*/);
-      else
-        scrollViewer.ChangeView(nullptr, scrollViewer.ScrollableHeight(), nullptr, !animated /*disableAnimation*/);
-      break;
-    }
+  if (commandId == ScrollViewCommands::ScrollTo) {
+    double x = commandArgs[0].asDouble();
+    double y = commandArgs[1].asDouble();
+    bool animated = commandArgs[2].asBool();
+    scrollViewer.ChangeView(x, y, nullptr, !animated /*disableAnimation*/);
+  } else if (commandId == ScrollViewCommands::ScrollToEnd) {
+    bool animated = commandArgs[0].asBool();
+    bool horiz = scrollViewer.HorizontalScrollMode() == winrt::ScrollMode::Auto;
+    if (horiz)
+      scrollViewer.ChangeView(scrollViewer.ScrollableWidth(), nullptr, nullptr, !animated /*disableAnimation*/);
+    else
+      scrollViewer.ChangeView(nullptr, scrollViewer.ScrollableHeight(), nullptr, !animated /*disableAnimation*/);
   }
 }
 
@@ -413,11 +408,10 @@ const char *ScrollViewManager::GetName() const {
 }
 
 folly::dynamic ScrollViewManager::GetCommands() const {
-  auto commands = Super::GetCommands();
-  commands.update(folly::dynamic::object(
-      "scrollTo", static_cast<std::underlying_type_t<ScrollViewCommands>>(ScrollViewCommands::ScrollTo))(
-      "scrollToEnd", static_cast<std::underlying_type_t<ScrollViewCommands>>(ScrollViewCommands::ScrollToEnd)));
-  return commands;
+  // Upstream JS will dispatch the string directly instead of ever actually calling this, but providing a real
+  // implementation is simple enough in case anything changes.
+  return folly::dynamic::object(ScrollViewCommands::ScrollTo, ScrollViewCommands::ScrollTo)(
+      ScrollViewCommands::ScrollToEnd, ScrollViewCommands::ScrollToEnd);
 }
 
 folly::dynamic ScrollViewManager::GetNativeProps() const {
diff --git a/vnext/ReactUWP/Views/ShadowNodeBase.cpp b/vnext/ReactUWP/Views/ShadowNodeBase.cpp
index c03d97ed666..527c30e5a88 100644
--- a/vnext/ReactUWP/Views/ShadowNodeBase.cpp
+++ b/vnext/ReactUWP/Views/ShadowNodeBase.cpp
@@ -44,7 +44,7 @@ bool ShadowNodeBase::NeedsForceLayout() {
   return false;
 }
 
-void ShadowNodeBase::dispatchCommand(int64_t commandId, const folly::dynamic &commandArgs) {
+void ShadowNodeBase::dispatchCommand(const std::string &commandId, const folly::dynamic &commandArgs) {
   GetViewManager()->DispatchCommand(GetView(), commandId, commandArgs);
 }
 
diff --git a/vnext/ReactUWP/Views/SwitchViewManager.cpp b/vnext/ReactUWP/Views/SwitchViewManager.cpp
index e5ad8a0c5a5..93093cdf36e 100644
--- a/vnext/ReactUWP/Views/SwitchViewManager.cpp
+++ b/vnext/ReactUWP/Views/SwitchViewManager.cpp
@@ -160,5 +160,17 @@ bool SwitchViewManager::UpdateProperty(
   return true;
 }
 
+void SwitchViewManager::DispatchCommand(
+    XamlView viewToUpdate,
+    const std::string &commandId,
+    const folly::dynamic &commandArgs) {
+  if (commandId == "setValue") {
+    auto value = commandArgs[0].asBool();
+    viewToUpdate.as<winrt::ToggleSwitch>().IsEnabled(value);
+  } else {
+    Super::DispatchCommand(viewToUpdate, commandId, commandArgs);
+  }
+}
+
 } // namespace uwp
 } // namespace react
diff --git a/vnext/ReactUWP/Views/SwitchViewManager.h b/vnext/ReactUWP/Views/SwitchViewManager.h
index aaa6089c809..372163eb095 100644
--- a/vnext/ReactUWP/Views/SwitchViewManager.h
+++ b/vnext/ReactUWP/Views/SwitchViewManager.h
@@ -17,6 +17,7 @@ class SwitchViewManager : public ControlViewManager {
   const char *GetName() const override;
   folly::dynamic GetNativeProps() const override;
   facebook::react::ShadowNode *createShadow() const override;
+  void DispatchCommand(XamlView viewToUpdate, const std::string &commandId, const folly::dynamic &commandArgs) override;
 
  protected:
   bool UpdateProperty(
diff --git a/vnext/ReactUWP/Views/TouchEventHandler.cpp b/vnext/ReactUWP/Views/TouchEventHandler.cpp
index cdcd9de40a8..d08300864ca 100644
--- a/vnext/ReactUWP/Views/TouchEventHandler.cpp
+++ b/vnext/ReactUWP/Views/TouchEventHandler.cpp
@@ -78,6 +78,13 @@ void TouchEventHandler::OnPointerPressed(
   if (!TagFromOriginalSource(args, &tag, &sourceElement))
     return;
 
+  // If this was caused by the user pressing the "back" hardware button, fire that event instead
+  if (args.GetCurrentPoint(sourceElement).Properties().PointerUpdateKind() ==
+      winrt::Windows::UI::Input::PointerUpdateKind::XButton1Pressed) {
+    args.Handled(DispatchBackEvent());
+    return;
+  }
+
   if (m_xamlView.as<winrt::FrameworkElement>().CapturePointer(args.Pointer())) {
     // Pointer pressing updates the enter/leave state
     UpdatePointersInViews(args, tag, sourceElement);
@@ -341,6 +348,16 @@ void TouchEventHandler::DispatchTouchEvent(TouchEventType eventType, size_t poin
   instance->CallJsFunction("RCTEventEmitter", "receiveTouches", std::move(params));
 }
 
+bool TouchEventHandler::DispatchBackEvent() {
+  auto instance = m_wkReactInstance.lock();
+  if (instance != nullptr && !instance->IsInError()) {
+    instance->CallJsFunction("RCTDeviceEventEmitter", "emit", folly::dynamic::array("hardwareBackPress"));
+    return true;
+  }
+
+  return false;
+}
+
 const char *TouchEventHandler::GetPointerDeviceTypeName(
     winrt::Windows::Devices::Input::PointerDeviceType deviceType) noexcept {
   const char *deviceTypeName = "unknown";
diff --git a/vnext/ReactUWP/Views/TouchEventHandler.h b/vnext/ReactUWP/Views/TouchEventHandler.h
index 62488bc7e4f..df26eaf2c19 100644
--- a/vnext/ReactUWP/Views/TouchEventHandler.h
+++ b/vnext/ReactUWP/Views/TouchEventHandler.h
@@ -78,6 +78,7 @@ class TouchEventHandler {
   enum class TouchEventType { Start = 0, End, Move, Cancel, PointerEntered, PointerExited, PointerMove };
   void OnPointerConcluded(TouchEventType eventType, const winrt::PointerRoutedEventArgs &args);
   void DispatchTouchEvent(TouchEventType eventType, size_t pointerIndex);
+  bool DispatchBackEvent();
   const char *GetPointerDeviceTypeName(winrt::Windows::Devices::Input::PointerDeviceType deviceType) noexcept;
   const char *GetTouchEventTypeName(TouchEventType eventType) noexcept;
 
diff --git a/vnext/ReactUWP/Views/ViewManagerBase.cpp b/vnext/ReactUWP/Views/ViewManagerBase.cpp
index 38feb176955..86d1e61e084 100644
--- a/vnext/ReactUWP/Views/ViewManagerBase.cpp
+++ b/vnext/ReactUWP/Views/ViewManagerBase.cpp
@@ -255,7 +255,7 @@ void ViewManagerBase::TransferProperties(XamlView /*oldView*/, XamlView /*newVie
 
 void ViewManagerBase::DispatchCommand(
     XamlView /*viewToUpdate*/,
-    int64_t /*commandId*/,
+    const std::string & /*commandId*/,
     const folly::dynamic & /*commandArgs*/) {
   assert(false); // View did not handle its command
 }
diff --git a/vnext/ReactWindowsCore/IUIManager.h b/vnext/ReactWindowsCore/IUIManager.h
index 4cf28835a16..cb677aa75aa 100644
--- a/vnext/ReactWindowsCore/IUIManager.h
+++ b/vnext/ReactWindowsCore/IUIManager.h
@@ -44,7 +44,8 @@ class IUIManager {
       folly::dynamic &addChildTags,
       folly::dynamic &addAtIndices,
       folly::dynamic &removeFrom) = 0;
-  virtual void dispatchViewManagerCommand(int64_t reactTag, int64_t commandId, folly::dynamic &&commandArgs) = 0;
+  virtual void
+  dispatchViewManagerCommand(int64_t reactTag, const std::string &commandId, folly::dynamic &&commandArgs) = 0;
   virtual void replaceExistingNonRootView(int64_t oldTag, int64_t newTag) = 0;
   virtual void measure(int64_t reactTag, facebook::xplat::module::CxxModule::Callback callback) = 0;
   virtual void measureInWindow(int64_t reactTag, facebook::xplat::module::CxxModule::Callback callback) = 0;
diff --git a/vnext/ReactWindowsCore/Modules/UIManagerModule.cpp b/vnext/ReactWindowsCore/Modules/UIManagerModule.cpp
index b71f31bd556..7d72ac8d25a 100644
--- a/vnext/ReactWindowsCore/Modules/UIManagerModule.cpp
+++ b/vnext/ReactWindowsCore/Modules/UIManagerModule.cpp
@@ -320,7 +320,10 @@ void UIManager::replaceExistingNonRootView(int64_t oldTag, int64_t newTag) {
   manageChildren(parent.m_tag, emptyVec, emptyVec, tagToAdd, indicesToAdd, indicesToRemove);
 }
 
-void UIManager::dispatchViewManagerCommand(int64_t reactTag, int64_t commandId, folly::dynamic &&commandArgs) {
+void UIManager::dispatchViewManagerCommand(
+    int64_t reactTag,
+    const std::string &commandId,
+    folly::dynamic &&commandArgs) {
   m_nativeUIManager->ensureInBatch();
   auto &node = m_nodeRegistry.getNode(reactTag);
   if (!node.m_zombie)
@@ -507,8 +510,11 @@ std::vector<facebook::xplat::module::CxxModule::Method> UIManagerModule::getMeth
       Method(
           "dispatchViewManagerCommand",
           [manager](dynamic args) {
+            // 0.61 allows directly dispatching command names instead of querying the ViewManager for the command ID.
+            // In stock React Native, integer commands are deprecated but not yet removed. RNW APIs only allow strings,
+            // and provide command constants as their literal string.
             manager->dispatchViewManagerCommand(
-                jsArgAsInt(args, 0), jsArgAsInt(args, 1), std::move(jsArgAsDynamic(args, 2)));
+                jsArgAsInt(args, 0), jsArgAsString(args, 1), std::move(jsArgAsDynamic(args, 2)));
           }),
       Method("measure", [manager](dynamic args, Callback cb) { manager->measure(jsArgAsInt(args, 0), cb); }),
       Method(
diff --git a/vnext/ReactWindowsCore/Modules/UIManagerModule.h b/vnext/ReactWindowsCore/Modules/UIManagerModule.h
index cf79bb89346..e66f5d5e9ac 100644
--- a/vnext/ReactWindowsCore/Modules/UIManagerModule.h
+++ b/vnext/ReactWindowsCore/Modules/UIManagerModule.h
@@ -43,7 +43,9 @@ class UIManager : public IUIManager, INativeUIManagerHost {
       folly::dynamic &addChildTags,
       folly::dynamic &addAtIndices,
       folly::dynamic &removeFrom) override;
-  void dispatchViewManagerCommand(int64_t reactTag, int64_t commandId, folly::dynamic &&commandArgs) override;
+
+  void dispatchViewManagerCommand(int64_t reactTag, const std::string &commandId, folly::dynamic &&commandArgs)
+      override;
   void replaceExistingNonRootView(int64_t oldTag, int64_t newTag) override;
   void onBatchComplete() override;
   void measure(int64_t reactTag, facebook::xplat::module::CxxModule::Callback callback) override;
diff --git a/vnext/ReactWindowsCore/ShadowNode.cpp b/vnext/ReactWindowsCore/ShadowNode.cpp
index 6bf17eb9261..626015b0423 100644
--- a/vnext/ReactWindowsCore/ShadowNode.cpp
+++ b/vnext/ReactWindowsCore/ShadowNode.cpp
@@ -8,7 +8,7 @@ namespace react {
 
 ShadowNode::~ShadowNode() {}
 
-void ShadowNode::dispatchCommand(int64_t commandId, const folly::dynamic &commandArgs) {}
+void ShadowNode::dispatchCommand(const std::string &commandId, const folly::dynamic &commandArgs) {}
 
 void ShadowNode::onDropViewInstance() {}
 
diff --git a/vnext/ReactWindowsCore/ShadowNode.h b/vnext/ReactWindowsCore/ShadowNode.h
index 4f986e2f108..ea10f0259db 100644
--- a/vnext/ReactWindowsCore/ShadowNode.h
+++ b/vnext/ReactWindowsCore/ShadowNode.h
@@ -20,7 +20,7 @@ struct ShadowNode {
 
   virtual void updateProperties(const folly::dynamic &&props);
   virtual void onDropViewInstance() = 0;
-  virtual void dispatchCommand(int64_t commandId, const folly::dynamic &commandArgs);
+  virtual void dispatchCommand(const std::string &commandId, const folly::dynamic &commandArgs);
   virtual void removeAllChildren() = 0;
   virtual void AddView(ShadowNode &child, int64_t index) = 0;
   virtual void RemoveChildAt(int64_t indexToRemove) = 0;
diff --git a/vnext/Scripts/Microsoft.ReactNative.nuspec b/vnext/Scripts/Microsoft.ReactNative.nuspec
index a9f01558837..1e83515adfb 100644
--- a/vnext/Scripts/Microsoft.ReactNative.nuspec
+++ b/vnext/Scripts/Microsoft.ReactNative.nuspec
@@ -21,37 +21,37 @@
     <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.xml"   target="lib\uap10.0"/> 
     -->
 
-    <file src="$nugetroot$\ARM\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm\native" />
-    <file src="$nugetroot$\ARM\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm\native" />
-    <file src="$nugetroot$\ARM\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm\native" />
+    <file src="$nugetroot$\ARM\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm\native\release" />
+    <file src="$nugetroot$\ARM\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm\native\release" />
+    <file src="$nugetroot$\ARM\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm\native\release" />
 
-    <file src="$nugetroot$\ARM\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm\native" />
-    <file src="$nugetroot$\ARM\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm\native" />
-    <file src="$nugetroot$\ARM\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm\native" />
+    <file src="$nugetroot$\ARM\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm\native\debug" />
+    <file src="$nugetroot$\ARM\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm\native\debug" />
+    <file src="$nugetroot$\ARM\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm\native\debug" />
 
-    <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm64\native" />
-    <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm64\native" />
-    <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm64\native" />
+    <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm64\native\release" />
+    <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm64\native\release" />
+    <file src="$nugetroot$\ARM64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm64\native\release" />
 
-    <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm64\native" />
-    <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm64\native" />
-    <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm64\native" />
+    <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-arm64\native\debug" />
+    <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-arm64\native\debug" />
+    <file src="$nugetroot$\ARM64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-arm64\native\debug" />
 
-    <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x86\native" />
-    <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x86\native" />
-    <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x86\native" />
+    <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x86\native\release" />
+    <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x86\native\release" />
+    <file src="$nugetroot$\x86\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x86\native\release" />
 
-    <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x86\native" />
-    <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x86\native" />
-    <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x86\native" />
+    <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x86\native\debug" />
+    <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x86\native\debug" />
+    <file src="$nugetroot$\x86\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x86\native\debug" />
 
-    <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x64\native" />
-    <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x64\native" />
-    <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x64\native" />
+    <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x64\native\release" />
+    <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x64\native\release" />
+    <file src="$nugetroot$\x64\Release\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x64\native\release" />
 
-    <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x64\native" />
-    <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x64\native" />
-    <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x64\native" />
+    <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.dll" target="runtimes\win10-x64\native\debug" />
+    <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pdb" target="runtimes\win10-x64\native\debug" />
+    <file src="$nugetroot$\x64\Debug\Microsoft.ReactNative\Microsoft.ReactNative.pri" target="runtimes\win10-x64\native\debug" />
 
   </files>
 </package>
diff --git a/vnext/Scripts/Microsoft.ReactNative.targets b/vnext/Scripts/Microsoft.ReactNative.targets
index d6195d83018..58cd47cddab 100644
--- a/vnext/Scripts/Microsoft.ReactNative.targets
+++ b/vnext/Scripts/Microsoft.ReactNative.targets
@@ -8,7 +8,9 @@
         <Reference Include="$(MSBuildThisFileDirectory)..\..\lib\uap10.0\Microsoft.ReactNative.winmd">
             <Implementation>Microsoft.ReactNative.dll</Implementation>
         </Reference>
-    <ReferenceCopyLocalPaths Include="$(MSBuildThisFileDirectory)..\..\runtimes\win10-$(Native-Platform)\native\Microsoft.ReactNative.dll" />
-    <ReferenceCopyLocalPaths Include="$(MSBuildThisFileDirectory)..\..\runtimes\win10-$(Native-Platform)\native\Microsoft.ReactNative.pri" />
+    <ReferenceCopyLocalPaths Condition="$(Configuration) == 'Debug'" Include="$(MSBuildThisFileDirectory)..\..\runtimes\win10-$(Native-Platform)\native\debug\Microsoft.ReactNative.dll" />
+    <ReferenceCopyLocalPaths Condition="$(Configuration) == 'Debug'" Include="$(MSBuildThisFileDirectory)..\..\runtimes\win10-$(Native-Platform)\native\debug\Microsoft.ReactNative.pri" />
+    <ReferenceCopyLocalPaths Condition="$(Configuration) != 'Debug'" Include="$(MSBuildThisFileDirectory)..\..\runtimes\win10-$(Native-Platform)\native\release\Microsoft.ReactNative.dll" />
+    <ReferenceCopyLocalPaths Condition="$(Configuration) != 'Debug'" Include="$(MSBuildThisFileDirectory)..\..\runtimes\win10-$(Native-Platform)\native\release\Microsoft.ReactNative.pri" />
     </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/vnext/Shared/OInstance.cpp b/vnext/Shared/OInstance.cpp
index 2da2a031bd1..3a9ba283c58 100644
--- a/vnext/Shared/OInstance.cpp
+++ b/vnext/Shared/OInstance.cpp
@@ -661,7 +661,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
 
 void InstanceImpl::RegisterForReloadIfNecessary() noexcept {
   // setup polling for live reload
-  if (!m_devManager->HasException() && m_devSettings->liveReloadCallback != nullptr) {
+  if (!m_devManager->HasException() && !m_devSettings->useFastRefresh && m_devSettings->liveReloadCallback != nullptr) {
     m_devManager->StartPollingLiveReload(m_devSettings->debugHost, m_devSettings->liveReloadCallback);
   }
 }
diff --git a/vnext/include/ReactUWP/Utils/PropertyUtils.h b/vnext/include/ReactUWP/Utils/PropertyUtils.h
index b97fe199dd3..a8e02589475 100644
--- a/vnext/include/ReactUWP/Utils/PropertyUtils.h
+++ b/vnext/include/ReactUWP/Utils/PropertyUtils.h
@@ -40,12 +40,10 @@ static const std::unordered_map<std::string, ShadowEdges> edgeTypeMap = {
     {"borderWidth", ShadowEdges::AllEdges},
 };
 
-inline winrt::Windows::UI::Xaml::Thickness GetThickness(double thicknesses[ShadowEdges::CountEdges], bool isRTL) {
+inline winrt::Windows::UI::Xaml::Thickness GetThickness(double thicknesses[ShadowEdges::CountEdges]) {
   const double defaultWidth = std::max<double>(0, thicknesses[ShadowEdges::AllEdges]);
   double startWidth = DefaultOrOverride(thicknesses[ShadowEdges::Left], thicknesses[ShadowEdges::Start]);
   double endWidth = DefaultOrOverride(thicknesses[ShadowEdges::Right], thicknesses[ShadowEdges::End]);
-  if (isRTL)
-    std::swap(startWidth, endWidth);
 
   // Compute each edge.  Most specific setting wins, so fill from broad to
   // narrow: all, horiz/vert, start/end, left/right
@@ -68,9 +66,7 @@ inline winrt::Windows::UI::Xaml::Thickness GetThickness(double thicknesses[Shado
   return thickness;
 }
 
-inline winrt::Windows::UI::Xaml::CornerRadius GetCornerRadius(
-    double cornerRadii[ShadowCorners::CountCorners],
-    bool isRTL) {
+inline winrt::Windows::UI::Xaml::CornerRadius GetCornerRadius(double cornerRadii[ShadowCorners::CountCorners]) {
   winrt::Windows::UI::Xaml::CornerRadius cornerRadius;
   const double defaultRadius = std::max<double>(0, cornerRadii[ShadowCorners::AllCorners]);
   double topStartRadius = DefaultOrOverride(cornerRadii[ShadowCorners::TopLeft], cornerRadii[ShadowCorners::TopStart]);
@@ -79,10 +75,6 @@ inline winrt::Windows::UI::Xaml::CornerRadius GetCornerRadius(
       DefaultOrOverride(cornerRadii[ShadowCorners::BottomLeft], cornerRadii[ShadowCorners::BottomStart]);
   double bottomEndRadius =
       DefaultOrOverride(cornerRadii[ShadowCorners::BottomRight], cornerRadii[ShadowCorners::BottomEnd]);
-  if (isRTL) {
-    std::swap(topStartRadius, topEndRadius);
-    std::swap(bottomStartRadius, bottomEndRadius);
-  }
 
   cornerRadius.TopLeft = DefaultOrOverride(defaultRadius, topStartRadius);
   cornerRadius.TopRight = DefaultOrOverride(defaultRadius, topEndRadius);
@@ -95,16 +87,14 @@ inline winrt::Windows::UI::Xaml::CornerRadius GetCornerRadius(
 template <class T>
 void UpdatePadding(ShadowNodeBase *node, const T &element, ShadowEdges edge, double margin) {
   node->m_padding[edge] = margin;
-  winrt::Thickness thickness =
-      GetThickness(node->m_padding, element.FlowDirection() == winrt::FlowDirection::RightToLeft);
+  winrt::Thickness thickness = GetThickness(node->m_padding);
   element.Padding(thickness);
 }
 
 template <class T>
 void SetBorderThickness(ShadowNodeBase *node, const T &element, ShadowEdges edge, double margin) {
   node->m_border[edge] = margin;
-  winrt::Thickness thickness =
-      GetThickness(node->m_border, element.FlowDirection() == winrt::FlowDirection::RightToLeft);
+  winrt::Thickness thickness = GetThickness(node->m_border);
   element.BorderThickness(thickness);
 }
 
@@ -141,8 +131,7 @@ UpdateCornerRadiusValueOnNode(ShadowNodeBase *node, ShadowCorners corner, const
 
 template <class T>
 void UpdateCornerRadiusOnElement(ShadowNodeBase *node, const T &element) {
-  winrt::CornerRadius cornerRadius =
-      GetCornerRadius(node->m_cornerRadius, element.FlowDirection() == winrt::FlowDirection::RightToLeft);
+  winrt::CornerRadius cornerRadius = GetCornerRadius(node->m_cornerRadius);
   element.CornerRadius(cornerRadius);
 }
 
diff --git a/vnext/include/ReactUWP/Views/ShadowNodeBase.h b/vnext/include/ReactUWP/Views/ShadowNodeBase.h
index e8ec8da550f..2e008780943 100644
--- a/vnext/include/ReactUWP/Views/ShadowNodeBase.h
+++ b/vnext/include/ReactUWP/Views/ShadowNodeBase.h
@@ -54,7 +54,7 @@ struct REACTWINDOWS_EXPORT ShadowNodeBase : public facebook::react::ShadowNode {
   virtual ~ShadowNodeBase() {}
 
   virtual void onDropViewInstance() override;
-  virtual void dispatchCommand(int64_t commandId, const folly::dynamic &commandArgs) override;
+  virtual void dispatchCommand(const std::string &commandId, const folly::dynamic &commandArgs) override;
   virtual void removeAllChildren() override;
   virtual void AddView(ShadowNode &child, int64_t index) override;
   virtual void RemoveChildAt(int64_t indexToRemove) override;
diff --git a/vnext/include/ReactUWP/Views/ViewManagerBase.h b/vnext/include/ReactUWP/Views/ViewManagerBase.h
index 17f2e2ae6c0..b1ff720d35a 100644
--- a/vnext/include/ReactUWP/Views/ViewManagerBase.h
+++ b/vnext/include/ReactUWP/Views/ViewManagerBase.h
@@ -62,7 +62,7 @@ class REACTWINDOWS_EXPORT ViewManagerBase : public facebook::react::IViewManager
 
   virtual void UpdateProperties(ShadowNodeBase *nodeToUpdate, const folly::dynamic &reactDiffMap);
 
-  virtual void DispatchCommand(XamlView viewToUpdate, int64_t commandId, const folly::dynamic &commandArgs);
+  virtual void DispatchCommand(XamlView viewToUpdate, const std::string &commandId, const folly::dynamic &commandArgs);
 
   // Yoga Layout
   virtual void
diff --git a/vnext/local-cli/generator-windows/index.js b/vnext/local-cli/generator-windows/index.js
index 13b2e476bf0..7387048d3dd 100644
--- a/vnext/local-cli/generator-windows/index.js
+++ b/vnext/local-cli/generator-windows/index.js
@@ -97,7 +97,7 @@ function copyProjectTemplateAndReplace(
   [
     { from: path.join(srcRootPath, 'metro.config.js'), to: 'metro.config.js' },
     { from: path.join(srcRootPath, '_gitignore'), to: path.join(windowsDir, '.gitignore') },
-    { from: path.join(srcRootPath, 'b_gitignore'), to: path.join(windowsDir, newProjectName, bundleDir, '.gitignore') },
+    { from: path.join(srcRootPath, 'b_gitignore'), to: path.join(windowsDir, newProjectName, '.gitignore') },
     { from: path.join(srcRootPath, 'index.windows.bundle'), to: path.join(windowsDir, newProjectName, bundleDir, 'index.windows.bundle') },
     { from: path.join(srcPath, projDir, 'MyApp.sln'), to: path.join(windowsDir, newProjectName + '.sln') },
   ].forEach((mapping) => copyAndReplaceWithChangedCallback(mapping.from, destPath, mapping.to, templateVars, options.overwrite));
diff --git a/vnext/local-cli/generator-windows/templates/b_gitignore b/vnext/local-cli/generator-windows/templates/b_gitignore
index d6b7ef32c84..917243bd7ae 100644
--- a/vnext/local-cli/generator-windows/templates/b_gitignore
+++ b/vnext/local-cli/generator-windows/templates/b_gitignore
@@ -1,2 +1 @@
-*
-!.gitignore
+/Bundle
diff --git a/vnext/local-cli/generator-windows/templates/cpp/proj-experimental/MyApp.vcxproj b/vnext/local-cli/generator-windows/templates/cpp/proj-experimental/MyApp.vcxproj
index 3e6ccd65be1..f6a21a959da 100644
--- a/vnext/local-cli/generator-windows/templates/cpp/proj-experimental/MyApp.vcxproj
+++ b/vnext/local-cli/generator-windows/templates/cpp/proj-experimental/MyApp.vcxproj
@@ -19,6 +19,9 @@
     <%=certificateThumbprint%>
     <PackageCertificatePassword>password</PackageCertificatePassword>
   </PropertyGroup>
+  <PropertyGroup>
+    <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
+  </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|ARM">
@@ -71,7 +74,7 @@
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
   <ImportGroup Label="Shared">
-    <Import Project="..\..\node_modules\react-native-windows\Microsoft.ReactNative.Cxx\Microsoft.ReactNative.Cxx.vcxitems" Label="Shared" />
+    <Import Project="$(ReactNativeWindowsDir)\Microsoft.ReactNative.Cxx\Microsoft.ReactNative.Cxx.vcxitems" Label="Shared" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -150,13 +153,8 @@
   </ItemGroup>
 
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-
-  <PropertyGroup>
-    <BundleCommand>
-      npx --no-install react-native bundle --platform windows --entry-file index.js --bundle-output $(MSBuildThisFileDirectory)/Bundle/index.windows.bundle --assets-dest $(MSBuildThisFileDirectory)/Bundle
-    </BundleCommand>
-  </PropertyGroup>
-  <Import Project="..\..\node_modules\react-native-windows\PropertySheets\Bundle.Cpp.targets"/>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.props"/>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.Cpp.targets"/>
 
   <ImportGroup Label="ExtensionTargets">
     <Import Project="..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets')" />
diff --git a/vnext/local-cli/generator-windows/templates/cpp/proj/MyApp.vcxproj b/vnext/local-cli/generator-windows/templates/cpp/proj/MyApp.vcxproj
index da48fb3cb65..d6970f786da 100644
--- a/vnext/local-cli/generator-windows/templates/cpp/proj/MyApp.vcxproj
+++ b/vnext/local-cli/generator-windows/templates/cpp/proj/MyApp.vcxproj
@@ -19,6 +19,9 @@
     <%=certificateThumbprint%>
     <PackageCertificatePassword>password</PackageCertificatePassword>
   </PropertyGroup>
+  <PropertyGroup>
+    <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
+  </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|ARM">
@@ -71,7 +74,7 @@
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
   <ImportGroup Label="Shared">
-    <Import Project="..\..\node_modules\react-native-windows\Microsoft.ReactNative.Cxx\Microsoft.ReactNative.Cxx.vcxitems" Label="Shared" />
+    <Import Project="$(ReactNativeWindowsDir)\Microsoft.ReactNative.Cxx\Microsoft.ReactNative.Cxx.vcxitems" Label="Shared" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
@@ -149,19 +152,14 @@
     </Text>
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\node_modules\react-native-windows\Microsoft.ReactNative\Microsoft.ReactNative.vcxproj">
+    <ProjectReference Include="$(ReactNativeWindowsDir)\Microsoft.ReactNative\Microsoft.ReactNative.vcxproj">
       <Project>{f7d32bd0-2749-483e-9a0d-1635ef7e3136}</Project>
     </ProjectReference>
   </ItemGroup>
 
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-
-  <PropertyGroup>
-    <BundleCommand>
-      npx --no-install react-native bundle --platform windows --entry-file index.js --bundle-output $(MSBuildThisFileDirectory)/Bundle/index.windows.bundle --assets-dest $(MSBuildThisFileDirectory)/Bundle
-    </BundleCommand>
-  </PropertyGroup>
-  <Import Project="..\..\node_modules\react-native-windows\PropertySheets\Bundle.Cpp.targets"/>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.props" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.Cpp.targets"/>
 
   <ImportGroup Label="ExtensionTargets">
     <Import Project="..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('..\packages\Microsoft.Windows.CppWinRT.2.0.200316.3\build\native\Microsoft.Windows.CppWinRT.targets')" />
diff --git a/vnext/local-cli/generator-windows/templates/cs/proj/MyApp.csproj b/vnext/local-cli/generator-windows/templates/cs/proj/MyApp.csproj
index 2b598cbc339..e7010aff763 100644
--- a/vnext/local-cli/generator-windows/templates/cs/proj/MyApp.csproj
+++ b/vnext/local-cli/generator-windows/templates/cs/proj/MyApp.csproj
@@ -22,6 +22,9 @@
     <PackageCertificatePassword>password</PackageCertificatePassword>
     <AppxGeneratePrisForPortableLibrariesEnabled>false</AppxGeneratePrisForPortableLibrariesEnabled>
   </PropertyGroup>
+  <PropertyGroup>
+    <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
+  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\x86\Debug\</OutputPath>
@@ -151,7 +154,7 @@
     </PackageReference>
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\node_modules\react-native-windows\Microsoft.ReactNative\Microsoft.ReactNative.vcxproj">
+    <ProjectReference Include="$(ReactNativeWindowsDir)\Microsoft.ReactNative\Microsoft.ReactNative.vcxproj">
       <Project>{f7d32bd0-2749-483e-9a0d-1635ef7e3136}</Project>
       <Name>Microsoft.ReactNative</Name>
     </ProjectReference>
@@ -159,17 +162,13 @@
       <Version>2.3.191129002</Version>
     </PackageReference>
   </ItemGroup>
-  <Import Project="..\..\node_modules\react-native-windows\Microsoft.ReactNative.SharedManaged\Microsoft.ReactNative.SharedManaged.projitems" Label="Shared" />
+  <Import Project="$(ReactNativeWindowsDir)\Microsoft.ReactNative.SharedManaged\Microsoft.ReactNative.SharedManaged.projitems" Label="Shared" />
   <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '16.0' ">
     <VisualStudioVersion>16.0</VisualStudioVersion>
   </PropertyGroup>
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
-  <PropertyGroup>
-    <BundleCommand>
-      npx --no-install react-native bundle --platform windows --entry-file index.js --bundle-output $(MSBuildThisFileDirectory)/Bundle/index.windows.bundle --assets-dest $(MSBuildThisFileDirectory)/Bundle
-    </BundleCommand>
-  </PropertyGroup>
-  <Import Project="..\..\node_modules\react-native-windows\PropertySheets\Bundle.targets" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.props" />
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\Bundle.targets" />
   <PropertyGroup>
     <PreBuildEvent>
     </PreBuildEvent>
diff --git a/vnext/package.json b/vnext/package.json
index 366f2127156..c3a48a4da24 100644
--- a/vnext/package.json
+++ b/vnext/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-master.42",
+  "version": "0.0.0-master.46",
   "license": "MIT",
   "repository": {
     "type": "git",
diff --git a/vnext/src/Libraries/Utilities/BackHandler.windows.js b/vnext/src/Libraries/Utilities/BackHandler.windows.js
index 8a57351da63..e6e3d035295 100644
--- a/vnext/src/Libraries/Utilities/BackHandler.windows.js
+++ b/vnext/src/Libraries/Utilities/BackHandler.windows.js
@@ -4,16 +4,30 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @format
  * @flow
+ * @format
  */
 
-// On Apple TV, this implements back navigation using the TV remote's menu button.
-// On iOS, this just implements a stub.
-
 'use strict';
 
-// TODO Hx: Implement.
+import NativeDeviceEventManager from '../../Libraries/NativeModules/specs/NativeDeviceEventManager';
+import RCTDeviceEventEmitter from '../EventEmitter/RCTDeviceEventEmitter';
+
+const DEVICE_BACK_EVENT = 'hardwareBackPress';
+
+type BackPressEventName = 'backPress' | 'hardwareBackPress';
+
+const _backPressSubscriptions = [];
+
+RCTDeviceEventEmitter.addListener(DEVICE_BACK_EVENT, function() {
+  for (let i = _backPressSubscriptions.length - 1; i >= 0; i--) {
+    if (_backPressSubscriptions[i]()) {
+      return;
+    }
+  }
+
+  BackHandler.exitApp();
+});
 
 /**
  * Detect hardware button presses for back navigation.
@@ -45,9 +59,6 @@
  * });
  * ```
  */
-
-type BackPressEventName = 'backPress' | 'hardwareBackPress';
-
 type TBackHandler = {|
   +exitApp: () => void,
   +addEventListener: (
@@ -59,13 +70,47 @@ type TBackHandler = {|
     handler: Function,
   ) => void,
 |};
-
 const BackHandler: TBackHandler = {
-  exitApp: () => {},
-  addEventListener: (eventName: BackPressEventName, handler: Function) => {
-    return {remove: () => {}};
+  exitApp: function(): void {
+    if (!NativeDeviceEventManager) {
+      return;
+    }
+
+    NativeDeviceEventManager.invokeDefaultBackPressHandler();
+  },
+
+  /**
+   * Adds an event handler. Supported events:
+   *
+   * - `hardwareBackPress`: Fires when the Android hardware back button is pressed or when the
+   * tvOS menu button is pressed.
+   */
+  addEventListener: function(
+    eventName: BackPressEventName,
+    handler: Function,
+  ): {remove: () => void, ...} {
+    if (_backPressSubscriptions.indexOf(handler) === -1) {
+      _backPressSubscriptions.push(handler);
+    }
+    return {
+      remove: (): void => BackHandler.removeEventListener(eventName, handler),
+    };
+  },
+
+  /**
+   * Removes the event handler.
+   */
+  removeEventListener: function(
+    eventName: BackPressEventName,
+    handler: Function,
+  ): void {
+    if (_backPressSubscriptions.indexOf(handler) !== -1) {
+      _backPressSubscriptions.splice(
+        _backPressSubscriptions.indexOf(handler),
+        1,
+      );
+    }
   },
-  removeEventListener: (eventName: BackPressEventName, handler: Function) => {},
 };
 
 module.exports = BackHandler;
diff --git a/vnext/src/RNTester/js/examples/RTL/RTLExample.windows.js b/vnext/src/RNTester/js/examples/RTL/RTLExample.windows.js
new file mode 100644
index 00000000000..2aed4557c8a
--- /dev/null
+++ b/vnext/src/RNTester/js/examples/RTL/RTLExample.windows.js
@@ -0,0 +1,749 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const React = require('react');
+
+const {
+  Alert,
+  Animated,
+  I18nManager,
+  Image,
+  PixelRatio,
+  Platform,
+  StyleSheet,
+  Text,
+  TouchableWithoutFeedback,
+  Switch,
+  View,
+  Button,
+} = require('react-native');
+
+type State = {
+  toggleStatus: any,
+  pan: Object,
+  linear: Object,
+  isRTL: boolean,
+  ...
+};
+
+type RTLToggleState = {isRTL: boolean, ...};
+
+type AnimationState = {
+  toggleStatus: any,
+  linear: Object,
+  windowWidth: number,
+  ...
+};
+
+const SCALE = PixelRatio.get();
+const IMAGE_DIMENSION = 100 * SCALE;
+const IMAGE_SIZE = [IMAGE_DIMENSION, IMAGE_DIMENSION];
+
+const IS_RTL = I18nManager.isRTL;
+
+function ListItem(props) {
+  return (
+    <View style={styles.row}>
+      <View style={styles.column1}>
+        <Image source={props.imageSource} style={styles.icon} />
+      </View>
+      <View style={styles.column2}>
+        <View style={styles.textBox}>
+          <Text>Text Text Text</Text>
+        </View>
+      </View>
+      <View style={styles.column3}>
+        <View style={styles.smallButton}>
+          <Text style={styles.fontSizeSmall}>Button</Text>
+        </View>
+      </View>
+    </View>
+  );
+}
+
+const TextAlignmentExample = withRTLState(({isRTL, setRTL, ...props}) => {
+  return (
+    <View>
+      <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+      <View style={directionStyle(isRTL)}>
+        <Text style={props.style}>
+          Left-to-Right language without text alignment.
+        </Text>
+        <Text style={props.style}>
+          {'\u0645\u0646 \u0627\u0644\u064A\u0645\u064A\u0646 ' +
+            '\u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631 ' +
+            '\u0627\u0644\u0644\u063A\u0629 \u062F\u0648\u0646 ' +
+            '\u0645\u062D\u0627\u0630\u0627\u0629 \u0627\u0644\u0646\u0635'}
+        </Text>
+        <Text style={props.style}>
+          {'\u05DE\u05D9\u05DE\u05D9\u05DF \u05DC\u05E9\u05DE\u05D0\u05DC ' +
+            '\u05D4\u05E9\u05E4\u05D4 \u05D1\u05DC\u05D9 ' +
+            '\u05D9\u05D9\u05E9\u05D5\u05E8 \u05D8\u05E7\u05E1\u05D8'}
+        </Text>
+      </View>
+    </View>
+  );
+});
+
+const IconsExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+      <View style={[styles.flexDirectionRow, directionStyle(isRTL)]}>
+        <View>
+          <Image
+            source={require('../../assets/like.png')}
+            style={styles.image}
+          />
+          <Text style={styles.fontSizeExtraSmall}>
+            Without directional meaning
+          </Text>
+        </View>
+        <View style={styles.rightAlignStyle}>
+          <Image
+            source={require('../../assets/poke.png')}
+            style={[styles.image, styles.withRTLStyle]}
+          />
+          <Text style={styles.fontSizeExtraSmall}>
+            With directional meaning
+          </Text>
+        </View>
+      </View>
+    </View>
+  );
+});
+
+function AnimationBlock(props) {
+  return (
+    <View style={styles.block}>
+      <TouchableWithoutFeedback onPress={props.onPress}>
+        <Animated.Image
+          style={[styles.img, props.imgStyle]}
+          source={require('../../assets/poke.png')}
+        />
+      </TouchableWithoutFeedback>
+    </View>
+  );
+}
+
+type RTLSwitcherComponentState = {|
+  isRTL: boolean,
+|};
+
+function withRTLState(Component) {
+  return class extends React.Component<*, RTLSwitcherComponentState> {
+    constructor(...args) {
+      super(...args);
+      this.state = {
+        isRTL: IS_RTL,
+      };
+    }
+
+    render() {
+      const setRTL = isRTL => this.setState({isRTL: isRTL});
+      return (
+        <Component isRTL={this.state.isRTL} setRTL={setRTL} {...this.props} />
+      );
+    }
+  };
+}
+
+const RTLToggler = ({isRTL, setRTL}) => {
+  if (Platform.OS === 'android') {
+    return <Text style={styles.rtlToggler}>{isRTL ? 'RTL' : 'LTR'}</Text>;
+  }
+
+  const toggleRTL = () => setRTL(!isRTL);
+  return (
+    <Button
+      onPress={toggleRTL}
+      title={isRTL ? 'RTL' : 'LTR'}
+      color="gray"
+      accessibilityLabel="Change layout direction"
+    />
+  );
+};
+
+class RTLToggleExample extends React.Component<any, RTLToggleState> {
+  constructor(props: Object) {
+    super(props);
+
+    this.state = {
+      isRTL: IS_RTL,
+    };
+  }
+
+  render() {
+    return (
+      <View>
+        <View style={styles.directionBox}>
+          <Text style={styles.directionText}>
+            {this.state.isRTL ? 'Right-to-Left' : 'Left-to-Right'}
+          </Text>
+        </View>
+        <View style={styles.flexDirectionRow}>
+          <Text style={styles.switchRowTextView}>forceRTL</Text>
+          <View style={styles.switchRowSwitchView}>
+            <Switch
+              onValueChange={this._onDirectionChange}
+              style={styles.rightAlignStyle}
+              value={this.state.isRTL}
+            />
+          </View>
+        </View>
+      </View>
+    );
+  }
+
+  _onDirectionChange = () => {
+    I18nManager.forceRTL(!this.state.isRTL);
+    this.setState({isRTL: !this.state.isRTL});
+    Alert.alert(
+      'Reload this page',
+      'Please reload this page to change the UI direction! ' +
+        'All examples in this app will be affected. ' +
+        'Check them out to see what they look like in RTL layout.',
+    );
+  };
+}
+
+const SimpleListItemExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+      <View style={[styles.list, directionStyle(isRTL)]}>
+        <ListItem imageSource={require('../../assets/like.png')} />
+        <ListItem imageSource={require('../../assets/poke.png')} />
+      </View>
+    </View>
+  );
+});
+
+const AnimationContainer = withRTLState(({isRTL, setRTL}) => {
+  return <AnimationExample isRTL={isRTL} setRTL={setRTL} />;
+});
+
+class AnimationExample extends React.Component<any, AnimationState> {
+  constructor(props: Object) {
+    super(props);
+
+    this.state = {
+      toggleStatus: {},
+      linear: new Animated.Value(0),
+      windowWidth: 0,
+    };
+  }
+
+  render() {
+    return (
+      <View>
+        <RTLToggler setRTL={this.props.setRTL} isRTL={this.props.isRTL} />
+        <View style={styles.view} onLayout={this._onLayout}>
+          <AnimationBlock
+            onPress={this._linearTap}
+            imgStyle={{
+              transform: [
+                {translateX: this.state.linear},
+                {scaleX: this.props.isRTL ? -1 : 1},
+              ],
+            }}
+          />
+        </View>
+      </View>
+    );
+  }
+
+  _onLayout = (e: Object) => {
+    this.setState({
+      windowWidth: e.nativeEvent.layout.width,
+    });
+  };
+
+  _linearTap = (e: Object) => {
+    this.setState({
+      toggleStatus: {
+        ...this.state.toggleStatus,
+        [e]: !this.state.toggleStatus[e],
+      },
+    });
+    const offset = IMAGE_SIZE[0] / SCALE / 2 + 10;
+    const toMaxDistance =
+      (this.props.isRTL ? -1 : 1) * (this.state.windowWidth / 2 - offset);
+    Animated.timing(this.state.linear, {
+      toValue: this.state.toggleStatus[e] ? toMaxDistance : 0,
+      duration: 2000,
+      useNativeDriver: true,
+    }).start();
+  };
+}
+
+const PaddingExample = withRTLState(({isRTL, setRTL}) => {
+  const color = 'teal';
+
+  return (
+    <View>
+      <Text style={styles.bold}>Styles</Text>
+      <Text>paddingStart: 50,</Text>
+      <Text>paddingEnd: 10</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <Text>The {color} is padding.</Text>
+      <View
+        style={{
+          backgroundColor: color,
+          paddingStart: 50,
+          paddingEnd: 10,
+          borderWidth: 1,
+          borderColor: color,
+          direction: isRTL ? 'rtl' : 'ltr',
+        }}>
+        <View
+          style={{
+            backgroundColor: 'white',
+            paddingTop: 5,
+            paddingBottom: 5,
+            borderLeftWidth: 1,
+            borderRightWidth: 1,
+            borderColor: 'gray',
+          }}>
+          <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+        </View>
+      </View>
+    </View>
+  );
+});
+
+const MarginExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <Text style={styles.bold}>Styles</Text>
+      <Text>marginStart: 50,</Text>
+      <Text>marginEnd: 10</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <Text>The green is margin.</Text>
+      <View
+        style={{
+          backgroundColor: 'green',
+          borderWidth: 1,
+          borderColor: 'green',
+          direction: isRTL ? 'rtl' : 'ltr',
+        }}>
+        <View
+          style={{
+            backgroundColor: 'white',
+            paddingTop: 5,
+            paddingBottom: 5,
+            marginStart: 50,
+            marginEnd: 10,
+            borderLeftWidth: 1,
+            borderRightWidth: 1,
+            borderColor: 'gray',
+          }}>
+          <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+        </View>
+      </View>
+    </View>
+  );
+});
+
+const PositionExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <Text style={styles.bold}>Styles</Text>
+      <Text>start: 50</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <Text>The orange is position.</Text>
+      <View
+        style={{
+          backgroundColor: 'orange',
+          borderWidth: 1,
+          borderColor: 'orange',
+          direction: isRTL ? 'rtl' : 'ltr',
+        }}>
+        <View
+          style={{
+            backgroundColor: 'white',
+            start: 50,
+            borderColor: 'gray',
+          }}>
+          <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+        </View>
+      </View>
+      <Text />
+      <Text style={styles.bold}>Styles</Text>
+      <Text>end: 50</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <Text>The orange is position.</Text>
+      <View
+        style={{
+          backgroundColor: 'orange',
+          borderWidth: 1,
+          borderColor: 'orange',
+          direction: isRTL ? 'rtl' : 'ltr',
+        }}>
+        <View
+          style={{
+            backgroundColor: 'white',
+            end: 50,
+            borderColor: 'gray',
+          }}>
+          <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+        </View>
+      </View>
+    </View>
+  );
+});
+
+const BorderWidthExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <Text style={styles.bold}>Styles</Text>
+      <Text>borderStartWidth: 10,</Text>
+      <Text>borderEndWidth: 50</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <View style={directionStyle(isRTL)}>
+        <View
+          style={{
+            borderColor: 'black', // [Windows] specify a color
+            borderStartWidth: 10,
+            borderEndWidth: 50,
+          }}>
+          <View>
+            <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+          </View>
+        </View>
+      </View>
+    </View>
+  );
+});
+
+const BorderColorExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <Text style={styles.bold}>Styles</Text>
+      <Text>borderStartColor: 'red',</Text>
+      <Text>borderEndColor: 'green',</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <View style={directionStyle(isRTL)}>
+        <View
+          style={{
+            borderStartColor: 'red',
+            borderEndColor: 'green',
+            borderLeftWidth: 20,
+            borderRightWidth: 20,
+            padding: 10,
+          }}>
+          <View>
+            <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+          </View>
+        </View>
+      </View>
+    </View>
+  );
+});
+
+const BorderRadiiExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <Text style={styles.bold}>Styles</Text>
+      <Text>borderTopStartRadius: 10,</Text>
+      <Text>borderTopEndRadius: 20,</Text>
+      <Text>borderBottomStartRadius: 30,</Text>
+      <Text>borderBottomEndRadius: 40</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <View style={directionStyle(isRTL)}>
+        <View
+          style={{
+            borderColor: 'black', // [Windows] specify a color
+            borderWidth: 10,
+            borderTopStartRadius: 10,
+            borderTopEndRadius: 20,
+            borderBottomStartRadius: 30,
+            borderBottomEndRadius: 40,
+            padding: 10,
+          }}>
+          <View>
+            <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+          </View>
+        </View>
+      </View>
+    </View>
+  );
+});
+
+const BorderExample = withRTLState(({isRTL, setRTL}) => {
+  return (
+    <View>
+      <Text style={styles.bold}>Styles</Text>
+      <Text>borderStartColor: 'red',</Text>
+      <Text>borderEndColor: 'green',</Text>
+      <Text>borderStartWidth: 10,</Text>
+      <Text>borderEndWidth: 50,</Text>
+      <Text>borderTopStartRadius: 10,</Text>
+      <Text>borderTopEndRadius: 20,</Text>
+      <Text>borderBottomStartRadius: 30,</Text>
+      <Text>borderBottomEndRadius: 40</Text>
+      <Text />
+      <Text style={styles.bold}>Demo: </Text>
+      <View style={directionStyle(isRTL)}>
+        <View
+          style={{
+            borderStartColor: 'red',
+            borderEndColor: 'green',
+            borderStartWidth: 10,
+            borderEndWidth: 50,
+            borderTopStartRadius: 10,
+            borderTopEndRadius: 20,
+            borderBottomStartRadius: 30,
+            borderBottomEndRadius: 40,
+            padding: 10,
+          }}>
+          <View>
+            <RTLToggler setRTL={setRTL} isRTL={isRTL} />
+          </View>
+        </View>
+      </View>
+    </View>
+  );
+});
+
+const directionStyle = isRTL =>
+  Platform.OS !== 'android' ? {direction: isRTL ? 'rtl' : 'ltr'} : null; // [Windows] Don't explicitly check for iOS
+
+const styles = StyleSheet.create({
+  container: {
+    backgroundColor: '#e9eaed',
+    paddingTop: 15,
+  },
+  directionBox: {
+    flex: 1,
+    backgroundColor: '#f8f8f8',
+    borderWidth: 0.5,
+    borderColor: 'black',
+    marginBottom: 15,
+  },
+  directionText: {
+    padding: 10,
+    fontSize: 16,
+    textAlign: 'center',
+    fontWeight: 'bold',
+  },
+  switchRowTextView: {
+    flex: 1,
+    marginBottom: 5,
+    marginTop: 5,
+    textAlign: 'center',
+  },
+  switchRowSwitchView: {
+    flex: 3,
+  },
+  rightAlignStyle: {
+    right: 10,
+    position: 'absolute',
+  },
+  list: {
+    height: 120,
+    marginBottom: 5,
+    borderTopWidth: 0.5,
+    borderLeftWidth: 0.5,
+    borderRightWidth: 0.5,
+    borderColor: '#e5e5e5',
+  },
+  row: {
+    height: 60,
+    flexDirection: 'row',
+    borderBottomWidth: 0.5,
+    borderColor: '#e5e5e5',
+  },
+  column1: {
+    width: 60,
+  },
+  column2: {
+    flex: 2.5,
+    padding: 6,
+  },
+  column3: {
+    flex: 1.5,
+  },
+  icon: {
+    width: 48,
+    height: 48,
+    margin: 6,
+    borderWidth: 0.5,
+    borderColor: '#e5e5e5',
+  },
+  withRTLStyle: {
+    transform: [{scaleX: IS_RTL ? -1 : 1}],
+  },
+  image: {
+    left: 30,
+    width: 48,
+    height: 48,
+  },
+  img: {
+    width: IMAGE_SIZE[0] / SCALE,
+    height: IMAGE_SIZE[1] / SCALE,
+  },
+  view: {
+    flex: 1,
+  },
+  block: {
+    padding: 10,
+    alignItems: 'center',
+  },
+  smallButton: {
+    top: 18,
+    borderRadius: 5,
+    height: 24,
+    width: 64,
+    backgroundColor: '#e5e5e5',
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  fontSizeSmall: {
+    fontSize: 10,
+  },
+  fontSizeExtraSmall: {
+    fontSize: 8,
+  },
+  textAlignLeft: {
+    textAlign: 'left',
+  },
+  textAlignRight: {
+    textAlign: 'right',
+  },
+  textBox: {
+    width: 28,
+  },
+  flexDirectionRow: {
+    flexDirection: 'row',
+  },
+  bold: {
+    fontWeight: 'bold',
+  },
+  rtlToggler: {
+    color: 'gray',
+    padding: 8,
+    textAlign: 'center',
+    fontWeight: '500',
+  },
+});
+
+exports.title = 'RTLExample';
+exports.description = 'Examples to show how to apply components to RTL layout.';
+exports.examples = [
+  {
+    title: 'Current Layout Direction',
+    render: function(): React.Element<any> {
+      return <RTLToggleExample />;
+    },
+  },
+  {
+    title: 'A Simple List Item Layout',
+    render: function(): React.Element<any> {
+      return <SimpleListItemExample />;
+    },
+  },
+  {
+    title: 'Default Text Alignment',
+    description: ('In iOS, it depends on active language. ' +
+      'In Android, it depends on the text content.': string),
+    render: function(): React.Element<any> {
+      return <TextAlignmentExample style={styles.fontSizeSmall} />;
+    },
+  },
+  {
+    title: "Using textAlign: 'left'",
+    description: ('In iOS/Android, text alignment flips regardless of ' +
+      'languages or text content.': string),
+    render: function(): React.Element<any> {
+      return (
+        <TextAlignmentExample
+          style={[styles.fontSizeSmall, styles.textAlignLeft]}
+        />
+      );
+    },
+  },
+  {
+    title: "Using textAlign: 'right'",
+    description: ('In iOS/Android, text alignment flips regardless of ' +
+      'languages or text content.': string),
+    render: function(): React.Element<any> {
+      return (
+        <TextAlignmentExample
+          style={[styles.fontSizeSmall, styles.textAlignRight]}
+        />
+      );
+    },
+  },
+  {
+    title: 'Working With Icons',
+    render: function(): React.Element<any> {
+      return <IconsExample />;
+    },
+  },
+  {
+    title: 'Controlling Animation',
+    description: 'Animation direction according to layout',
+    render: function(): React.Element<any> {
+      return <AnimationContainer />;
+    },
+  },
+  {
+    title: 'Padding Start/End',
+    render: function(): React.Element<any> {
+      return <PaddingExample />;
+    },
+  },
+  {
+    title: 'Margin Start/End',
+    render: function(): React.Element<any> {
+      return <MarginExample />;
+    },
+  },
+  {
+    title: 'Position Start/End',
+    render: function(): React.Element<any> {
+      return <PositionExample />;
+    },
+  },
+  {
+    title: 'Border Width Start/End',
+    render: function(): React.Element<any> {
+      return <BorderWidthExample />;
+    },
+  },
+  {
+    title: 'Border Color Start/End',
+    render: function(): React.Element<any> {
+      return <BorderColorExample />;
+    },
+  },
+  {
+    title: 'Border Radii Start/End',
+    render: function(): React.Element<any> {
+      return <BorderRadiiExample />;
+    },
+  },
+  {
+    title: 'Border',
+    render: function(): React.Element<any> {
+      return <BorderExample />;
+    },
+  },
+];
diff --git a/vnext/src/overrides.json b/vnext/src/overrides.json
index c08977e63fd..ff537dfc57b 100644
--- a/vnext/src/overrides.json
+++ b/vnext/src/overrides.json
@@ -683,10 +683,10 @@
     {
       "type": "derived",
       "file": "Libraries\\Utilities\\BackHandler.windows.js",
-      "baseFile": "Libraries\\Utilities\\BackHandler.ios.js",
-      "baseVersion": "0.62.0-rc.3",
-      "baseHash": "aa2d482b80ae66104d632c75c24646fdcbe916af",
-      "issue": "LEGACY_FIXME"
+      "baseFile": "Libraries\\Utilities\\BackHandler.android.js",
+      "baseVersion": "0.62.2",
+      "baseHash": "b1633b6bb5e3dc842011b09f778626c39bf6b654",
+      "issue": 4629
     },
     {
       "type": "derived",
@@ -814,6 +814,14 @@
       "type": "platform",
       "file": "RNTester\\js\\examples-win\\WindowsBrush\\WindowsBrushExample.windows.tsx"
     },
+    {
+      "type": "patch",
+      "file": "RNTester\\js\\examples\\RTL\\RTLExample.windows.js",
+      "baseFile": "RNTester\\js\\examples\\RTL\\RTLExample.js",
+      "baseVersion": "0.62.2",
+      "baseHash": "70a65dc896406e7ad971f0a9a770b7ea30f43b9e",
+      "issue": 4678
+    },
     {
       "type": "patch",
       "file": "RNTester\\js\\examples\\ScrollView\\ScrollViewExample.windows.js",
diff --git a/yarn.lock b/yarn.lock
index 363d82f3a04..95232c8022e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2807,9 +2807,9 @@
   integrity sha1-7ihweulOEdK4J7y+UnC86n8+ce4=
 
 "@types/lodash@^4.14.149":
-  version "4.14.149"
-  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.149.tgz#1342d63d948c6062838fbf961012f74d4e638440"
-  integrity sha512-ijGqzZt/b7BfzcK9vTrS6MFljQRPn5BFWOx8oE0GYxribu6uV+aA9zZuXI1zc/etK9E8nrgdoF2+LgUw7+9tJQ==
+  version "4.14.150"
+  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.150.tgz#649fe44684c3f1fcb6164d943c5a61977e8cf0bd"
+  integrity sha512-kMNLM5JBcasgYscD9x/Gvr6lTAv2NVgsKtet/hm93qMyf/D1pt+7jeEZklKJKxMVmXjxbRVQQGfqDSfipYCO6w==
 
 "@types/minimatch@*":
   version "3.0.3"
@@ -4143,6 +4143,11 @@ ast-types@0.11.7:
   resolved "https://registry.yarnpkg.com/ast-types/-/ast-types-0.11.7.tgz#f318bf44e339db6a320be0009ded64ec1471f46c"
   integrity sha512-2mP3TwtkY/aTv5X3ZsMpNAbOnyoC/aMJwJSoaELPkHId0nSQgFcnU4dRW3isxiz7+zBexk0ym3WNVjMiQBnJSw==
 
+ast-types@0.13.3:
+  version "0.13.3"
+  resolved "https://registry.yarnpkg.com/ast-types/-/ast-types-0.13.3.tgz#50da3f28d17bdbc7969a3a2d83a0e4a72ae755a7"
+  integrity sha512-XTZ7xGML849LkQP86sWdQzfhwbt3YwIO6MqbX9mUNYY98VKaaVZP7YNNm70IpwecbkkxmfC5IYAzOQ/2p29zRA==
+
 astral-regex@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-1.0.0.tgz#6c8c3fb827dd43ee3918f27b82782ab7658a6fd9"
@@ -4450,9 +4455,9 @@ bcrypt-pbkdf@^1.0.0:
     tweetnacl "^0.14.3"
 
 beachball@^1.13.4:
-  version "1.29.1"
-  resolved "https://registry.yarnpkg.com/beachball/-/beachball-1.29.1.tgz#6893ccf7118f9652cfdf9a46b30b4c0a1a212ad0"
-  integrity sha512-xoRLCm1P1s6SdqXQah17WMtUf6B2AjTEU1hfqX2QODK+UhSloikM4Weu9aeJcdFxvryH8PlGTc60dll1rme23g==
+  version "1.30.2"
+  resolved "https://registry.yarnpkg.com/beachball/-/beachball-1.30.2.tgz#c0e645b783d74de23fea404ed220dac59aab651d"
+  integrity sha512-d/2+T5+vQD/32wAQAMY7hRVyVunjD0mRCVYLPYqfxBeYHMJeQ/Irwm8u1rhhjCf94oIdoVGn2dXtWLm99RcttA==
   dependencies:
     cosmiconfig "^6.0.0"
     fs-extra "^8.0.1"
@@ -4462,6 +4467,7 @@ beachball@^1.13.4:
     minimatch "^3.0.4"
     prompts "~2.1.0"
     semver "^6.1.1"
+    toposort "^2.0.2"
     yargs-parser "^13.1.0"
 
 before-after-hook@^2.0.0:
@@ -6852,6 +6858,11 @@ flow-parser@0.*:
   resolved "https://registry.yarnpkg.com/flow-parser/-/flow-parser-0.113.0.tgz#5b5913c54833918d0c3136ba69f6cf0cdd85fc20"
   integrity sha512-+hRyEB1sVLNMTMniDdM1JIS8BJ3HUL7IFIJaxX+t/JUy0GNYdI0Tg1QLx8DJmOF8HeoCrUDcREpnDAc/pPta3w==
 
+flow-parser@^0.121.0:
+  version "0.121.0"
+  resolved "https://registry.yarnpkg.com/flow-parser/-/flow-parser-0.121.0.tgz#9f9898eaec91a9f7c323e9e992d81ab5c58e618f"
+  integrity sha512-1gIBiWJNR0tKUNv8gZuk7l9rVX06OuLzY9AoGio7y/JT4V1IZErEMEq2TJS+PFcw/y0RshZ1J/27VfK1UQzYVg==
+
 flush-write-stream@^1.0.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/flush-write-stream/-/flush-write-stream-1.1.1.tgz#8dd7d873a1babc207d94ead0c2e0e44276ebf2e8"
@@ -7704,9 +7715,9 @@ invert-kv@^2.0.0:
   integrity sha512-wPVv/y/QQ/Uiirj/vh3oP+1Ww+AWehmi1g5fFWGPF6IpCBCDVrhgHRMvrLfdYcwDh3QJbGXDW4JAuzxElLSqKA==
 
 io-ts@^2.1.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/io-ts/-/io-ts-2.2.0.tgz#e01ee2031098f05ab2ef17d137b8bebc928644e2"
-  integrity sha512-BIZkC9IJ1ix8v3ttSWb5CWVzbEbMkGwjl0dMBGCXVT921/4f/9wAngsqA8VLXFe5JjLJ3INxBufz3BaQVf2zKw==
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/io-ts/-/io-ts-2.2.1.tgz#d8cb21a23cf8fbe697d78445a65bab42c0eb467f"
+  integrity sha512-RufppkTV58MfDKF2gXlHVBvi+WIyL7nUcAQMkJ1O3SiQcqwlxf6dBOJP/LV19UxHRkGKJZ6ImSj7LqYcELIejQ==
 
 io.appium.settings@^2.10.0:
   version "2.14.1"
@@ -8541,7 +8552,7 @@ jsc-android@^245459.0.0:
   resolved "https://registry.yarnpkg.com/jsc-android/-/jsc-android-245459.0.0.tgz#e584258dd0b04c9159a27fb104cd5d491fd202c9"
   integrity sha512-wkjURqwaB1daNkDi2OYYbsLnIdC/lUM2nPXQKRs5pqEU9chDg435bjvo+LSaHotDENygHQDHe+ntUkkw2gwMtg==
 
-jscodeshift@^0.6.2:
+jscodeshift@0.6.4, jscodeshift@^0.6.2:
   version "0.6.4"
   resolved "https://registry.yarnpkg.com/jscodeshift/-/jscodeshift-0.6.4.tgz#e19ab86214edac86a75c4557fc88b3937d558a8e"
   integrity sha512-+NF/tlNbc2WEhXUuc4WEJLsJumF84tnaMUZW2hyJw3jThKKRvsPX4sPJVgO1lPE28z0gNL+gwniLG9d8mYvQCQ==
@@ -8565,6 +8576,30 @@ jscodeshift@^0.6.2:
     temp "^0.8.1"
     write-file-atomic "^2.3.0"
 
+jscodeshift@^0.7.0:
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/jscodeshift/-/jscodeshift-0.7.0.tgz#4eee7506fd4fdacbd80340287d61575af991fdab"
+  integrity sha512-Kt6rpTa1HVhAWagD6J0y6qxxqRmDgkFvczerLgOsDNSGoUZSmq2CO1vFRcda9OV1BaZKSHCIh+VREPts5tB/Ig==
+  dependencies:
+    "@babel/core" "^7.1.6"
+    "@babel/parser" "^7.1.6"
+    "@babel/plugin-proposal-class-properties" "^7.1.0"
+    "@babel/plugin-proposal-object-rest-spread" "^7.0.0"
+    "@babel/preset-env" "^7.1.6"
+    "@babel/preset-flow" "^7.0.0"
+    "@babel/preset-typescript" "^7.1.0"
+    "@babel/register" "^7.0.0"
+    babel-core "^7.0.0-bridge.0"
+    colors "^1.1.2"
+    flow-parser "0.*"
+    graceful-fs "^4.1.11"
+    micromatch "^3.1.10"
+    neo-async "^2.5.0"
+    node-dir "^0.1.17"
+    recast "^0.18.1"
+    temp "^0.8.1"
+    write-file-atomic "^2.3.0"
+
 jsdom@^11.5.1:
   version "11.12.0"
   resolved "https://registry.yarnpkg.com/jsdom/-/jsdom-11.12.0.tgz#1a80d40ddd378a1de59656e9e6dc5a3ba8657bc8"
@@ -10326,7 +10361,7 @@ npm-run-path@^2.0.0:
     gauge "~2.7.3"
     set-blocking "~2.0.0"
 
-nullthrows@^1.1.0, nullthrows@^1.1.1:
+nullthrows@1.1.1, nullthrows@^1.1.0, nullthrows@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/nullthrows/-/nullthrows-1.1.1.tgz#7818258843856ae971eae4208ad7d7eb19a431b1"
   integrity sha512-2vPPEi+Z7WqML2jZYddDIfy5Dqb0r2fze2zTxNNknZaFpVHU3mFB3R+DWeJWGVx0ecvttSGlJTI+WG+8Z4cDWw==
@@ -11336,6 +11371,24 @@ react-is@^16.8.1, react-is@^16.8.4, react-is@^16.9.0:
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
 
+react-native-codegen@0.0.2:
+  version "0.0.2"
+  resolved "https://registry.yarnpkg.com/react-native-codegen/-/react-native-codegen-0.0.2.tgz#2a1c15a9deb80b62a5e9c0f215bb29900216f7ee"
+  integrity sha512-cZ28TUlYanjpca6dcxyGmZi4JKTmeaE4vJhjTABMRD+R7Rw6FtTAUqU2BoAKksEsrf8dJN5pQEUOSb4Cv0502Q==
+  dependencies:
+    flow-parser "^0.121.0"
+    jscodeshift "^0.7.0"
+    nullthrows "^1.1.1"
+
+react-native-tscodegen@0.0.10:
+  version "0.0.10"
+  resolved "https://registry.yarnpkg.com/react-native-tscodegen/-/react-native-tscodegen-0.0.10.tgz#2997f039625e55aac91a367ac3d6b496c50f1265"
+  integrity sha512-MwG76JC/YpelWgcOmPQIiYdIAL+4uwafFROVUMNHI1ko5LkSay1sY1D7FDdAq9fXE0kZoHna7YHD50DR6CLj8w==
+  dependencies:
+    jscodeshift "0.6.4"
+    nullthrows "1.1.1"
+    typescript "^3.5.3"
+
 react-native@0.62.2:
   version "0.62.2"
   resolved "https://registry.yarnpkg.com/react-native/-/react-native-0.62.2.tgz#d831e11a3178705449142df19a70ac2ca16bad10"
@@ -11540,6 +11593,16 @@ recast@^0.16.1:
     private "~0.1.5"
     source-map "~0.6.1"
 
+recast@^0.18.1:
+  version "0.18.10"
+  resolved "https://registry.yarnpkg.com/recast/-/recast-0.18.10.tgz#605ebbe621511eb89b6356a7e224bff66ed91478"
+  integrity sha512-XNvYvkfdAN9QewbrxeTOjgINkdY/odTgTS56ZNEWL9Ml0weT4T3sFtvnTuF+Gxyu46ANcRm1ntrF6F5LAJPAaQ==
+  dependencies:
+    ast-types "0.13.3"
+    esprima "~4.0.0"
+    private "^0.1.8"
+    source-map "~0.6.1"
+
 rechoir@^0.6.2:
   version "0.6.2"
   resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
@@ -13032,6 +13095,11 @@ toidentifier@1.0.0:
   resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.0.tgz#7e1be3470f1e77948bc43d94a3c8f4d7752ba553"
   integrity sha512-yaOH/Pk/VEhBWWTlhI+qXxDFXlejDGcQipMlyxda9nthulaxLZUNcUqFxokp0vcYnvteJln5FNQDRrxj3YcbVw==
 
+toposort@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/toposort/-/toposort-2.0.2.tgz#ae21768175d1559d48bef35420b2f4962f09c330"
+  integrity sha1-riF2gXXRVZ1IvvNUILL0li8JwzA=
+
 tough-cookie@^2.3.3, tough-cookie@^2.3.4:
   version "2.5.0"
   resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2"
@@ -13170,7 +13238,7 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
-typescript@^3.8.3:
+typescript@^3.5.3, typescript@^3.8.3:
   version "3.8.3"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.8.3.tgz#409eb8544ea0335711205869ec458ab109ee1061"
   integrity sha512-MYlEfn5VrLNsgudQTVJeNaQFUAI7DkhnOjdpAp4T+ku1TfQClewlbSuTVHiA+8skNBgaf02TL/kLOvig4y3G8w==