react-native-windows 0.66.1 → 0.67.0-preview.2

package/codegen/NativeAsyncSQLiteDBStorageSpec.g.h

@@ -13,14 +13,62 @@
 
 namespace Microsoft::ReactNativeSpecs {
 
+REACT_STRUCT(AsyncSQLiteDBStorageSpec_multiGet_callback_errors_element)
+struct AsyncSQLiteDBStorageSpec_multiGet_callback_errors_element {
+    REACT_FIELD(message)
+    std::string message;
+    REACT_FIELD(key)
+    std::optional<std::string> key;
+};
+
+REACT_STRUCT(AsyncSQLiteDBStorageSpec_multiSet_callback_errors_element)
+struct AsyncSQLiteDBStorageSpec_multiSet_callback_errors_element {
+    REACT_FIELD(message)
+    std::string message;
+    REACT_FIELD(key)
+    std::optional<std::string> key;
+};
+
+REACT_STRUCT(AsyncSQLiteDBStorageSpec_multiMerge_callback_errors_element)
+struct AsyncSQLiteDBStorageSpec_multiMerge_callback_errors_element {
+    REACT_FIELD(message)
+    std::string message;
+    REACT_FIELD(key)
+    std::optional<std::string> key;
+};
+
+REACT_STRUCT(AsyncSQLiteDBStorageSpec_multiRemove_callback_errors_element)
+struct AsyncSQLiteDBStorageSpec_multiRemove_callback_errors_element {
+    REACT_FIELD(message)
+    std::string message;
+    REACT_FIELD(key)
+    std::optional<std::string> key;
+};
+
+REACT_STRUCT(AsyncSQLiteDBStorageSpec_clear_callback_error)
+struct AsyncSQLiteDBStorageSpec_clear_callback_error {
+    REACT_FIELD(message)
+    std::string message;
+    REACT_FIELD(key)
+    std::optional<std::string> key;
+};
+
+REACT_STRUCT(AsyncSQLiteDBStorageSpec_getAllKeys_callback_error)
+struct AsyncSQLiteDBStorageSpec_getAllKeys_callback_error {
+    REACT_FIELD(message)
+    std::string message;
+    REACT_FIELD(key)
+    std::optional<std::string> key;
+};
+
 struct AsyncSQLiteDBStorageSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(React::JSValueArray, Callback<React::JSValue>) noexcept>{0, L"multiGet"},
-      Method<void(React::JSValueArray, Callback<React::JSValue>) noexcept>{1, L"multiSet"},
-      Method<void(React::JSValueArray, Callback<React::JSValue>) noexcept>{2, L"multiMerge"},
-      Method<void(React::JSValueArray, Callback<React::JSValue>) noexcept>{3, L"multiRemove"},
-      Method<void(Callback<React::JSValue>) noexcept>{4, L"clear"},
-      Method<void(Callback<React::JSValue>) noexcept>{5, L"getAllKeys"},
+      Method<void(std::vector<std::string>, Callback<std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiGet_callback_errors_element>>, std::optional<std::vector<std::vector<std::string>>>>) noexcept>{0, L"multiGet"},
+      Method<void(std::vector<std::vector<std::string>>, Callback<std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiSet_callback_errors_element>>>) noexcept>{1, L"multiSet"},
+      Method<void(std::vector<std::vector<std::string>>, Callback<std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiMerge_callback_errors_element>>>) noexcept>{2, L"multiMerge"},
+      Method<void(std::vector<std::string>, Callback<std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiRemove_callback_errors_element>>>) noexcept>{3, L"multiRemove"},
+      Method<void(Callback<AsyncSQLiteDBStorageSpec_clear_callback_error>) noexcept>{4, L"clear"},
+      Method<void(Callback<std::optional<AsyncSQLiteDBStorageSpec_getAllKeys_callback_error>, std::optional<std::vector<std::string>>>) noexcept>{5, L"getAllKeys"},
   };
 
   template <class TModule>
@@ -30,33 +78,33 @@ struct AsyncSQLiteDBStorageSpec : winrt::Microsoft::ReactNative::TurboModuleSpec
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "multiGet",
-          "    REACT_METHOD(multiGet) void multiGet(React::JSValueArray && keys, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(multiGet) static void multiGet(React::JSValueArray && keys, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(multiGet) void multiGet(std::vector<std::string> const & keys, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiGet_callback_errors_element>>, std::optional<std::vector<std::vector<std::string>>>)> const & callback) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(multiGet) static void multiGet(std::vector<std::string> const & keys, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiGet_callback_errors_element>>, std::optional<std::vector<std::vector<std::string>>>)> const & callback) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "multiSet",
-          "    REACT_METHOD(multiSet) void multiSet(React::JSValueArray && kvPairs, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(multiSet) static void multiSet(React::JSValueArray && kvPairs, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(multiSet) void multiSet(std::vector<std::vector<std::string>> const & kvPairs, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiSet_callback_errors_element>>)> const & callback) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(multiSet) static void multiSet(std::vector<std::vector<std::string>> const & kvPairs, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiSet_callback_errors_element>>)> const & callback) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "multiMerge",
-          "    REACT_METHOD(multiMerge) void multiMerge(React::JSValueArray && kvPairs, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(multiMerge) static void multiMerge(React::JSValueArray && kvPairs, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(multiMerge) void multiMerge(std::vector<std::vector<std::string>> const & kvPairs, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiMerge_callback_errors_element>>)> const & callback) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(multiMerge) static void multiMerge(std::vector<std::vector<std::string>> const & kvPairs, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiMerge_callback_errors_element>>)> const & callback) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "multiRemove",
-          "    REACT_METHOD(multiRemove) void multiRemove(React::JSValueArray && keys, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(multiRemove) static void multiRemove(React::JSValueArray && keys, std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(multiRemove) void multiRemove(std::vector<std::string> const & keys, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiRemove_callback_errors_element>>)> const & callback) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(multiRemove) static void multiRemove(std::vector<std::string> const & keys, std::function<void(std::optional<std::vector<AsyncSQLiteDBStorageSpec_multiRemove_callback_errors_element>>)> const & callback) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "clear",
-          "    REACT_METHOD(clear) void clear(std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(clear) static void clear(std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(clear) void clear(std::function<void(AsyncSQLiteDBStorageSpec_clear_callback_error const &)> const & callback) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(clear) static void clear(std::function<void(AsyncSQLiteDBStorageSpec_clear_callback_error const &)> const & callback) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           5,
           "getAllKeys",
-          "    REACT_METHOD(getAllKeys) void getAllKeys(std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(getAllKeys) static void getAllKeys(std::function<void(React::JSValue const &)> const & callback) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(getAllKeys) void getAllKeys(std::function<void(std::optional<AsyncSQLiteDBStorageSpec_getAllKeys_callback_error>, std::optional<std::vector<std::string>>)> const & callback) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(getAllKeys) static void getAllKeys(std::function<void(std::optional<AsyncSQLiteDBStorageSpec_getAllKeys_callback_error>, std::optional<std::vector<std::string>>)> const & callback) noexcept { /* implementation */ }}\n");
   }
 };
 

package/codegen/NativeBlobModuleSpec.g.h

@@ -13,20 +13,38 @@
 
 namespace Microsoft::ReactNativeSpecs {
 
+REACT_STRUCT(BlobModuleSpec_Constants)
+struct BlobModuleSpec_Constants {
+    REACT_FIELD(BLOB_URI_SCHEME)
+    std::optional<std::string> BLOB_URI_SCHEME;
+    REACT_FIELD(BLOB_URI_HOST)
+    std::optional<std::string> BLOB_URI_HOST;
+};
+
 struct BlobModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto constants = std::tuple{
+      TypedConstant<BlobModuleSpec_Constants>{0},
+  };
   static constexpr auto methods = std::tuple{
       Method<void() noexcept>{0, L"addNetworkingHandler"},
       Method<void(double) noexcept>{1, L"addWebSocketHandler"},
       Method<void(double) noexcept>{2, L"removeWebSocketHandler"},
-      Method<void(React::JSValueObject, double) noexcept>{3, L"sendOverSocket"},
-      Method<void(React::JSValueArray, std::string) noexcept>{4, L"createFromParts"},
+      Method<void(React::JSValue, double) noexcept>{3, L"sendOverSocket"},
+      Method<void(std::vector<React::JSValue>, std::string) noexcept>{4, L"createFromParts"},
       Method<void(std::string) noexcept>{5, L"release"},
   };
 
   template <class TModule>
   static constexpr void ValidateModule() noexcept {
+    constexpr auto constantCheckResults = CheckConstants<TModule, BlobModuleSpec>();
     constexpr auto methodCheckResults = CheckMethods<TModule, BlobModuleSpec>();
 
+    REACT_SHOW_CONSTANT_SPEC_ERRORS(
+          0,
+          "BlobModuleSpec_Constants",
+          "    REACT_GET_CONSTANTS(GetConstants) BlobModuleSpec_Constants GetConstants() noexcept {/*implementation*/}\n"
+          "    REACT_GET_CONSTANTS(GetConstants) static BlobModuleSpec_Constants GetConstants() noexcept {/*implementation*/}\n");
+
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "addNetworkingHandler",
@@ -45,13 +63,13 @@ struct BlobModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "sendOverSocket",
-          "    REACT_METHOD(sendOverSocket) void sendOverSocket(React::JSValueObject && blob, double socketID) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(sendOverSocket) static void sendOverSocket(React::JSValueObject && blob, double socketID) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(sendOverSocket) void sendOverSocket(React::JSValue && blob, double socketID) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(sendOverSocket) static void sendOverSocket(React::JSValue && blob, double socketID) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "createFromParts",
-          "    REACT_METHOD(createFromParts) void createFromParts(React::JSValueArray && parts, std::string withId) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(createFromParts) static void createFromParts(React::JSValueArray && parts, std::string withId) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(createFromParts) void createFromParts(std::vector<React::JSValue> const & parts, std::string withId) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(createFromParts) static void createFromParts(std::vector<React::JSValue> const & parts, std::string withId) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           5,
           "release",

package/codegen/NativeBugReportingSpec.g.h

@@ -16,7 +16,7 @@ namespace Microsoft::ReactNativeSpecs {
 struct BugReportingSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
       Method<void() noexcept>{0, L"startReportAProblemFlow"},
-      Method<void(React::JSValueObject, React::JSValueObject) noexcept>{1, L"setExtraData"},
+      Method<void(React::JSValue, React::JSValue) noexcept>{1, L"setExtraData"},
       Method<void(std::string) noexcept>{2, L"setCategoryID"},
   };
 
@@ -32,8 +32,8 @@ struct BugReportingSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "setExtraData",
-          "    REACT_METHOD(setExtraData) void setExtraData(React::JSValueObject && extraData, React::JSValueObject && extraFiles) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(setExtraData) static void setExtraData(React::JSValueObject && extraData, React::JSValueObject && extraFiles) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(setExtraData) void setExtraData(React::JSValue && extraData, React::JSValue && extraFiles) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(setExtraData) static void setExtraData(React::JSValue && extraData, React::JSValue && extraFiles) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "setCategoryID",

package/codegen/NativeDatePickerAndroidSpec.g.h

@@ -15,7 +15,7 @@ namespace Microsoft::ReactNativeSpecs {
 
 struct DatePickerAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(React::JSValueObject, Promise<React::JSValue>) noexcept>{0, L"open"},
+      Method<void(React::JSValue, Promise<React::JSValue>) noexcept>{0, L"open"},
   };
 
   template <class TModule>
@@ -25,8 +25,8 @@ struct DatePickerAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "open",
-          "    REACT_METHOD(open) void open(React::JSValueObject && options, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(open) static void open(React::JSValueObject && options, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(open) void open(React::JSValue && options, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(open) static void open(React::JSValue && options, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n");
   }
 };
 

package/codegen/NativeDevLoadingViewSpec.g.h

@@ -15,7 +15,7 @@ namespace Microsoft::ReactNativeSpecs {
 
 struct DevLoadingViewSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(std::string, double, double) noexcept>{0, L"showMessage"},
+      Method<void(std::string, std::optional<double>, std::optional<double>) noexcept>{0, L"showMessage"},
       Method<void() noexcept>{1, L"hide"},
   };
 
@@ -26,8 +26,8 @@ struct DevLoadingViewSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "showMessage",
-          "    REACT_METHOD(showMessage) void showMessage(std::string message, double withColor, double withBackgroundColor) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(showMessage) static void showMessage(std::string message, double withColor, double withBackgroundColor) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(showMessage) void showMessage(std::string message, std::optional<double> withColor, std::optional<double> withBackgroundColor) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(showMessage) static void showMessage(std::string message, std::optional<double> withColor, std::optional<double> withBackgroundColor) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "hide",

package/codegen/NativeDeviceInfoSpec.g.h

@@ -51,15 +51,33 @@ struct DeviceInfoSpec_DimensionsPayload {
     std::optional<DeviceInfoSpec_DisplayMetricsAndroid> screenPhysicalPixels;
 };
 
+REACT_STRUCT(DeviceInfoSpec_Constants)
+struct DeviceInfoSpec_Constants {
+    REACT_FIELD(Dimensions)
+    DeviceInfoSpec_DimensionsPayload Dimensions;
+    REACT_FIELD(isIPhoneX_deprecated)
+    std::optional<bool> isIPhoneX_deprecated;
+};
+
 struct DeviceInfoSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto constants = std::tuple{
+      TypedConstant<DeviceInfoSpec_Constants>{0},
+  };
   static constexpr auto methods = std::tuple{
 
   };
 
   template <class TModule>
   static constexpr void ValidateModule() noexcept {
+    constexpr auto constantCheckResults = CheckConstants<TModule, DeviceInfoSpec>();
     constexpr auto methodCheckResults = CheckMethods<TModule, DeviceInfoSpec>();
 
+    REACT_SHOW_CONSTANT_SPEC_ERRORS(
+          0,
+          "DeviceInfoSpec_Constants",
+          "    REACT_GET_CONSTANTS(GetConstants) DeviceInfoSpec_Constants GetConstants() noexcept {/*implementation*/}\n"
+          "    REACT_GET_CONSTANTS(GetConstants) static DeviceInfoSpec_Constants GetConstants() noexcept {/*implementation*/}\n");
+
 
   }
 };

package/codegen/NativeDialogManagerAndroidSpec.g.h

@@ -26,25 +26,49 @@ struct DialogManagerAndroidSpec_DialogOptions {
     REACT_FIELD(buttonNeutral)
     std::optional<std::string> buttonNeutral;
     REACT_FIELD(items)
-    std::optional<React::JSValueArray> items;
+    std::optional<std::vector<std::string>> items;
     REACT_FIELD(cancelable)
     std::optional<bool> cancelable;
 };
 
+REACT_STRUCT(DialogManagerAndroidSpec_Constants)
+struct DialogManagerAndroidSpec_Constants {
+    REACT_FIELD(buttonClicked)
+    std::string buttonClicked;
+    REACT_FIELD(dismissed)
+    std::string dismissed;
+    REACT_FIELD(buttonPositive)
+    double buttonPositive;
+    REACT_FIELD(buttonNegative)
+    double buttonNegative;
+    REACT_FIELD(buttonNeutral)
+    double buttonNeutral;
+};
+
 struct DialogManagerAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto constants = std::tuple{
+      TypedConstant<DialogManagerAndroidSpec_Constants>{0},
+  };
   static constexpr auto methods = std::tuple{
-      Method<void(DialogManagerAndroidSpec_DialogOptions, Callback<React::JSValue>, Callback<React::JSValue>) noexcept>{0, L"showAlert"},
+      Method<void(DialogManagerAndroidSpec_DialogOptions, Callback<std::string>, Callback<std::string, double>) noexcept>{0, L"showAlert"},
   };
 
   template <class TModule>
   static constexpr void ValidateModule() noexcept {
+    constexpr auto constantCheckResults = CheckConstants<TModule, DialogManagerAndroidSpec>();
     constexpr auto methodCheckResults = CheckMethods<TModule, DialogManagerAndroidSpec>();
 
+    REACT_SHOW_CONSTANT_SPEC_ERRORS(
+          0,
+          "DialogManagerAndroidSpec_Constants",
+          "    REACT_GET_CONSTANTS(GetConstants) DialogManagerAndroidSpec_Constants GetConstants() noexcept {/*implementation*/}\n"
+          "    REACT_GET_CONSTANTS(GetConstants) static DialogManagerAndroidSpec_Constants GetConstants() noexcept {/*implementation*/}\n");
+
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "showAlert",
-          "    REACT_METHOD(showAlert) void showAlert(DialogManagerAndroidSpec_DialogOptions && config, std::function<void(React::JSValue const &)> const & onError, std::function<void(React::JSValue const &)> const & onAction) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(showAlert) static void showAlert(DialogManagerAndroidSpec_DialogOptions && config, std::function<void(React::JSValue const &)> const & onError, std::function<void(React::JSValue const &)> const & onAction) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(showAlert) void showAlert(DialogManagerAndroidSpec_DialogOptions && config, std::function<void(std::string)> const & onError, std::function<void(std::string, double)> const & onAction) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(showAlert) static void showAlert(DialogManagerAndroidSpec_DialogOptions && config, std::function<void(std::string)> const & onError, std::function<void(std::string, double)> const & onAction) noexcept { /* implementation */ }}\n");
   }
 };
 

package/codegen/NativeDialogManagerWindowsSpec.g.h

@@ -0,0 +1,77 @@
+
+/*
+ * This file is auto-generated from a NativeModule spec file in js.
+ *
+ * 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.
+ */
+#pragma once
+
+#include "NativeModules.h"
+#include <tuple>
+
+namespace Microsoft::ReactNativeSpecs {
+
+REACT_STRUCT(DialogManagerWindowsSpec_DialogOptions)
+struct DialogManagerWindowsSpec_DialogOptions {
+    REACT_FIELD(title)
+    std::optional<std::string> title;
+    REACT_FIELD(message)
+    std::optional<std::string> message;
+    REACT_FIELD(buttonPositive)
+    std::optional<std::string> buttonPositive;
+    REACT_FIELD(buttonNegative)
+    std::optional<std::string> buttonNegative;
+    REACT_FIELD(buttonNeutral)
+    std::optional<std::string> buttonNeutral;
+    REACT_FIELD(items)
+    std::optional<std::vector<std::string>> items;
+    REACT_FIELD(cancelable)
+    std::optional<bool> cancelable;
+    REACT_FIELD(defaultButton)
+    std::optional<int> defaultButton;
+};
+
+REACT_STRUCT(DialogManagerWindowsSpec_Constants)
+struct DialogManagerWindowsSpec_Constants {
+    REACT_FIELD(buttonClicked)
+    std::string buttonClicked;
+    REACT_FIELD(dismissed)
+    std::string dismissed;
+    REACT_FIELD(buttonPositive)
+    int buttonPositive;
+    REACT_FIELD(buttonNegative)
+    int buttonNegative;
+    REACT_FIELD(buttonNeutral)
+    int buttonNeutral;
+};
+
+struct DialogManagerWindowsSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto constants = std::tuple{
+      TypedConstant<DialogManagerWindowsSpec_Constants>{0},
+  };
+  static constexpr auto methods = std::tuple{
+      Method<void(DialogManagerWindowsSpec_DialogOptions, Callback<std::string>, Callback<std::string, int>) noexcept>{0, L"showAlert"},
+  };
+
+  template <class TModule>
+  static constexpr void ValidateModule() noexcept {
+    constexpr auto constantCheckResults = CheckConstants<TModule, DialogManagerWindowsSpec>();
+    constexpr auto methodCheckResults = CheckMethods<TModule, DialogManagerWindowsSpec>();
+
+    REACT_SHOW_CONSTANT_SPEC_ERRORS(
+          0,
+          "DialogManagerWindowsSpec_Constants",
+          "    REACT_GET_CONSTANTS(GetConstants) DialogManagerWindowsSpec_Constants GetConstants() noexcept {/*implementation*/}\n"
+          "    REACT_GET_CONSTANTS(GetConstants) static DialogManagerWindowsSpec_Constants GetConstants() noexcept {/*implementation*/}\n");
+
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          0,
+          "showAlert",
+          "    REACT_METHOD(showAlert) void showAlert(DialogManagerWindowsSpec_DialogOptions && config, std::function<void(std::string)> const & onError, std::function<void(std::string, int)> const & onAction) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(showAlert) static void showAlert(DialogManagerWindowsSpec_DialogOptions && config, std::function<void(std::string)> const & onError, std::function<void(std::string, int)> const & onAction) noexcept { /* implementation */ }}\n");
+  }
+};
+
+} // namespace Microsoft::ReactNativeSpecs

package/codegen/NativeExceptionsManagerSpec.g.h

@@ -38,21 +38,21 @@ struct ExceptionsManagerSpec_ExceptionData {
     REACT_FIELD(componentStack)
     std::optional<std::string> componentStack;
     REACT_FIELD(stack)
-    React::JSValueArray stack;
+    std::vector<ExceptionsManagerSpec_StackFrame> stack;
     REACT_FIELD(id)
     double id;
     REACT_FIELD(isFatal)
     bool isFatal;
     REACT_FIELD(extraData)
-    std::optional<React::JSValueObject> extraData;
+    std::optional<React::JSValue> extraData;
 };
 
 struct ExceptionsManagerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(std::string, React::JSValueArray, double) noexcept>{0, L"reportFatalException"},
-      Method<void(std::string, React::JSValueArray, double) noexcept>{1, L"reportSoftException"},
+      Method<void(std::string, std::vector<ExceptionsManagerSpec_StackFrame>, double) noexcept>{0, L"reportFatalException"},
+      Method<void(std::string, std::vector<ExceptionsManagerSpec_StackFrame>, double) noexcept>{1, L"reportSoftException"},
       Method<void(ExceptionsManagerSpec_ExceptionData) noexcept>{2, L"reportException"},
-      Method<void(std::string, React::JSValueArray, double) noexcept>{3, L"updateExceptionMessage"},
+      Method<void(std::string, std::vector<ExceptionsManagerSpec_StackFrame>, double) noexcept>{3, L"updateExceptionMessage"},
       Method<void() noexcept>{4, L"dismissRedbox"},
   };
 
@@ -63,13 +63,13 @@ struct ExceptionsManagerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "reportFatalException",
-          "    REACT_METHOD(reportFatalException) void reportFatalException(std::string message, React::JSValueArray && stack, double exceptionId) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(reportFatalException) static void reportFatalException(std::string message, React::JSValueArray && stack, double exceptionId) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(reportFatalException) void reportFatalException(std::string message, std::vector<ExceptionsManagerSpec_StackFrame> const & stack, double exceptionId) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(reportFatalException) static void reportFatalException(std::string message, std::vector<ExceptionsManagerSpec_StackFrame> const & stack, double exceptionId) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "reportSoftException",
-          "    REACT_METHOD(reportSoftException) void reportSoftException(std::string message, React::JSValueArray && stack, double exceptionId) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(reportSoftException) static void reportSoftException(std::string message, React::JSValueArray && stack, double exceptionId) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(reportSoftException) void reportSoftException(std::string message, std::vector<ExceptionsManagerSpec_StackFrame> const & stack, double exceptionId) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(reportSoftException) static void reportSoftException(std::string message, std::vector<ExceptionsManagerSpec_StackFrame> const & stack, double exceptionId) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "reportException",
@@ -78,8 +78,8 @@ struct ExceptionsManagerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "updateExceptionMessage",
-          "    REACT_METHOD(updateExceptionMessage) void updateExceptionMessage(std::string message, React::JSValueArray && stack, double exceptionId) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(updateExceptionMessage) static void updateExceptionMessage(std::string message, React::JSValueArray && stack, double exceptionId) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(updateExceptionMessage) void updateExceptionMessage(std::string message, std::vector<ExceptionsManagerSpec_StackFrame> const & stack, double exceptionId) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(updateExceptionMessage) static void updateExceptionMessage(std::string message, std::vector<ExceptionsManagerSpec_StackFrame> const & stack, double exceptionId) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "dismissRedbox",

package/codegen/NativeFileReaderModuleSpec.g.h

@@ -15,8 +15,8 @@ namespace Microsoft::ReactNativeSpecs {
 
 struct FileReaderModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(React::JSValueObject, Promise<React::JSValue>) noexcept>{0, L"readAsDataURL"},
-      Method<void(React::JSValueObject, std::string, Promise<React::JSValue>) noexcept>{1, L"readAsText"},
+      Method<void(React::JSValue, Promise<React::JSValue>) noexcept>{0, L"readAsDataURL"},
+      Method<void(React::JSValue, std::string, Promise<React::JSValue>) noexcept>{1, L"readAsText"},
   };
 
   template <class TModule>
@@ -26,13 +26,13 @@ struct FileReaderModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "readAsDataURL",
-          "    REACT_METHOD(readAsDataURL) void readAsDataURL(React::JSValueObject && data, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(readAsDataURL) static void readAsDataURL(React::JSValueObject && data, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(readAsDataURL) void readAsDataURL(React::JSValue && data, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(readAsDataURL) static void readAsDataURL(React::JSValue && data, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "readAsText",
-          "    REACT_METHOD(readAsText) void readAsText(React::JSValueObject && data, std::string encoding, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(readAsText) static void readAsText(React::JSValueObject && data, std::string encoding, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(readAsText) void readAsText(React::JSValue && data, std::string encoding, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(readAsText) static void readAsText(React::JSValue && data, std::string encoding, React::ReactPromise<React::JSValue> &&result) noexcept { /* implementation */ }}\n");
   }
 };
 

package/codegen/NativeFrameRateLoggerSpec.g.h

@@ -13,9 +13,17 @@
 
 namespace Microsoft::ReactNativeSpecs {
 
+REACT_STRUCT(FrameRateLoggerSpec_setGlobalOptions_options)
+struct FrameRateLoggerSpec_setGlobalOptions_options {
+    REACT_FIELD(debug)
+    std::optional<bool> debug;
+    REACT_FIELD(reportStackTraces)
+    std::optional<bool> reportStackTraces;
+};
+
 struct FrameRateLoggerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(React::JSValueObject) noexcept>{0, L"setGlobalOptions"},
+      Method<void(FrameRateLoggerSpec_setGlobalOptions_options) noexcept>{0, L"setGlobalOptions"},
       Method<void(std::string) noexcept>{1, L"setContext"},
       Method<void() noexcept>{2, L"beginScroll"},
       Method<void() noexcept>{3, L"endScroll"},
@@ -28,8 +36,8 @@ struct FrameRateLoggerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "setGlobalOptions",
-          "    REACT_METHOD(setGlobalOptions) void setGlobalOptions(React::JSValueObject && options) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(setGlobalOptions) static void setGlobalOptions(React::JSValueObject && options) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(setGlobalOptions) void setGlobalOptions(FrameRateLoggerSpec_setGlobalOptions_options && options) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(setGlobalOptions) static void setGlobalOptions(FrameRateLoggerSpec_setGlobalOptions_options && options) noexcept { /* implementation */ }}\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "setContext",

package/codegen/NativeI18nManagerSpec.g.h

@@ -13,7 +13,20 @@
 
 namespace Microsoft::ReactNativeSpecs {
 
+REACT_STRUCT(I18nManagerSpec_Constants)
+struct I18nManagerSpec_Constants {
+    REACT_FIELD(isRTL)
+    bool isRTL;
+    REACT_FIELD(doLeftAndRightSwapInRTL)
+    bool doLeftAndRightSwapInRTL;
+    REACT_FIELD(localeIdentifier)
+    std::optional<std::string> localeIdentifier;
+};
+
 struct I18nManagerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto constants = std::tuple{
+      TypedConstant<I18nManagerSpec_Constants>{0},
+  };
   static constexpr auto methods = std::tuple{
       Method<void(bool) noexcept>{0, L"allowRTL"},
       Method<void(bool) noexcept>{1, L"forceRTL"},
@@ -22,8 +35,15 @@ struct I18nManagerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
 
   template <class TModule>
   static constexpr void ValidateModule() noexcept {
+    constexpr auto constantCheckResults = CheckConstants<TModule, I18nManagerSpec>();
     constexpr auto methodCheckResults = CheckMethods<TModule, I18nManagerSpec>();
 
+    REACT_SHOW_CONSTANT_SPEC_ERRORS(
+          0,
+          "I18nManagerSpec_Constants",
+          "    REACT_GET_CONSTANTS(GetConstants) I18nManagerSpec_Constants GetConstants() noexcept {/*implementation*/}\n"
+          "    REACT_GET_CONSTANTS(GetConstants) static I18nManagerSpec_Constants GetConstants() noexcept {/*implementation*/}\n");
+
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "allowRTL",

package/codegen/NativeImageEditorSpec.g.h

@@ -13,14 +13,38 @@
 
 namespace Microsoft::ReactNativeSpecs {
 
+REACT_STRUCT(ImageEditorSpec_Options_offset)
+struct ImageEditorSpec_Options_offset {
+    REACT_FIELD(x)
+    double x;
+    REACT_FIELD(y)
+    double y;
+};
+
+REACT_STRUCT(ImageEditorSpec_Options_size)
+struct ImageEditorSpec_Options_size {
+    REACT_FIELD(width)
+    double width;
+    REACT_FIELD(height)
+    double height;
+};
+
+REACT_STRUCT(ImageEditorSpec_Options_displaySize)
+struct ImageEditorSpec_Options_displaySize {
+    REACT_FIELD(width)
+    double width;
+    REACT_FIELD(height)
+    double height;
+};
+
 REACT_STRUCT(ImageEditorSpec_Options)
 struct ImageEditorSpec_Options {
     REACT_FIELD(offset)
-    React::JSValueObject offset;
+    ImageEditorSpec_Options_offset offset;
     REACT_FIELD(size)
-    React::JSValueObject size;
+    ImageEditorSpec_Options_size size;
     REACT_FIELD(displaySize)
-    std::optional<React::JSValueObject> displaySize;
+    std::optional<ImageEditorSpec_Options_displaySize> displaySize;
     REACT_FIELD(resizeMode)
     std::optional<std::string> resizeMode;
     REACT_FIELD(allowExternalStorage)
@@ -29,7 +53,7 @@ struct ImageEditorSpec_Options {
 
 struct ImageEditorSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(std::string, ImageEditorSpec_Options, Callback<React::JSValue>, Callback<React::JSValue>) noexcept>{0, L"cropImage"},
+      Method<void(std::string, ImageEditorSpec_Options, Callback<std::string>, Callback<std::string>) noexcept>{0, L"cropImage"},
   };
 
   template <class TModule>
@@ -39,8 +63,8 @@ struct ImageEditorSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "cropImage",
-          "    REACT_METHOD(cropImage) void cropImage(std::string uri, ImageEditorSpec_Options && cropData, std::function<void(React::JSValue const &)> const & successCallback, std::function<void(React::JSValue const &)> const & errorCallback) noexcept { /* implementation */ }}\n"
-          "    REACT_METHOD(cropImage) static void cropImage(std::string uri, ImageEditorSpec_Options && cropData, std::function<void(React::JSValue const &)> const & successCallback, std::function<void(React::JSValue const &)> const & errorCallback) noexcept { /* implementation */ }}\n");
+          "    REACT_METHOD(cropImage) void cropImage(std::string uri, ImageEditorSpec_Options && cropData, std::function<void(std::string)> const & successCallback, std::function<void(std::string)> const & errorCallback) noexcept { /* implementation */ }}\n"
+          "    REACT_METHOD(cropImage) static void cropImage(std::string uri, ImageEditorSpec_Options && cropData, std::function<void(std::string)> const & successCallback, std::function<void(std::string)> const & errorCallback) noexcept { /* implementation */ }}\n");
   }
 };