@react-native-firebase/crashlytics 25.0.1 → 26.0.0

package/ios/generated/RNFBCrashlyticsTurboModulesJSI.h

@@ -0,0 +1,320 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+  
+#pragma mark - NativeRNFBTurboCrashlyticsCrashlyticsStackFrame
+
+template <typename P0, typename P1, typename P2, typename P3, typename P4>
+struct NativeRNFBTurboCrashlyticsCrashlyticsStackFrame {
+  P0 src;
+  P1 line;
+  P2 col;
+  P3 fn;
+  P4 file;
+  bool operator==(const NativeRNFBTurboCrashlyticsCrashlyticsStackFrame &other) const {
+    return src == other.src && line == other.line && col == other.col && fn == other.fn && file == other.file;
+  }
+};
+
+template <typename T>
+struct NativeRNFBTurboCrashlyticsCrashlyticsStackFrameBridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+      bridging::fromJs<decltype(types.src)>(rt, value.getProperty(rt, "src"), jsInvoker),
+      bridging::fromJs<decltype(types.line)>(rt, value.getProperty(rt, "line"), jsInvoker),
+      bridging::fromJs<decltype(types.col)>(rt, value.getProperty(rt, "col"), jsInvoker),
+      bridging::fromJs<decltype(types.fn)>(rt, value.getProperty(rt, "fn"), jsInvoker),
+      bridging::fromJs<decltype(types.file)>(rt, value.getProperty(rt, "file"), jsInvoker)};
+    return result;
+  }
+
+#ifdef DEBUG
+  static jsi::String srcToJs(jsi::Runtime &rt, decltype(types.src) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static double lineToJs(jsi::Runtime &rt, decltype(types.line) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static double colToJs(jsi::Runtime &rt, decltype(types.col) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String fnToJs(jsi::Runtime &rt, decltype(types.fn) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::String fileToJs(jsi::Runtime &rt, decltype(types.file) value) {
+    return bridging::toJs(rt, value);
+  }
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+    result.setProperty(rt, "src", bridging::toJs(rt, value.src, jsInvoker));
+    result.setProperty(rt, "line", bridging::toJs(rt, value.line, jsInvoker));
+    result.setProperty(rt, "col", bridging::toJs(rt, value.col, jsInvoker));
+    result.setProperty(rt, "fn", bridging::toJs(rt, value.fn, jsInvoker));
+    result.setProperty(rt, "file", bridging::toJs(rt, value.file, jsInvoker));
+    return result;
+  }
+};
+
+
+
+#pragma mark - NativeRNFBTurboCrashlyticsJavaScriptErrorObject
+
+template <typename P0, typename P1, typename P2>
+struct NativeRNFBTurboCrashlyticsJavaScriptErrorObject {
+  P0 message;
+  P1 isUnhandledRejection;
+  P2 frames;
+  bool operator==(const NativeRNFBTurboCrashlyticsJavaScriptErrorObject &other) const {
+    return message == other.message && isUnhandledRejection == other.isUnhandledRejection && frames == other.frames;
+  }
+};
+
+template <typename T>
+struct NativeRNFBTurboCrashlyticsJavaScriptErrorObjectBridging {
+  static T types;
+
+  static T fromJs(
+      jsi::Runtime &rt,
+      const jsi::Object &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    T result{
+      bridging::fromJs<decltype(types.message)>(rt, value.getProperty(rt, "message"), jsInvoker),
+      bridging::fromJs<decltype(types.isUnhandledRejection)>(rt, value.getProperty(rt, "isUnhandledRejection"), jsInvoker),
+      bridging::fromJs<decltype(types.frames)>(rt, value.getProperty(rt, "frames"), jsInvoker)};
+    return result;
+  }
+
+#ifdef DEBUG
+  static jsi::String messageToJs(jsi::Runtime &rt, decltype(types.message) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static bool isUnhandledRejectionToJs(jsi::Runtime &rt, decltype(types.isUnhandledRejection) value) {
+    return bridging::toJs(rt, value);
+  }
+
+  static jsi::Array framesToJs(jsi::Runtime &rt, decltype(types.frames) value) {
+    return bridging::toJs(rt, value);
+  }
+#endif
+
+  static jsi::Object toJs(
+      jsi::Runtime &rt,
+      const T &value,
+      const std::shared_ptr<CallInvoker> &jsInvoker) {
+    auto result = facebook::jsi::Object(rt);
+    result.setProperty(rt, "message", bridging::toJs(rt, value.message, jsInvoker));
+    result.setProperty(rt, "isUnhandledRejection", bridging::toJs(rt, value.isUnhandledRejection, jsInvoker));
+    result.setProperty(rt, "frames", bridging::toJs(rt, value.frames, jsInvoker));
+    return result;
+  }
+};
+
+class JSI_EXPORT NativeRNFBTurboCrashlyticsCxxSpecJSI : public TurboModule {
+protected:
+  NativeRNFBTurboCrashlyticsCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual jsi::Object getConstants(jsi::Runtime &rt) = 0;
+  virtual jsi::Value checkForUnsentReports(jsi::Runtime &rt) = 0;
+  virtual void crash(jsi::Runtime &rt) = 0;
+  virtual jsi::Value crashWithStackPromise(jsi::Runtime &rt, jsi::Object jsErrorDict) = 0;
+  virtual jsi::Value deleteUnsentReports(jsi::Runtime &rt) = 0;
+  virtual jsi::Value didCrashOnPreviousExecution(jsi::Runtime &rt) = 0;
+  virtual void log(jsi::Runtime &rt, jsi::String message) = 0;
+  virtual jsi::Value logPromise(jsi::Runtime &rt, jsi::String message) = 0;
+  virtual void sendUnsentReports(jsi::Runtime &rt) = 0;
+  virtual jsi::Value setAttribute(jsi::Runtime &rt, jsi::String key, jsi::String value) = 0;
+  virtual jsi::Value setAttributes(jsi::Runtime &rt, jsi::Object attributes) = 0;
+  virtual jsi::Value setUserId(jsi::Runtime &rt, jsi::String userId) = 0;
+  virtual void recordError(jsi::Runtime &rt, jsi::Object jsErrorDict) = 0;
+  virtual jsi::Value recordErrorPromise(jsi::Runtime &rt, jsi::Object jsErrorDict) = 0;
+  virtual jsi::Value setCrashlyticsCollectionEnabled(jsi::Runtime &rt, bool enabled) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativeRNFBTurboCrashlyticsCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "NativeRNFBTurboCrashlytics";
+
+protected:
+  NativeRNFBTurboCrashlyticsCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativeRNFBTurboCrashlyticsCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+
+private:
+  class Delegate : public NativeRNFBTurboCrashlyticsCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativeRNFBTurboCrashlyticsCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+
+    }
+
+    jsi::Object getConstants(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::getConstants) == 1,
+          "Expected getConstants(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Object>(
+          rt, &T::getConstants, jsInvoker_, instance_);
+    }
+    jsi::Value checkForUnsentReports(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::checkForUnsentReports) == 1,
+          "Expected checkForUnsentReports(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::checkForUnsentReports, jsInvoker_, instance_);
+    }
+    void crash(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::crash) == 1,
+          "Expected crash(...) to have 1 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::crash, jsInvoker_, instance_);
+    }
+    jsi::Value crashWithStackPromise(jsi::Runtime &rt, jsi::Object jsErrorDict) override {
+      static_assert(
+          bridging::getParameterCount(&T::crashWithStackPromise) == 2,
+          "Expected crashWithStackPromise(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::crashWithStackPromise, jsInvoker_, instance_, std::move(jsErrorDict));
+    }
+    jsi::Value deleteUnsentReports(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::deleteUnsentReports) == 1,
+          "Expected deleteUnsentReports(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::deleteUnsentReports, jsInvoker_, instance_);
+    }
+    jsi::Value didCrashOnPreviousExecution(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::didCrashOnPreviousExecution) == 1,
+          "Expected didCrashOnPreviousExecution(...) to have 1 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::didCrashOnPreviousExecution, jsInvoker_, instance_);
+    }
+    void log(jsi::Runtime &rt, jsi::String message) override {
+      static_assert(
+          bridging::getParameterCount(&T::log) == 2,
+          "Expected log(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::log, jsInvoker_, instance_, std::move(message));
+    }
+    jsi::Value logPromise(jsi::Runtime &rt, jsi::String message) override {
+      static_assert(
+          bridging::getParameterCount(&T::logPromise) == 2,
+          "Expected logPromise(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::logPromise, jsInvoker_, instance_, std::move(message));
+    }
+    void sendUnsentReports(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::sendUnsentReports) == 1,
+          "Expected sendUnsentReports(...) to have 1 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::sendUnsentReports, jsInvoker_, instance_);
+    }
+    jsi::Value setAttribute(jsi::Runtime &rt, jsi::String key, jsi::String value) override {
+      static_assert(
+          bridging::getParameterCount(&T::setAttribute) == 3,
+          "Expected setAttribute(...) to have 3 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::setAttribute, jsInvoker_, instance_, std::move(key), std::move(value));
+    }
+    jsi::Value setAttributes(jsi::Runtime &rt, jsi::Object attributes) override {
+      static_assert(
+          bridging::getParameterCount(&T::setAttributes) == 2,
+          "Expected setAttributes(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::setAttributes, jsInvoker_, instance_, std::move(attributes));
+    }
+    jsi::Value setUserId(jsi::Runtime &rt, jsi::String userId) override {
+      static_assert(
+          bridging::getParameterCount(&T::setUserId) == 2,
+          "Expected setUserId(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::setUserId, jsInvoker_, instance_, std::move(userId));
+    }
+    void recordError(jsi::Runtime &rt, jsi::Object jsErrorDict) override {
+      static_assert(
+          bridging::getParameterCount(&T::recordError) == 2,
+          "Expected recordError(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::recordError, jsInvoker_, instance_, std::move(jsErrorDict));
+    }
+    jsi::Value recordErrorPromise(jsi::Runtime &rt, jsi::Object jsErrorDict) override {
+      static_assert(
+          bridging::getParameterCount(&T::recordErrorPromise) == 2,
+          "Expected recordErrorPromise(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::recordErrorPromise, jsInvoker_, instance_, std::move(jsErrorDict));
+    }
+    jsi::Value setCrashlyticsCollectionEnabled(jsi::Runtime &rt, bool enabled) override {
+      static_assert(
+          bridging::getParameterCount(&T::setCrashlyticsCollectionEnabled) == 2,
+          "Expected setCrashlyticsCollectionEnabled(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::setCrashlyticsCollectionEnabled, jsInvoker_, instance_, std::move(enabled));
+    }
+
+  private:
+    friend class NativeRNFBTurboCrashlyticsCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+} // namespace facebook::react

package/ios/generated/ReactAppDependencyProvider.podspec

@@ -0,0 +1,34 @@
+# 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.
+
+version = "0.78.3"
+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
+
+Pod::Spec.new do |s|
+  s.name                   = "ReactAppDependencyProvider"
+  s.version                = version
+  s.summary                = "The third party dependency provider for the app"
+  s.homepage               = "https://reactnative.dev/"
+  s.documentation_url      = "https://reactnative.dev/"
+  s.license                = "MIT"
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = "**/RCTAppDependencyProvider.{h,mm}"
+
+  # This guard prevent to install the dependencies when we run `pod install` in the old architecture.
+  s.pod_target_xcconfig    = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+    "DEFINES_MODULE" => "YES"
+  }
+
+  s.dependency "ReactCodegen"
+end

package/lib/handlers.ts

@@ -15,7 +15,7 @@
  *
  */
 
-import { firebase } from '.';
+import { getApp } from '@react-native-firebase/app';
 import { isError, once } from '@react-native-firebase/app/dist/module/common';
 // @ts-ignore - No declaration file for promise/setimmediate/rejection-tracking
 import tracking from 'promise/setimmediate/rejection-tracking';
@@ -125,35 +125,16 @@ export const setGlobalErrorHandler = once((nativeModule: NativeModule) => {
         // Flag the Crashlytics backend that we have a fatal error, they will transform it
         await nativeModule.setAttribute(FATAL_FLAG, fatalTime);
 
-        // remember our current deprecation warning state in case users
-        // have set it to non-default
-        const currentDeprecationWarningToggle =
-          globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS;
-
-        // Notify analytics, if it exists - throws error if not
         try {
-          // FIXME - disable warnings and use the old namespaced style,
-          // See https://github.com/invertase/react-native-firebase/issues/8381
-          // Unfortunately, this fails completely when using modular!
-          // Did not matter if I did named imports above or dynamic require here.
-          // So temporarily reverting and silencing warnings instead
-          globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = true;
-          // @ts-ignore - analytics types not available in crashlytics
-          await firebase.app().analytics().logEvent(
-            'app_exception', // 'app_exception' is reserved but we make an exception for JS->fatal transforms
-            {
-              fatal: 1, // as in firebase-android-sdk
-              timestamp: fatalTime,
-            },
-          );
+          const { getAnalytics, logEvent } = require('@react-native-firebase/analytics');
+          await logEvent(getAnalytics(getApp()), 'app_exception', {
+            fatal: 1,
+            timestamp: fatalTime,
+          });
         } catch (_) {
-          // This just means analytics was not present, so we could not log the analytics event
-          // console.log('error logging analytics app_exception: ' + e);
-        } finally {
-          globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = currentDeprecationWarningToggle;
+          // analytics not present
         }
 
-        // If we are chaining to other handlers, just record the error, otherwise we need to crash with it
         if (nativeModule.isCrashlyticsJavascriptExceptionHandlerChainingEnabled) {
           await nativeModule.recordErrorPromise(createNativeErrorObj(error, stackFrames, false));
         } else {

package/lib/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
  *
@@ -15,12 +16,213 @@
  *
  */
 
-// Export types from types/crashlytics
-export type { Crashlytics, FirebaseCrashlyticsTypes } from './types/crashlytics';
+import type { FirebaseApp } from '@react-native-firebase/app';
+import {
+  isBoolean,
+  isError,
+  isObject,
+  isString,
+} from '@react-native-firebase/app/dist/module/common';
+import {
+  FirebaseModule,
+  getOrCreateModularInstance,
+} from '@react-native-firebase/app/dist/module/internal';
+import type { ModuleConfig } from '@react-native-firebase/app/dist/module/internal';
+import './types/internal';
+import StackTrace from 'stacktrace-js';
+import {
+  createNativeErrorObj,
+  setGlobalErrorHandler,
+  setOnUnhandledPromiseRejectionHandler,
+} from './handlers';
+import { version } from './version';
+import type { Crashlytics } from './types/crashlytics';
+import type { CrashlyticsInternal } from './types/internal';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
 
-// Export modular API functions
-export * from './modular';
+const nativeModuleName = 'NativeRNFBTurboCrashlytics';
 
-// Export namespaced API
-export * from './namespaced';
-export { default } from './namespaced';
+class FirebaseCrashlyticsModule extends FirebaseModule {
+  _isCrashlyticsCollectionEnabled: boolean;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    customUrlOrRegion?: string | null,
+  ) {
+    super(app, config, customUrlOrRegion);
+    setGlobalErrorHandler(this.native);
+    setOnUnhandledPromiseRejectionHandler(this.native);
+    this._isCrashlyticsCollectionEnabled = this.native.isCrashlyticsCollectionEnabled;
+  }
+
+  get isCrashlyticsCollectionEnabled(): boolean {
+    // Purposefully did not deprecate this as I think it should remain a property rather than a method.
+    return this._isCrashlyticsCollectionEnabled;
+  }
+
+  checkForUnsentReports(): Promise<boolean> {
+    if (this.isCrashlyticsCollectionEnabled) {
+      throw new Error(
+        "firebase.crashlytics().setCrashlyticsCollectionEnabled(*) has been set to 'true', all reports are automatically sent.",
+      );
+    }
+    return this.native.checkForUnsentReports();
+  }
+
+  crash(): void {
+    this.native.crash();
+  }
+
+  async deleteUnsentReports(): Promise<void> {
+    await this.native.deleteUnsentReports();
+  }
+
+  didCrashOnPreviousExecution(): Promise<boolean> {
+    return this.native.didCrashOnPreviousExecution();
+  }
+
+  log(message: string): void {
+    this.native.log(`${message}`);
+  }
+
+  setAttribute(name: string, value: string): Promise<null> {
+    if (!isString(name)) {
+      throw new Error(
+        'firebase.crashlytics().setAttribute(*, _): The supplied property name must be a string.',
+      );
+    }
+
+    if (!isString(value)) {
+      throw new Error(
+        'firebase.crashlytics().setAttribute(_, *): The supplied property value must be a string value.',
+      );
+    }
+
+    return this.native.setAttribute(name, value);
+  }
+
+  setAttributes(object: { [key: string]: string }): Promise<null> {
+    if (!isObject(object)) {
+      throw new Error(
+        'firebase.crashlytics().setAttributes(*): The supplied arg must be an object of key value strings.',
+      );
+    }
+
+    return this.native.setAttributes(object);
+  }
+
+  setUserId(userId: string): Promise<null> {
+    if (!isString(userId)) {
+      throw new Error(
+        'firebase.crashlytics().setUserId(*): The supplied userId must be a string value.',
+      );
+    }
+
+    return this.native.setUserId(userId);
+  }
+
+  recordError(error: Error, jsErrorName?: string): void {
+    if (isError(error)) {
+      StackTrace.fromError(error, { offline: true })
+        .then(stackFrames =>
+          this.native.recordErrorPromise(
+            createNativeErrorObj(error, stackFrames, false, jsErrorName),
+          ),
+        )
+        .catch(() => {});
+    } else {
+      console.warn(
+        'firebase.crashlytics().recordError(*) expects an instance of Error. Non Errors will be ignored.',
+      );
+    }
+  }
+
+  sendUnsentReports(): void {
+    if (this.isCrashlyticsCollectionEnabled) {
+      this.native.sendUnsentReports();
+    }
+  }
+
+  setCrashlyticsCollectionEnabled(enabled: boolean): Promise<null> {
+    if (!isBoolean(enabled)) {
+      throw new Error(
+        "firebase.crashlytics().setCrashlyticsCollectionEnabled(*) 'enabled' must be a boolean.",
+      );
+    }
+
+    this._isCrashlyticsCollectionEnabled = enabled;
+    return this.native.setCrashlyticsCollectionEnabled(enabled);
+  }
+}
+
+const config: ModuleConfig = {
+  namespace: 'crashlytics',
+  nativeModuleName,
+  nativeEvents: false,
+  hasMultiAppSupport: false,
+  hasCustomUrlOrRegionSupport: false,
+  turboModule: true,
+};
+
+export const SDK_VERSION = version;
+
+export function getCrashlytics(app?: FirebaseApp): Crashlytics {
+  return getOrCreateModularInstance(
+    FirebaseCrashlyticsModule,
+    config,
+    app,
+  ) as unknown as Crashlytics;
+}
+
+export function checkForUnsentReports(crashlytics: Crashlytics): Promise<boolean> {
+  return (crashlytics as CrashlyticsInternal).checkForUnsentReports();
+}
+
+export function deleteUnsentReports(crashlytics: Crashlytics): Promise<void> {
+  return (crashlytics as CrashlyticsInternal).deleteUnsentReports();
+}
+
+export function didCrashOnPreviousExecution(crashlytics: Crashlytics): Promise<boolean> {
+  return (crashlytics as CrashlyticsInternal).didCrashOnPreviousExecution();
+}
+
+export function crash(crashlytics: Crashlytics): void {
+  return (crashlytics as CrashlyticsInternal).crash();
+}
+
+export function log(crashlytics: Crashlytics, message: string): void {
+  return (crashlytics as CrashlyticsInternal).log(message);
+}
+
+export function recordError(crashlytics: Crashlytics, error: Error, jsErrorName?: string): void {
+  return (crashlytics as CrashlyticsInternal).recordError(error, jsErrorName);
+}
+
+export function sendUnsentReports(crashlytics: Crashlytics): void {
+  return (crashlytics as CrashlyticsInternal).sendUnsentReports();
+}
+
+export function setUserId(crashlytics: Crashlytics, userId: string): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setUserId(userId);
+}
+
+export function setAttribute(crashlytics: Crashlytics, name: string, value: string): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setAttribute(name, value);
+}
+
+export function setAttributes(
+  crashlytics: Crashlytics,
+  attributes: { [key: string]: string },
+): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setAttributes(attributes);
+}
+
+export function setCrashlyticsCollectionEnabled(
+  crashlytics: Crashlytics,
+  enabled: boolean,
+): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setCrashlyticsCollectionEnabled(enabled);
+}
+
+export type { Crashlytics } from './types/crashlytics';

package/lib/types/crashlytics.ts

@@ -125,35 +125,5 @@ export interface Statics {
 /**
  * FirebaseApp type with crashlytics() method.
  * @deprecated Import FirebaseApp from '@react-native-firebase/app' instead.
- * The crashlytics() method is added via module augmentation.
  */
 export type FirebaseApp = ReactNativeFirebase.FirebaseApp;
-
-// ============ Module Augmentation ============
-
-/* eslint-disable @typescript-eslint/no-namespace */
-declare module '@react-native-firebase/app' {
-  namespace ReactNativeFirebase {
-    interface Module {
-      crashlytics: FirebaseModuleWithStaticsAndApp<Crashlytics, Statics>;
-    }
-    interface FirebaseApp {
-      crashlytics(): Crashlytics;
-    }
-  }
-}
-/* eslint-enable @typescript-eslint/no-namespace */
-// ============ Backwards Compatibility Namespace - to be removed with namespaced exports ============
-type _Statics = Statics;
-
-/**
- * @deprecated Use the exported types directly instead.
- * FirebaseCrashlyticsTypes namespace is kept for backwards compatibility.
- */
-/* eslint-disable @typescript-eslint/no-namespace */
-export namespace FirebaseCrashlyticsTypes {
-  // Short name aliases referencing top-level types
-  export type Module = Crashlytics;
-  export type Statics = _Statics;
-}
-/* eslint-enable @typescript-eslint/no-namespace */