npm - react-native-windows - Versions diffs - 0.71.10 → 0.72.0-preview.2 - Mend

react-native-windows 0.71.10 → 0.72.0-preview.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (620) hide show

package/codegen/NativeHeadlessJsTaskSupportSpec.g.h CHANGED Viewed

@@ -16,7 +16,7 @@ namespace Microsoft::ReactNativeSpecs {
 struct HeadlessJsTaskSupportSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
       Method<void(double) noexcept>{0, L"notifyTaskFinished"},
-      Method<void(double, Promise<::React::JSValue>) noexcept>{1, L"notifyTaskRetry"},
+      Method<void(double, Promise<bool>) noexcept>{1, L"notifyTaskRetry"},
   };
   template <class TModule>
@@ -31,8 +31,8 @@ struct HeadlessJsTaskSupportSpec : winrt::Microsoft::ReactNative::TurboModuleSpe
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "notifyTaskRetry",
-          "    REACT_METHOD(notifyTaskRetry) void notifyTaskRetry(double taskId, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(notifyTaskRetry) static void notifyTaskRetry(double taskId, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(notifyTaskRetry) void notifyTaskRetry(double taskId, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(notifyTaskRetry) static void notifyTaskRetry(double taskId, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
   }
 };

package/codegen/NativeImageLoaderAndroidSpec.g.h CHANGED Viewed

@@ -13,12 +13,28 @@
 namespace Microsoft::ReactNativeSpecs {
+REACT_STRUCT(ImageLoaderAndroidSpec_getSize_returnType)
+struct ImageLoaderAndroidSpec_getSize_returnType {
+    REACT_FIELD(width)
+    double width;
+    REACT_FIELD(height)
+    double height;
+};
+REACT_STRUCT(ImageLoaderAndroidSpec_getSizeWithHeaders_returnType)
+struct ImageLoaderAndroidSpec_getSizeWithHeaders_returnType {
+    REACT_FIELD(width)
+    double width;
+    REACT_FIELD(height)
+    double height;
+};
 struct ImageLoaderAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
       Method<void(double) noexcept>{0, L"abortRequest"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{1, L"getSize"},
-      Method<void(std::string, ::React::JSValue, Promise<::React::JSValue>) noexcept>{2, L"getSizeWithHeaders"},
-      Method<void(std::string, double, Promise<::React::JSValue>) noexcept>{3, L"prefetchImage"},
+      Method<void(std::string, Promise<ImageLoaderAndroidSpec_getSize_returnType>) noexcept>{1, L"getSize"},
+      Method<void(std::string, ::React::JSValue, Promise<ImageLoaderAndroidSpec_getSizeWithHeaders_returnType>) noexcept>{2, L"getSizeWithHeaders"},
+      Method<void(std::string, double, Promise<bool>) noexcept>{3, L"prefetchImage"},
       Method<void(std::vector<std::string>, Promise<::React::JSValue>) noexcept>{4, L"queryCache"},
   };
@@ -34,18 +50,18 @@ struct ImageLoaderAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "getSize",
-          "    REACT_METHOD(getSize) void getSize(std::string uri, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getSize) static void getSize(std::string uri, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getSize) void getSize(std::string uri, ::React::ReactPromise<ImageLoaderAndroidSpec_getSize_returnType> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getSize) static void getSize(std::string uri, ::React::ReactPromise<ImageLoaderAndroidSpec_getSize_returnType> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "getSizeWithHeaders",
-          "    REACT_METHOD(getSizeWithHeaders) void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getSizeWithHeaders) static void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getSizeWithHeaders) void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<ImageLoaderAndroidSpec_getSizeWithHeaders_returnType> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getSizeWithHeaders) static void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<ImageLoaderAndroidSpec_getSizeWithHeaders_returnType> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "prefetchImage",
-          "    REACT_METHOD(prefetchImage) void prefetchImage(std::string uri, double requestId, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(prefetchImage) static void prefetchImage(std::string uri, double requestId, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(prefetchImage) void prefetchImage(std::string uri, double requestId, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(prefetchImage) static void prefetchImage(std::string uri, double requestId, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "queryCache",

package/codegen/NativeImageLoaderIOSSpec.g.h CHANGED Viewed

@@ -13,12 +13,20 @@
 namespace Microsoft::ReactNativeSpecs {
+REACT_STRUCT(ImageLoaderIOSSpec_getSizeWithHeaders_returnType)
+struct ImageLoaderIOSSpec_getSizeWithHeaders_returnType {
+    REACT_FIELD(width)
+    double width;
+    REACT_FIELD(height)
+    double height;
+};
 struct ImageLoaderIOSSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{0, L"getSize"},
-      Method<void(std::string, ::React::JSValue, Promise<::React::JSValue>) noexcept>{1, L"getSizeWithHeaders"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{2, L"prefetchImage"},
-      Method<void(std::string, std::string, double, Promise<::React::JSValue>) noexcept>{3, L"prefetchImageWithMetadata"},
+      Method<void(std::string, Promise<std::vector<double>>) noexcept>{0, L"getSize"},
+      Method<void(std::string, ::React::JSValue, Promise<ImageLoaderIOSSpec_getSizeWithHeaders_returnType>) noexcept>{1, L"getSizeWithHeaders"},
+      Method<void(std::string, Promise<bool>) noexcept>{2, L"prefetchImage"},
+      Method<void(std::string, std::string, double, Promise<bool>) noexcept>{3, L"prefetchImageWithMetadata"},
       Method<void(std::vector<std::string>, Promise<::React::JSValue>) noexcept>{4, L"queryCache"},
   };
@@ -29,23 +37,23 @@ struct ImageLoaderIOSSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "getSize",
-          "    REACT_METHOD(getSize) void getSize(std::string uri, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getSize) static void getSize(std::string uri, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getSize) void getSize(std::string uri, ::React::ReactPromise<std::vector<double>> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getSize) static void getSize(std::string uri, ::React::ReactPromise<std::vector<double>> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "getSizeWithHeaders",
-          "    REACT_METHOD(getSizeWithHeaders) void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getSizeWithHeaders) static void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getSizeWithHeaders) void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<ImageLoaderIOSSpec_getSizeWithHeaders_returnType> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getSizeWithHeaders) static void getSizeWithHeaders(std::string uri, ::React::JSValue && headers, ::React::ReactPromise<ImageLoaderIOSSpec_getSizeWithHeaders_returnType> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "prefetchImage",
-          "    REACT_METHOD(prefetchImage) void prefetchImage(std::string uri, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(prefetchImage) static void prefetchImage(std::string uri, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(prefetchImage) void prefetchImage(std::string uri, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(prefetchImage) static void prefetchImage(std::string uri, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "prefetchImageWithMetadata",
-          "    REACT_METHOD(prefetchImageWithMetadata) void prefetchImageWithMetadata(std::string uri, std::string queryRootName, double rootTag, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(prefetchImageWithMetadata) static void prefetchImageWithMetadata(std::string uri, std::string queryRootName, double rootTag, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(prefetchImageWithMetadata) void prefetchImageWithMetadata(std::string uri, std::string queryRootName, double rootTag, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(prefetchImageWithMetadata) static void prefetchImageWithMetadata(std::string uri, std::string queryRootName, double rootTag, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "queryCache",

package/codegen/NativeIntentAndroidSpec.g.h CHANGED Viewed

@@ -15,11 +15,11 @@ namespace Microsoft::ReactNativeSpecs {
 struct IntentAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(Promise<::React::JSValue>) noexcept>{0, L"getInitialURL"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{1, L"canOpenURL"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{2, L"openURL"},
-      Method<void(Promise<::React::JSValue>) noexcept>{3, L"openSettings"},
-      Method<void(std::string, std::optional<::React::JSValueArray>, Promise<::React::JSValue>) noexcept>{4, L"sendIntent"},
+      Method<void(Promise<std::string>) noexcept>{0, L"getInitialURL"},
+      Method<void(std::string, Promise<bool>) noexcept>{1, L"canOpenURL"},
+      Method<void(std::string, Promise<void>) noexcept>{2, L"openURL"},
+      Method<void(Promise<void>) noexcept>{3, L"openSettings"},
+      Method<void(std::string, std::optional<::React::JSValueArray>, Promise<void>) noexcept>{4, L"sendIntent"},
   };
   template <class TModule>
@@ -29,28 +29,28 @@ struct IntentAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "getInitialURL",
-          "    REACT_METHOD(getInitialURL) void getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getInitialURL) static void getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getInitialURL) void getInitialURL(::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getInitialURL) static void getInitialURL(::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "canOpenURL",
-          "    REACT_METHOD(canOpenURL) void canOpenURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(canOpenURL) static void canOpenURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(canOpenURL) void canOpenURL(std::string url, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(canOpenURL) static void canOpenURL(std::string url, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "openURL",
-          "    REACT_METHOD(openURL) void openURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(openURL) static void openURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(openURL) void openURL(std::string url, ::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(openURL) static void openURL(std::string url, ::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "openSettings",
-          "    REACT_METHOD(openSettings) void openSettings(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(openSettings) static void openSettings(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(openSettings) void openSettings(::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(openSettings) static void openSettings(::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "sendIntent",
-          "    REACT_METHOD(sendIntent) void sendIntent(std::string action, std::optional<::React::JSValueArray> extras, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(sendIntent) static void sendIntent(std::string action, std::optional<::React::JSValueArray> extras, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(sendIntent) void sendIntent(std::string action, std::optional<::React::JSValueArray> extras, ::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(sendIntent) static void sendIntent(std::string action, std::optional<::React::JSValueArray> extras, ::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n");
   }
 };

package/codegen/NativeLinkingManagerSpec.g.h CHANGED Viewed

@@ -15,10 +15,10 @@ namespace Microsoft::ReactNativeSpecs {
 struct LinkingManagerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(Promise<::React::JSValue>) noexcept>{0, L"getInitialURL"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{1, L"canOpenURL"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{2, L"openURL"},
-      Method<void(Promise<::React::JSValue>) noexcept>{3, L"openSettings"},
+      Method<void(Promise<std::string>) noexcept>{0, L"getInitialURL"},
+      Method<void(std::string, Promise<bool>) noexcept>{1, L"canOpenURL"},
+      Method<void(std::string, Promise<void>) noexcept>{2, L"openURL"},
+      Method<void(Promise<void>) noexcept>{3, L"openSettings"},
       Method<void(std::string) noexcept>{4, L"addListener"},
       Method<void(double) noexcept>{5, L"removeListeners"},
   };
@@ -30,23 +30,23 @@ struct LinkingManagerSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "getInitialURL",
-          "    REACT_METHOD(getInitialURL) void getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getInitialURL) static void getInitialURL(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getInitialURL) void getInitialURL(::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getInitialURL) static void getInitialURL(::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "canOpenURL",
-          "    REACT_METHOD(canOpenURL) void canOpenURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(canOpenURL) static void canOpenURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(canOpenURL) void canOpenURL(std::string url, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(canOpenURL) static void canOpenURL(std::string url, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "openURL",
-          "    REACT_METHOD(openURL) void openURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(openURL) static void openURL(std::string url, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(openURL) void openURL(std::string url, ::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(openURL) static void openURL(std::string url, ::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "openSettings",
-          "    REACT_METHOD(openSettings) void openSettings(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(openSettings) static void openSettings(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(openSettings) void openSettings(::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(openSettings) static void openSettings(::React::ReactPromise<void> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "addListener",

package/codegen/NativePerformanceObserverSpec.g.h CHANGED Viewed

@@ -31,12 +31,25 @@ struct PerformanceObserverSpec_RawPerformanceEntry {
     std::optional<double> interactionId;
 };
+REACT_STRUCT(PerformanceObserverSpec_GetPendingEntriesResult)
+struct PerformanceObserverSpec_GetPendingEntriesResult {
+    REACT_FIELD(entries)
+    std::vector<PerformanceObserverSpec_RawPerformanceEntry> entries;
+    REACT_FIELD(droppedEntriesCount)
+    double droppedEntriesCount;
+};
 struct PerformanceObserverSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(std::string) noexcept>{0, L"startReporting"},
-      Method<void(std::string) noexcept>{1, L"stopReporting"},
-      SyncMethod<std::vector<PerformanceObserverSpec_RawPerformanceEntry>() noexcept>{2, L"getPendingEntries"},
+      Method<void(double) noexcept>{0, L"startReporting"},
+      Method<void(double) noexcept>{1, L"stopReporting"},
+      SyncMethod<PerformanceObserverSpec_GetPendingEntriesResult() noexcept>{2, L"popPendingEntries"},
       Method<void(Callback<>) noexcept>{3, L"setOnPerformanceEntryCallback"},
+      Method<void(PerformanceObserverSpec_RawPerformanceEntry) noexcept>{4, L"logRawEntry"},
+      SyncMethod<::React::JSValueArray() noexcept>{5, L"getEventCounts"},
+      Method<void(double, double) noexcept>{6, L"setDurationThreshold"},
+      Method<void(double, std::string) noexcept>{7, L"clearEntries"},
+      SyncMethod<std::vector<PerformanceObserverSpec_RawPerformanceEntry>(double, std::string) noexcept>{8, L"getEntries"},
   };
   template <class TModule>
@@ -46,23 +59,48 @@ struct PerformanceObserverSpec : winrt::Microsoft::ReactNative::TurboModuleSpec
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "startReporting",
-          "    REACT_METHOD(startReporting) void startReporting(std::string entryType) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(startReporting) static void startReporting(std::string entryType) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(startReporting) void startReporting(double entryType) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(startReporting) static void startReporting(double entryType) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "stopReporting",
-          "    REACT_METHOD(stopReporting) void stopReporting(std::string entryType) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(stopReporting) static void stopReporting(std::string entryType) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(stopReporting) void stopReporting(double entryType) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(stopReporting) static void stopReporting(double entryType) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
-          "getPendingEntries",
-          "    REACT_SYNC_METHOD(getPendingEntries) std::vector<PerformanceObserverSpec_RawPerformanceEntry> getPendingEntries() noexcept { /* implementation */ }\n"
-          "    REACT_SYNC_METHOD(getPendingEntries) static std::vector<PerformanceObserverSpec_RawPerformanceEntry> getPendingEntries() noexcept { /* implementation */ }\n");
+          "popPendingEntries",
+          "    REACT_SYNC_METHOD(popPendingEntries) PerformanceObserverSpec_GetPendingEntriesResult popPendingEntries() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(popPendingEntries) static PerformanceObserverSpec_GetPendingEntriesResult popPendingEntries() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "setOnPerformanceEntryCallback",
           "    REACT_METHOD(setOnPerformanceEntryCallback) void setOnPerformanceEntryCallback(std::function<void()> const & callback) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(setOnPerformanceEntryCallback) static void setOnPerformanceEntryCallback(std::function<void()> const & callback) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          4,
+          "logRawEntry",
+          "    REACT_METHOD(logRawEntry) void logRawEntry(PerformanceObserverSpec_RawPerformanceEntry && entry) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(logRawEntry) static void logRawEntry(PerformanceObserverSpec_RawPerformanceEntry && entry) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          5,
+          "getEventCounts",
+          "    REACT_SYNC_METHOD(getEventCounts) ::React::JSValueArray getEventCounts() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getEventCounts) static ::React::JSValueArray getEventCounts() noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          6,
+          "setDurationThreshold",
+          "    REACT_METHOD(setDurationThreshold) void setDurationThreshold(double entryType, double durationThreshold) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(setDurationThreshold) static void setDurationThreshold(double entryType, double durationThreshold) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          7,
+          "clearEntries",
+          "    REACT_METHOD(clearEntries) void clearEntries(double entryType, std::string entryName) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(clearEntries) static void clearEntries(double entryType, std::string entryName) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          8,
+          "getEntries",
+          "    REACT_SYNC_METHOD(getEntries) std::vector<PerformanceObserverSpec_RawPerformanceEntry> getEntries(double entryType, std::string entryName) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getEntries) static std::vector<PerformanceObserverSpec_RawPerformanceEntry> getEntries(double entryType, std::string entryName) noexcept { /* implementation */ }\n");
   }
 };

package/codegen/NativePerformanceSpec.g.h ADDED Viewed

@@ -0,0 +1,63 @@
+/*
+ * 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(PerformanceSpec_ReactNativeStartupTiming)
+struct PerformanceSpec_ReactNativeStartupTiming {
+    REACT_FIELD(startTime)
+    double startTime;
+    REACT_FIELD(endTime)
+    double endTime;
+    REACT_FIELD(executeJavaScriptBundleEntryPointStart)
+    double executeJavaScriptBundleEntryPointStart;
+    REACT_FIELD(executeJavaScriptBundleEntryPointEnd)
+    double executeJavaScriptBundleEntryPointEnd;
+};
+struct PerformanceSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
+  static constexpr auto methods = std::tuple{
+      Method<void(std::string, double, double) noexcept>{0, L"mark"},
+      Method<void(std::string, double, double, double, std::string, std::string) noexcept>{1, L"measure"},
+      SyncMethod<::React::JSValue() noexcept>{2, L"getSimpleMemoryInfo"},
+      SyncMethod<PerformanceSpec_ReactNativeStartupTiming() noexcept>{3, L"getReactNativeStartupTiming"},
+  };
+  template <class TModule>
+  static constexpr void ValidateModule() noexcept {
+    constexpr auto methodCheckResults = CheckMethods<TModule, PerformanceSpec>();
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          0,
+          "mark",
+          "    REACT_METHOD(mark) void mark(std::string name, double startTime, double duration) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(mark) static void mark(std::string name, double startTime, double duration) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          1,
+          "measure",
+          "    REACT_METHOD(measure) void measure(std::string name, double startTime, double endTime, double duration, std::string startMark, std::string endMark) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(measure) static void measure(std::string name, double startTime, double endTime, double duration, std::string startMark, std::string endMark) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          2,
+          "getSimpleMemoryInfo",
+          "    REACT_SYNC_METHOD(getSimpleMemoryInfo) ::React::JSValue getSimpleMemoryInfo() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getSimpleMemoryInfo) static ::React::JSValue getSimpleMemoryInfo() noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          3,
+          "getReactNativeStartupTiming",
+          "    REACT_SYNC_METHOD(getReactNativeStartupTiming) PerformanceSpec_ReactNativeStartupTiming getReactNativeStartupTiming() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getReactNativeStartupTiming) static PerformanceSpec_ReactNativeStartupTiming getReactNativeStartupTiming() noexcept { /* implementation */ }\n");
+  }
+};
+} // namespace Microsoft::ReactNativeSpecs

package/codegen/NativePermissionsAndroidSpec.g.h CHANGED Viewed

@@ -15,9 +15,9 @@ namespace Microsoft::ReactNativeSpecs {
 struct PermissionsAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{0, L"checkPermission"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{1, L"requestPermission"},
-      Method<void(std::string, Promise<::React::JSValue>) noexcept>{2, L"shouldShowRequestPermissionRationale"},
+      Method<void(std::string, Promise<bool>) noexcept>{0, L"checkPermission"},
+      Method<void(std::string, Promise<std::string>) noexcept>{1, L"requestPermission"},
+      Method<void(std::string, Promise<bool>) noexcept>{2, L"shouldShowRequestPermissionRationale"},
       Method<void(std::vector<std::string>, Promise<::React::JSValue>) noexcept>{3, L"requestMultiplePermissions"},
   };
@@ -28,18 +28,18 @@ struct PermissionsAndroidSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "checkPermission",
-          "    REACT_METHOD(checkPermission) void checkPermission(std::string permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(checkPermission) static void checkPermission(std::string permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(checkPermission) void checkPermission(std::string permission, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(checkPermission) static void checkPermission(std::string permission, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
           "requestPermission",
-          "    REACT_METHOD(requestPermission) void requestPermission(std::string permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(requestPermission) static void requestPermission(std::string permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(requestPermission) void requestPermission(std::string permission, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(requestPermission) static void requestPermission(std::string permission, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
           "shouldShowRequestPermissionRationale",
-          "    REACT_METHOD(shouldShowRequestPermissionRationale) void shouldShowRequestPermissionRationale(std::string permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(shouldShowRequestPermissionRationale) static void shouldShowRequestPermissionRationale(std::string permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(shouldShowRequestPermissionRationale) void shouldShowRequestPermissionRationale(std::string permission, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(shouldShowRequestPermissionRationale) static void shouldShowRequestPermissionRationale(std::string permission, ::React::ReactPromise<bool> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "requestMultiplePermissions",

package/codegen/NativePlatformConstantsWinSpec.g.h CHANGED Viewed

@@ -22,7 +22,7 @@ struct PlatformConstantsWinSpec_Constants_reactNativeVersion {
     REACT_FIELD(patch)
     double patch;
     REACT_FIELD(prerelease)
-    std::optional<double> prerelease;
+    std::optional<std::string> prerelease;
 };
 REACT_STRUCT(PlatformConstantsWinSpec_Constants)

package/codegen/NativePushNotificationManagerIOSSpec.g.h CHANGED Viewed

@@ -62,14 +62,14 @@ struct PushNotificationManagerIOSSpec : winrt::Microsoft::ReactNative::TurboModu
       Method<void(std::string, std::string) noexcept>{0, L"onFinishRemoteNotification"},
       Method<void(double) noexcept>{1, L"setApplicationIconBadgeNumber"},
       Method<void(Callback<double>) noexcept>{2, L"getApplicationIconBadgeNumber"},
-      Method<void(PushNotificationManagerIOSSpec_requestPermissions_permission, Promise<::React::JSValue>) noexcept>{3, L"requestPermissions"},
+      Method<void(PushNotificationManagerIOSSpec_requestPermissions_permission, Promise<PushNotificationManagerIOSSpec_Permissions>) noexcept>{3, L"requestPermissions"},
       Method<void() noexcept>{4, L"abandonPermissions"},
       Method<void(Callback<PushNotificationManagerIOSSpec_Permissions>) noexcept>{5, L"checkPermissions"},
       Method<void(PushNotificationManagerIOSSpec_Notification) noexcept>{6, L"presentLocalNotification"},
       Method<void(PushNotificationManagerIOSSpec_Notification) noexcept>{7, L"scheduleLocalNotification"},
       Method<void() noexcept>{8, L"cancelAllLocalNotifications"},
       Method<void(::React::JSValue) noexcept>{9, L"cancelLocalNotifications"},
-      Method<void(Promise<::React::JSValue>) noexcept>{10, L"getInitialNotification"},
+      Method<void(Promise<std::optional<PushNotificationManagerIOSSpec_Notification>>) noexcept>{10, L"getInitialNotification"},
       Method<void(Callback<PushNotificationManagerIOSSpec_Notification>) noexcept>{11, L"getScheduledLocalNotifications"},
       Method<void() noexcept>{12, L"removeAllDeliveredNotifications"},
       Method<void(std::vector<std::string>) noexcept>{13, L"removeDeliveredNotifications"},
@@ -101,8 +101,8 @@ struct PushNotificationManagerIOSSpec : winrt::Microsoft::ReactNative::TurboModu
     REACT_SHOW_METHOD_SPEC_ERRORS(
           3,
           "requestPermissions",
-          "    REACT_METHOD(requestPermissions) void requestPermissions(PushNotificationManagerIOSSpec_requestPermissions_permission && permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(requestPermissions) static void requestPermissions(PushNotificationManagerIOSSpec_requestPermissions_permission && permission, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(requestPermissions) void requestPermissions(PushNotificationManagerIOSSpec_requestPermissions_permission && permission, ::React::ReactPromise<PushNotificationManagerIOSSpec_Permissions> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(requestPermissions) static void requestPermissions(PushNotificationManagerIOSSpec_requestPermissions_permission && permission, ::React::ReactPromise<PushNotificationManagerIOSSpec_Permissions> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           4,
           "abandonPermissions",
@@ -136,8 +136,8 @@ struct PushNotificationManagerIOSSpec : winrt::Microsoft::ReactNative::TurboModu
     REACT_SHOW_METHOD_SPEC_ERRORS(
           10,
           "getInitialNotification",
-          "    REACT_METHOD(getInitialNotification) void getInitialNotification(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getInitialNotification) static void getInitialNotification(::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getInitialNotification) void getInitialNotification(::React::ReactPromise<std::optional<PushNotificationManagerIOSSpec_Notification>> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getInitialNotification) static void getInitialNotification(::React::ReactPromise<std::optional<PushNotificationManagerIOSSpec_Notification>> &&result) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           11,
           "getScheduledLocalNotifications",

package/codegen/NativeSampleTurboModuleSpec.g.h CHANGED Viewed

@@ -30,15 +30,16 @@ struct SampleTurboModuleSpec : 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<::React::JSValueArray(::React::JSValueArray) noexcept>{4, L"getArray"},
-      SyncMethod<::React::JSValue(::React::JSValue) noexcept>{5, L"getObject"},
-      SyncMethod<::React::JSValue(::React::JSValue) noexcept>{6, L"getUnsafeObject"},
-      SyncMethod<double(double) noexcept>{7, L"getRootTag"},
-      SyncMethod<::React::JSValue(double, std::string, ::React::JSValue) noexcept>{8, L"getValue"},
-      Method<void(Callback<std::string>) noexcept>{9, L"getValueWithCallback"},
-      Method<void(bool, Promise<::React::JSValue>) noexcept>{10, L"getValueWithPromise"},
+      SyncMethod<double(double) noexcept>{2, L"getEnum"},
+      SyncMethod<double(double) noexcept>{3, L"getNumber"},
+      SyncMethod<std::string(std::string) noexcept>{4, L"getString"},
+      SyncMethod<::React::JSValueArray(::React::JSValueArray) noexcept>{5, L"getArray"},
+      SyncMethod<::React::JSValue(::React::JSValue) noexcept>{6, L"getObject"},
+      SyncMethod<::React::JSValue(::React::JSValue) noexcept>{7, L"getUnsafeObject"},
+      SyncMethod<double(double) noexcept>{8, L"getRootTag"},
+      SyncMethod<::React::JSValue(double, std::string, ::React::JSValue) noexcept>{9, L"getValue"},
+      Method<void(Callback<std::string>) noexcept>{10, L"getValueWithCallback"},
+      Method<void(bool, Promise<std::string>) noexcept>{11, L"getValueWithPromise"},
   };
   template <class TModule>
@@ -64,49 +65,54 @@ struct SampleTurboModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
           "    REACT_SYNC_METHOD(getBool) static bool getBool(bool arg) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           2,
+          "getEnum",
+          "    REACT_SYNC_METHOD(getEnum) double getEnum(double arg) noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(getEnum) static double getEnum(double arg) noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          3,
           "getNumber",
           "    REACT_SYNC_METHOD(getNumber) double getNumber(double arg) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getNumber) static double getNumber(double arg) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          3,
+          4,
           "getString",
           "    REACT_SYNC_METHOD(getString) std::string getString(std::string arg) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getString) static std::string getString(std::string arg) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          4,
+          5,
           "getArray",
           "    REACT_SYNC_METHOD(getArray) ::React::JSValueArray getArray(::React::JSValueArray && arg) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getArray) static ::React::JSValueArray getArray(::React::JSValueArray && arg) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          5,
+          6,
           "getObject",
           "    REACT_SYNC_METHOD(getObject) ::React::JSValue getObject(::React::JSValue && arg) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getObject) static ::React::JSValue getObject(::React::JSValue && arg) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          6,
+          7,
           "getUnsafeObject",
           "    REACT_SYNC_METHOD(getUnsafeObject) ::React::JSValue getUnsafeObject(::React::JSValue && arg) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getUnsafeObject) static ::React::JSValue getUnsafeObject(::React::JSValue && arg) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          7,
+          8,
           "getRootTag",
           "    REACT_SYNC_METHOD(getRootTag) double getRootTag(double arg) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getRootTag) static double getRootTag(double arg) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          8,
+          9,
           "getValue",
           "    REACT_SYNC_METHOD(getValue) ::React::JSValue getValue(double x, std::string y, ::React::JSValue && z) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getValue) static ::React::JSValue getValue(double x, std::string y, ::React::JSValue && z) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          9,
+          10,
           "getValueWithCallback",
           "    REACT_METHOD(getValueWithCallback) void getValueWithCallback(std::function<void(std::string)> const & callback) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(getValueWithCallback) static void getValueWithCallback(std::function<void(std::string)> const & callback) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          10,
+          11,
           "getValueWithPromise",
-          "    REACT_METHOD(getValueWithPromise) void getValueWithPromise(bool error, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(getValueWithPromise) static void getValueWithPromise(bool error, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(getValueWithPromise) void getValueWithPromise(bool error, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(getValueWithPromise) static void getValueWithPromise(bool error, ::React::ReactPromise<std::string> &&result) noexcept { /* implementation */ }\n");
   }
 };

package/codegen/NativeShareModuleSpec.g.h CHANGED Viewed

@@ -21,9 +21,15 @@ struct ShareModuleSpec_share_content {
     std::optional<std::string> message;
 };
+REACT_STRUCT(ShareModuleSpec_share_returnType)
+struct ShareModuleSpec_share_returnType {
+    REACT_FIELD(action)
+    std::string action;
+};
 struct ShareModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
-      Method<void(ShareModuleSpec_share_content, std::string, Promise<::React::JSValue>) noexcept>{0, L"share"},
+      Method<void(ShareModuleSpec_share_content, std::string, Promise<ShareModuleSpec_share_returnType>) noexcept>{0, L"share"},
   };
   template <class TModule>
@@ -33,8 +39,8 @@ struct ShareModuleSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
     REACT_SHOW_METHOD_SPEC_ERRORS(
           0,
           "share",
-          "    REACT_METHOD(share) void share(ShareModuleSpec_share_content && content, std::string dialogTitle, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n"
-          "    REACT_METHOD(share) static void share(ShareModuleSpec_share_content && content, std::string dialogTitle, ::React::ReactPromise<::React::JSValue> &&result) noexcept { /* implementation */ }\n");
+          "    REACT_METHOD(share) void share(ShareModuleSpec_share_content && content, std::string dialogTitle, ::React::ReactPromise<ShareModuleSpec_share_returnType> &&result) noexcept { /* implementation */ }\n"
+          "    REACT_METHOD(share) static void share(ShareModuleSpec_share_content && content, std::string dialogTitle, ::React::ReactPromise<ShareModuleSpec_share_returnType> &&result) noexcept { /* implementation */ }\n");
   }
 };