feat(smart-app): implement complete mobile app MVP

- App.tsx: full navigation (Auth stack + Main tabs with 5 screens)
- Auth: LoginScreen, RegisterScreen, ForgotPasswordScreen
- HomeScreen: dashboard with IoT metrics, weather widget, alerts, quick actions, sensors
- MapScreen: interactive map with layer toggles (6 layers)
- MarketplaceScreen: categories (6), products (5), search
- ChatScreen: AI chat with quick prompts (4), bot responses
- ProfileScreen: user info, stats, menu (9 items), logout
- AlertsScreen: alert list with severity, acknowledge
- SensorsScreen: sensor list with type filters (6 types), search
- ZonesScreen: zone cards with stats
- SettingsScreen: language picker (FR/EN/ES/DE), privacy, about
- Stores: iotStore (sensors, zones, alerts), notificationStore, uiStore + i18n
- Hooks: useSensors, useAlerts, useNotifications, useLocation
- Components: Card, Button, LoadingSpinner, ErrorBoundary, Header
- Services: iotService, notificationService (with axios API client)
- Utils: formatters (temp, AQI, noise, dates), validators (email, password, IBAN)
- Theme: colors.ts with full design system (Blue Ocean palette)
- Ditto: fixed MongoDB connection, new JWT secrets, official gateway image

smart-app-city/frontend/node_modules/react-native/ReactCommon/reactperflogger/.clang-tidy

@@ -0,0 +1,6 @@
+---
+Checks: '>
+clang-diagnostic-*,
+'
+InheritParentConfig: true
+...

smart-app-city/frontend/node_modules/react-native/ReactCommon/reactperflogger/CMakeLists.txt

@@ -0,0 +1,19 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+add_compile_options(
+        -fexceptions
+        -frtti
+        -std=c++20
+        -Wall
+        -Wpedantic)
+
+file(GLOB reactperflogger_SRC CONFIGURE_DEPENDS reactperflogger/*.cpp)
+add_library(reactperflogger STATIC ${reactperflogger_SRC})
+
+target_include_directories(reactperflogger PUBLIC .)

smart-app-city/frontend/node_modules/react-native/ReactCommon/reactperflogger/React-perflogger.podspec

@@ -0,0 +1,36 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+folly_config = get_folly_config()
+folly_compiler_flags = folly_config[:compiler_flags]
+folly_version = folly_config[:version]
+boost_compiler_flags = '-Wno-documentation'
+
+Pod::Spec.new do |s|
+  s.name                   = "React-perflogger"
+  s.version                = version
+  s.summary                = "-"  # TODO
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = "**/*.{cpp,h}"
+  s.header_dir             = "reactperflogger"
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++20" }
+end

smart-app-city/frontend/node_modules/react-native/ReactCommon/reactperflogger/reactperflogger/BridgeNativeModulePerfLogger.cpp

@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "BridgeNativeModulePerfLogger.h"
+
+namespace facebook::react {
+namespace BridgeNativeModulePerfLogger {
+
+std::unique_ptr<NativeModulePerfLogger> g_perfLogger = nullptr;
+
+void enableLogging(std::unique_ptr<NativeModulePerfLogger>&& newPerfLogger) {
+  g_perfLogger = std::move(newPerfLogger);
+}
+
+void disableLogging() {
+  g_perfLogger = nullptr;
+}
+
+void moduleDataCreateStart(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleDataCreateStart(moduleName, id);
+  }
+}
+
+void moduleDataCreateEnd(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleDataCreateEnd(moduleName, id);
+  }
+}
+
+void moduleCreateStart(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateStart(moduleName, id);
+  }
+}
+
+void moduleCreateCacheHit(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateCacheHit(moduleName, id);
+  }
+}
+
+void moduleCreateConstructStart(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateConstructStart(moduleName, id);
+  }
+}
+
+void moduleCreateConstructEnd(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateConstructEnd(moduleName, id);
+  }
+}
+
+void moduleCreateSetUpStart(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateSetUpStart(moduleName, id);
+  }
+}
+
+void moduleCreateSetUpEnd(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateSetUpEnd(moduleName, id);
+  }
+}
+
+void moduleCreateEnd(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateEnd(moduleName, id);
+  }
+}
+
+void moduleCreateFail(const char* moduleName, int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleCreateFail(moduleName, id);
+  }
+}
+
+void moduleJSRequireBeginningStart(const char* moduleName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleJSRequireBeginningStart(moduleName);
+  }
+}
+
+void moduleJSRequireBeginningCacheHit(const char* moduleName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleJSRequireBeginningCacheHit(moduleName);
+  }
+}
+
+void moduleJSRequireBeginningEnd(const char* moduleName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleJSRequireBeginningEnd(moduleName);
+  }
+}
+
+void moduleJSRequireBeginningFail(const char* moduleName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleJSRequireBeginningFail(moduleName);
+  }
+}
+
+void moduleJSRequireEndingStart(const char* moduleName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleJSRequireEndingStart(moduleName);
+  }
+}
+
+void moduleJSRequireEndingEnd(const char* moduleName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleJSRequireEndingEnd(moduleName);
+  }
+}
+
+void moduleJSRequireEndingFail(const char* moduleName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->moduleJSRequireEndingFail(moduleName);
+  }
+}
+
+void syncMethodCallStart(const char* moduleName, const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallStart(moduleName, methodName);
+  }
+}
+
+void syncMethodCallArgConversionStart(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallArgConversionStart(moduleName, methodName);
+  }
+}
+
+void syncMethodCallArgConversionEnd(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallArgConversionEnd(moduleName, methodName);
+  }
+}
+
+void syncMethodCallExecutionStart(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallExecutionStart(moduleName, methodName);
+  }
+}
+void syncMethodCallExecutionEnd(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallExecutionEnd(moduleName, methodName);
+  }
+}
+
+void syncMethodCallReturnConversionStart(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallReturnConversionStart(moduleName, methodName);
+  }
+}
+
+void syncMethodCallReturnConversionEnd(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallReturnConversionEnd(moduleName, methodName);
+  }
+}
+
+void syncMethodCallEnd(const char* moduleName, const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallEnd(moduleName, methodName);
+  }
+}
+
+void syncMethodCallFail(const char* moduleName, const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->syncMethodCallFail(moduleName, methodName);
+  }
+}
+
+void asyncMethodCallStart(const char* moduleName, const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallStart(moduleName, methodName);
+  }
+}
+
+void asyncMethodCallArgConversionStart(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallArgConversionStart(moduleName, methodName);
+  }
+}
+
+void asyncMethodCallArgConversionEnd(
+    const char* moduleName,
+    const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallArgConversionEnd(moduleName, methodName);
+  }
+}
+
+void asyncMethodCallDispatch(const char* moduleName, const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallDispatch(moduleName, methodName);
+  }
+}
+
+void asyncMethodCallEnd(const char* moduleName, const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallEnd(moduleName, methodName);
+  }
+}
+
+void asyncMethodCallFail(const char* moduleName, const char* methodName) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallFail(moduleName, methodName);
+  }
+}
+
+void asyncMethodCallBatchPreprocessStart() {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallBatchPreprocessStart();
+  }
+}
+
+void asyncMethodCallBatchPreprocessEnd(int batchSize) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallBatchPreprocessEnd(batchSize);
+  }
+}
+
+void asyncMethodCallExecutionStart(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallExecutionStart(moduleName, methodName, id);
+  }
+}
+
+void asyncMethodCallExecutionArgConversionStart(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallExecutionArgConversionStart(
+        moduleName, methodName, id);
+  }
+}
+
+void asyncMethodCallExecutionArgConversionEnd(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallExecutionArgConversionEnd(
+        moduleName, methodName, id);
+  }
+}
+
+void asyncMethodCallExecutionEnd(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallExecutionEnd(moduleName, methodName, id);
+  }
+}
+
+void asyncMethodCallExecutionFail(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id) {
+  NativeModulePerfLogger* logger = g_perfLogger.get();
+  if (logger != nullptr) {
+    logger->asyncMethodCallExecutionFail(moduleName, methodName, id);
+  }
+}
+
+} // namespace BridgeNativeModulePerfLogger
+} // namespace facebook::react

smart-app-city/frontend/node_modules/react-native/ReactCommon/reactperflogger/reactperflogger/BridgeNativeModulePerfLogger.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <memory>
+#include "NativeModulePerfLogger.h"
+
+namespace facebook::react {
+
+namespace BridgeNativeModulePerfLogger {
+void enableLogging(std::unique_ptr<NativeModulePerfLogger>&& logger);
+void disableLogging();
+
+void moduleDataCreateStart(const char* moduleName, int32_t id);
+void moduleDataCreateEnd(const char* moduleName, int32_t id);
+
+/**
+ * Create NativeModule platform object
+ */
+void moduleCreateStart(const char* moduleName, int32_t id);
+void moduleCreateCacheHit(const char* moduleName, int32_t id);
+void moduleCreateConstructStart(const char* moduleName, int32_t id);
+void moduleCreateConstructEnd(const char* moduleName, int32_t id);
+void moduleCreateSetUpStart(const char* moduleName, int32_t id);
+void moduleCreateSetUpEnd(const char* moduleName, int32_t id);
+void moduleCreateEnd(const char* moduleName, int32_t id);
+void moduleCreateFail(const char* moduleName, int32_t id);
+
+/**
+ * JS require beginning
+ */
+void moduleJSRequireBeginningStart(const char* moduleName);
+void moduleJSRequireBeginningCacheHit(const char* moduleName);
+void moduleJSRequireBeginningEnd(const char* moduleName);
+void moduleJSRequireBeginningFail(const char* moduleName);
+
+/**
+ * JS require ending
+ */
+void moduleJSRequireEndingStart(const char* moduleName);
+void moduleJSRequireEndingEnd(const char* moduleName);
+void moduleJSRequireEndingFail(const char* moduleName);
+
+// Sync method calls
+void syncMethodCallStart(const char* moduleName, const char* methodName);
+void syncMethodCallArgConversionStart(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallArgConversionEnd(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallExecutionStart(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallExecutionEnd(const char* moduleName, const char* methodName);
+void syncMethodCallReturnConversionStart(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallReturnConversionEnd(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallEnd(const char* moduleName, const char* methodName);
+void syncMethodCallFail(const char* moduleName, const char* methodName);
+
+// Async method calls
+void asyncMethodCallStart(const char* moduleName, const char* methodName);
+void asyncMethodCallArgConversionStart(
+    const char* moduleName,
+    const char* methodName);
+void asyncMethodCallArgConversionEnd(
+    const char* moduleName,
+    const char* methodName);
+void asyncMethodCallDispatch(const char* moduleName, const char* methodName);
+void asyncMethodCallEnd(const char* moduleName, const char* methodName);
+void asyncMethodCallFail(const char* moduleName, const char* methodName);
+
+/**
+ * Pre-processing async method call batch
+ */
+void asyncMethodCallBatchPreprocessStart();
+void asyncMethodCallBatchPreprocessEnd(int batchSize);
+
+// Async method call execution
+void asyncMethodCallExecutionStart(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionArgConversionStart(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionArgConversionEnd(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionEnd(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionFail(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+
+} // namespace BridgeNativeModulePerfLogger
+
+} // namespace facebook::react

smart-app-city/frontend/node_modules/react-native/ReactCommon/reactperflogger/reactperflogger/NativeModulePerfLogger.h

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+#include <cstdint>
+
+namespace facebook::react {
+
+/**
+ * A platform-agnostic interface to do performance logging on NativeModules and
+ * TuboModules.
+ */
+class NativeModulePerfLogger {
+ public:
+  virtual ~NativeModulePerfLogger() {}
+
+  /**
+   * NativeModule Initialization.
+   *
+   * The initialization of two NativeModules can interleave. Therefore,
+   * performance markers should use the moduleName as a unique key.
+   */
+
+  /**
+   * On iOS:
+   *   - NativeModule initialization is split into two phases, which sometimes
+   *     have a pause in the middle.
+   *   - TurboModule initialization happens all at once.
+   *
+   * On Android:
+   *   - NativeModule and TurboModule initialization happens all at once.
+   *
+   * These markers are meant for iOS NativeModules:
+   *  - moduleDataCreateStart: very beginning of first phase.
+   *  - moduleDataCreateEnd: after RCTModuleData has been created.
+   */
+  virtual void moduleDataCreateStart(const char* moduleName, int32_t id) = 0;
+  virtual void moduleDataCreateEnd(const char* moduleName, int32_t id) = 0;
+
+  /**
+   * How long does it take to create the platform NativeModule object?
+   *   - moduleCreateStart: start creating platform NativeModule
+   *   - moduleCreateEnd: stop creating platform NativeModule
+   */
+  virtual void moduleCreateStart(const char* moduleName, int32_t id) = 0;
+  virtual void moduleCreateCacheHit(const char* moduleName, int32_t id) = 0;
+  virtual void moduleCreateConstructStart(
+      const char* moduleName,
+      int32_t id) = 0;
+  virtual void moduleCreateConstructEnd(const char* moduleName, int32_t id) = 0;
+  virtual void moduleCreateSetUpStart(const char* moduleName, int32_t id) = 0;
+  virtual void moduleCreateSetUpEnd(const char* moduleName, int32_t id) = 0;
+  virtual void moduleCreateEnd(const char* moduleName, int32_t id) = 0;
+  virtual void moduleCreateFail(const char* moduleName, int32_t id) = 0;
+
+  /**
+   * How long, after starting JS require, does it take to start creating the
+   * platform NativeModule?
+   *   - moduleJSRequireBeginningStart: start of JS require
+   *   - moduleJSRequireBeginningEnd: start creating platform NativeModule
+   */
+  virtual void moduleJSRequireBeginningStart(const char* moduleName) = 0;
+  virtual void moduleJSRequireBeginningCacheHit(const char* moduleName) = 0;
+  virtual void moduleJSRequireBeginningEnd(const char* moduleName) = 0;
+  virtual void moduleJSRequireBeginningFail(const char* moduleName) = 0;
+
+  /**
+   * How long does it take to return from the JS require after the platform
+   * NativeModule is created?
+   *   - moduleJSRequireEndingStart: end creating platform NativeModule
+   *   - moduleJSRequireEndingEnd: end of JS require
+   */
+  virtual void moduleJSRequireEndingStart(const char* moduleName) = 0;
+  virtual void moduleJSRequireEndingEnd(const char* moduleName) = 0;
+  virtual void moduleJSRequireEndingFail(const char* moduleName) = 0;
+
+  // Sync method calls
+  virtual void syncMethodCallStart(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallArgConversionStart(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallArgConversionEnd(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallExecutionStart(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallExecutionEnd(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallReturnConversionStart(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallReturnConversionEnd(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallEnd(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void syncMethodCallFail(
+      const char* moduleName,
+      const char* methodName) = 0;
+
+  // Async method calls
+  virtual void asyncMethodCallStart(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void asyncMethodCallArgConversionStart(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void asyncMethodCallArgConversionEnd(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void asyncMethodCallDispatch(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void asyncMethodCallEnd(
+      const char* moduleName,
+      const char* methodName) = 0;
+  virtual void asyncMethodCallFail(
+      const char* moduleName,
+      const char* methodName) = 0;
+
+  /**
+   * In the NativeModule system, we batch async NativeModule method calls.
+   * When we execute a batch of NativeModule method calls, we convert the batch
+   * from a jsi::Value to folly::dynamic to std::vector<MethodCall>. This marker
+   * documents that work.
+   */
+  virtual void asyncMethodCallBatchPreprocessStart() = 0;
+  virtual void asyncMethodCallBatchPreprocessEnd(int batchSize) = 0;
+
+  // Async method call execution
+  virtual void asyncMethodCallExecutionStart(
+      const char* moduleName,
+      const char* methodName,
+      int32_t id) = 0;
+  virtual void asyncMethodCallExecutionArgConversionStart(
+      const char* moduleName,
+      const char* methodName,
+      int32_t id) = 0;
+  virtual void asyncMethodCallExecutionArgConversionEnd(
+      const char* moduleName,
+      const char* methodName,
+      int32_t id) = 0;
+  virtual void asyncMethodCallExecutionEnd(
+      const char* moduleName,
+      const char* methodName,
+      int32_t id) = 0;
+  virtual void asyncMethodCallExecutionFail(
+      const char* moduleName,
+      const char* methodName,
+      int32_t id) = 0;
+};
+
+} // namespace facebook::react