@react-native-firebase/app 25.1.0 → 26.0.0

package/lib/internal/registry/nativeModule.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  */
-import { APP_NATIVE_MODULE } from '../constants';
+import { APP_NATIVE_MODULE, UTILS_NATIVE_MODULE } from '../constants';
 import NativeFirebaseError from '../NativeFirebaseError';
 import type { NativeError } from '../../types/internal';
 import RNFBNativeEventEmitter from '../RNFBNativeEventEmitter';
@@ -31,8 +31,15 @@ interface NativeEvent {
   [key: string]: unknown;
 }
 
+interface RouteEntry {
+  host: Record<string, unknown>;
+  key: string;
+  argToPrepend: unknown[];
+}
+
 const NATIVE_MODULE_REGISTRY: Record<string, WrappedNativeModule> = {};
 const NATIVE_MODULE_EVENT_SUBSCRIPTIONS: Record<string, boolean> = {};
+let staticUtilsModule: WrappedNativeModule | null = null;
 
 function nativeModuleKey(module: FirebaseModule): string {
   return `${module._customUrlOrRegion || ''}:${module.app.name}:${module._config.namespace}`;
@@ -41,11 +48,6 @@ function nativeModuleKey(module: FirebaseModule): string {
 /**
  * Wraps a native module method to provide
  * auto prepended args and custom Error classes.
- *
- * @param namespace
- * @param method
- * @param argToPrepend
- * @returns {Function}
  */
 function nativeModuleMethodWrapped(
   namespace: string,
@@ -54,9 +56,7 @@ function nativeModuleMethodWrapped(
   isTurboModule: boolean,
 ): (...args: unknown[]) => unknown {
   return (...args: unknown[]) => {
-    // For iOS TurboModules, encode null values in arguments to work around
-    // the limitation where null values in object properties get stripped during serialization
-    // See: https://github.com/facebook/react-native/issues/52802
+    // Per-call encodeNullValues walk is intentional: args may differ on every invocation.
     const processedArgs = isIOS && isTurboModule ? args.map(arg => encodeNullValues(arg)) : args;
     const allArgs = [...argToPrepend, ...processedArgs];
     const possiblePromise = method(...allArgs);
@@ -73,50 +73,107 @@ function nativeModuleMethodWrapped(
 }
 
 /**
- * Prepends all arguments in prependArgs to all native method calls
- *
- * @param namespace
- * @param NativeModule - Raw native module from React Native
- * @param argToPrepend
+ * NewArch-AD-14 / NewArch-AD-14a: routing composite Proxy — lazy wrap+bind on first access per method.
  */
-function nativeModuleWrapped(
+function createRoutingCompositeProxy(
   namespace: string,
-  NativeModule: Record<string, unknown> | undefined,
-  argToPrepend: unknown[],
+  hosts: Array<{ module: Record<string, unknown> | undefined; argToPrepend: unknown[] }>,
   isTurboModule: boolean,
 ): WrappedNativeModule {
-  const native: Record<string, unknown> = {};
-  if (!NativeModule) {
-    return NativeModule as unknown as WrappedNativeModule;
-  }
+  const routingMap: Record<string, RouteEntry> = {};
+  const memoizedMethods: Record<string, (...args: unknown[]) => unknown> = {};
+  const memoizedConstants: Record<string, unknown> = {};
 
-  const nativeModuleObj = NativeModule;
-  let properties = Object.keys(Object.getPrototypeOf(nativeModuleObj));
-  if (!properties.length) properties = Object.keys(nativeModuleObj);
-
-  for (let i = 0, len = properties.length; i < len; i++) {
-    const property = properties[i];
-    if (!property) continue;
-    if (typeof nativeModuleObj[property] === 'function') {
-      native[property] = nativeModuleMethodWrapped(
-        namespace,
-        nativeModuleObj[property] as (...args: unknown[]) => unknown,
-        argToPrepend,
-        isTurboModule,
-      );
-    } else {
-      native[property] = nativeModuleObj[property];
+  for (const { module, argToPrepend } of hosts) {
+    if (!module) {
+      continue;
+    }
+    for (const key in module) {
+      if (key === 'constructor' || key === 'getConstants') {
+        continue;
+      }
+      routingMap[key] = { host: module, key, argToPrepend };
     }
   }
 
-  return native;
+  const target = Object.create(null) as WrappedNativeModule;
+
+  return new Proxy(target, {
+    get(_target, name: string | symbol) {
+      if (typeof name !== 'string' || !(name in routingMap)) {
+        return undefined;
+      }
+
+      const route = routingMap[name];
+      if (!route) {
+        return undefined;
+      }
+
+      const value = route.host[route.key];
+
+      if (typeof value !== 'function') {
+        if (!(name in memoizedConstants)) {
+          memoizedConstants[name] = value;
+        }
+        return memoizedConstants[name];
+      }
+
+      if (!memoizedMethods[name]) {
+        memoizedMethods[name] = nativeModuleMethodWrapped(
+          namespace,
+          (value as (...args: unknown[]) => unknown).bind(route.host),
+          route.argToPrepend,
+          isTurboModule,
+        ) as (...args: unknown[]) => unknown;
+      }
+
+      return memoizedMethods[name];
+    },
+    has(_target, name) {
+      return typeof name === 'string' && name in routingMap;
+    },
+    ownKeys() {
+      return Object.keys(routingMap);
+    },
+    getOwnPropertyDescriptor(_target, name) {
+      if (typeof name !== 'string' || !(name in routingMap)) {
+        return undefined;
+      }
+      return {
+        enumerable: true,
+        configurable: true,
+      };
+    },
+    set() {
+      return false;
+    },
+  });
+}
+
+/**
+ * NewArch-AD-14a N=1: single-host routing composite (TurboModule by default).
+ */
+function createSingleHostComposite(
+  namespace: string,
+  moduleName: string,
+  argToPrepend: unknown[] = [],
+  isTurboModule = true,
+): WrappedNativeModule {
+  const nativeModule = getReactNativeModule(moduleName);
+
+  if (!nativeModule) {
+    throw new Error(getMissingModuleHelpText(namespace));
+  }
+
+  return createRoutingCompositeProxy(
+    namespace,
+    [{ module: nativeModule, argToPrepend }],
+    isTurboModule,
+  );
 }
 
 /**
  * Initialises and wraps all the native module methods.
- *
- * @param module
- * @returns {*}
  */
 function initialiseNativeModule(module: FirebaseModule): WrappedNativeModule {
   const config = module._config;
@@ -130,41 +187,45 @@ function initialiseNativeModule(module: FirebaseModule): WrappedNativeModule {
     disablePrependCustomUrlOrRegion,
     turboModule,
   } = config;
-  const multiModuleRoot: WrappedNativeModule = {};
   const isTurboModule = !!turboModule;
   const multiModule = Array.isArray(nativeModuleName);
   const nativeModuleNames = multiModule ? nativeModuleName : [nativeModuleName];
 
-  for (let i = 0; i < nativeModuleNames.length; i++) {
-    const moduleName = nativeModuleNames[i];
-    if (!moduleName) continue;
+  const argToPrepend: Array<string> = [];
+
+  if (hasMultiAppSupport) {
+    argToPrepend.push(module.app.name);
+  }
+
+  if (hasCustomUrlOrRegionSupport && !disablePrependCustomUrlOrRegion) {
+    argToPrepend.push(module._customUrlOrRegion as string);
+  }
 
-    const nativeModule = getReactNativeModule(moduleName);
+  let composite: WrappedNativeModule;
 
-    // only error if there's a single native module
-    // as multi modules can mean some are optional
-    if (!multiModule && !nativeModule) {
+  if (!multiModule) {
+    const moduleName = nativeModuleNames[0];
+    if (!moduleName) {
       throw new Error(getMissingModuleHelpText(namespace));
     }
 
-    if (multiModule) {
-      multiModuleRoot[moduleName] = !!nativeModule;
-    }
+    composite = createSingleHostComposite(namespace, moduleName, argToPrepend, isTurboModule);
+  } else {
+    const hosts: Array<{ module: Record<string, unknown> | undefined; argToPrepend: unknown[] }> =
+      [];
 
-    const argToPrepend: Array<string> = [];
+    for (let i = 0; i < nativeModuleNames.length; i++) {
+      const moduleName = nativeModuleNames[i];
+      if (!moduleName) continue;
 
-    if (hasMultiAppSupport) {
-      argToPrepend.push(module.app.name);
-    }
+      const nativeModule = getReactNativeModule(moduleName);
 
-    if (hasCustomUrlOrRegionSupport && !disablePrependCustomUrlOrRegion) {
-      argToPrepend.push(module._customUrlOrRegion as string);
+      if (nativeModule) {
+        hosts.push({ module: nativeModule, argToPrepend });
+      }
     }
 
-    Object.assign(
-      multiModuleRoot,
-      nativeModuleWrapped(namespace, nativeModule, argToPrepend, isTurboModule),
-    );
+    composite = createRoutingCompositeProxy(namespace, hosts, isTurboModule);
   }
 
   if (nativeEvents && Array.isArray(nativeEvents) && nativeEvents.length) {
@@ -176,34 +237,20 @@ function initialiseNativeModule(module: FirebaseModule): WrappedNativeModule {
     }
   }
 
-  Object.freeze(multiModuleRoot);
-
-  NATIVE_MODULE_REGISTRY[key] = multiModuleRoot;
+  NATIVE_MODULE_REGISTRY[key] = composite;
 
   return NATIVE_MODULE_REGISTRY[key];
 }
 
-/**
- * Subscribe to a native event for js side distribution by appName
- *    React Native events are hard set at compile - cant do dynamic event names
- *    so we use a single event send it to js and js then internally can prefix it
- *    and distribute dynamically.
- *
- * @param eventName
- * @private
- */
 function subscribeToNativeModuleEvent(eventName: string): void {
   if (!NATIVE_MODULE_EVENT_SUBSCRIPTIONS[eventName]) {
     RNFBNativeEventEmitter.addListener(eventName, (...args: unknown[]) => {
       const event = args[0] as NativeEvent;
       if (event.appName && event.databaseId) {
-        // Firestore requires both appName and databaseId to prefix
         SharedEventEmitter.emit(`${event.appName}-${event.databaseId}-${eventName}`, event);
       } else if (event.appName) {
-        // native event has an appName property - auto prefix and internally emit
         SharedEventEmitter.emit(`${event.appName}-${eventName}`, event);
       } else {
-        // standard event - no need to prefix
         SharedEventEmitter.emit(eventName, event);
       }
     });
@@ -212,12 +259,6 @@ function subscribeToNativeModuleEvent(eventName: string): void {
   }
 }
 
-/**
- * Help text for integrating the native counter parts for each firebase module.
- *
- * @param namespace
- * @returns {string}
- */
 function getMissingModuleHelpText(namespace: string): string {
   const snippet = `firebase.${namespace}()`;
 
@@ -236,13 +277,6 @@ function getMissingModuleHelpText(namespace: string): string {
   );
 }
 
-/**
- * Gets a wrapped native module instance for the provided firebase module.
- * Will attempt to create a new instance if non previously created.
- *
- * @param module
- * @returns {*}
- */
 export function getNativeModule(module: FirebaseModule): WrappedNativeModule {
   const key = nativeModuleKey(module);
 
@@ -253,30 +287,25 @@ export function getNativeModule(module: FirebaseModule): WrappedNativeModule {
   return initialiseNativeModule(module);
 }
 
-/**
- * Custom wrapped app module as it does not have it's own FirebaseModule based class.
- *
- * @returns {*}
- */
 export function getAppModule(): RNFBAppModuleInterface {
   if (NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE]) {
     return NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] as unknown as RNFBAppModuleInterface;
   }
 
-  const namespace = 'app';
-  const nativeModule = getReactNativeModule(APP_NATIVE_MODULE);
+  NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] = createSingleHostComposite('app', APP_NATIVE_MODULE);
 
-  if (!nativeModule) {
-    throw new Error(getMissingModuleHelpText(namespace));
+  return NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] as unknown as RNFBAppModuleInterface;
+}
+
+/**
+ * Memoized wrapped utils surface for static path-constant reads (NewArch-AD-18 E5).
+ */
+export function getStaticUtilsModule(): WrappedNativeModule {
+  if (staticUtilsModule) {
+    return staticUtilsModule;
   }
 
-  NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] = nativeModuleWrapped(
-    namespace,
-    nativeModule,
-    [],
-    // TODO: change to true when we use TurboModules for app package
-    false,
-  );
+  staticUtilsModule = createSingleHostComposite('utils', UTILS_NATIVE_MODULE);
 
-  return NATIVE_MODULE_REGISTRY[APP_NATIVE_MODULE] as unknown as RNFBAppModuleInterface;
+  return staticUtilsModule;
 }

package/lib/modular.ts

@@ -15,8 +15,9 @@
  *
  */
 
-import { MODULAR_DEPRECATION_ARG } from './common';
-import type { ReactNativeFirebase, LogCallback, LogOptions } from './types/app';
+import type { ReactNativeFirebase, LogCallback, LogOptions, Utils } from './types/app';
+import { getUtils as getUtilsImpl } from './utils';
+import UtilsStatics from './utils/UtilsStatics';
 import {
   deleteApp as deleteAppCompat,
   getApp as getAppCompat,
@@ -27,36 +28,27 @@ import {
 } from './internal/registry/app';
 import { setUserLogHandler } from './internal/logger';
 import { version as sdkVersion } from './version';
-import { getReactNativeModule } from './internal/nativeModule';
-import { APP_NATIVE_MODULE } from './internal/constants';
-import type { RNFBAppModuleInterface } from './internal/NativeModules';
+import { getAppModule } from './internal/registry/nativeModule';
 /**
  * Renders this app unusable and frees the resources of all associated services.
  * @param app - The app to delete.
  * @returns Promise<void>
  */
 export function deleteApp(app: ReactNativeFirebase.FirebaseApp): Promise<void> {
-  return deleteAppCompat.call(
-    null,
-    app.name,
-    (app as any)._nativeInitialized,
-    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
-    MODULAR_DEPRECATION_ARG,
-  );
+  return deleteAppCompat(app.name, (app as any)._nativeInitialized);
 }
 
 /**
  * Registers a library's name and version for platform logging purposes.
- * @param _libraryKeyOrName - library name or key.
- * @param _version - library version.
- * @param _variant - library variant. Optional.
- * @returns Promise<void>
+ *
+ * @remarks **Web only.** Always throws on React Native Firebase — native SDK version registration
+ * is handled by the Firebase iOS/Android SDKs.
  */
 export function registerVersion(
   _libraryKeyOrName: string,
   _version: string,
   _variant?: string,
-): Promise<void> {
+): void {
   throw new Error('registerVersion is only supported on Web');
 }
 
@@ -75,15 +67,16 @@ export function onLog(logCallback: LogCallback | null, options?: LogOptions): vo
  * @returns An array of all initialized Firebase apps.
  */
 export function getApps(): ReactNativeFirebase.FirebaseApp[] {
-  return getAppsCompat.call(
-    null,
-    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
-    MODULAR_DEPRECATION_ARG,
-  );
+  return getAppsCompat();
 }
 
 /**
  * Initializes a Firebase app with the provided options and name.
+ *
+ * @remarks On React Native Firebase this is **async** (`Promise<FirebaseApp>`) because secondary
+ * app creation crosses the native bridge. The default app is still configured from native
+ * `GoogleService-Info.plist` / `google-services.json` at launch.
+ *
  * @param options - Options to configure the services used in the app.
  * @param configOrName - The optional name of the app, or config for the app to initialize (a name of '[DEFAULT]' will be used if omitted).
  * @returns The initialized Firebase app.
@@ -92,13 +85,7 @@ export function initializeApp(
   options: ReactNativeFirebase.FirebaseAppOptions,
   configOrName?: string | ReactNativeFirebase.FirebaseAppConfig,
 ): Promise<ReactNativeFirebase.FirebaseApp> {
-  return initializeAppCompat.call(
-    null,
-    options,
-    configOrName,
-    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
-    MODULAR_DEPRECATION_ARG,
-  );
+  return initializeAppCompat(options, configOrName);
 }
 
 /**
@@ -107,12 +94,7 @@ export function initializeApp(
  * @returns The requested Firebase app instance.
  */
 export function getApp(name?: string): ReactNativeFirebase.FirebaseApp {
-  return getAppCompat.call(
-    null,
-    name,
-    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
-    MODULAR_DEPRECATION_ARG,
-  );
+  return getAppCompat(name);
 }
 
 /**
@@ -121,12 +103,7 @@ export function getApp(name?: string): ReactNativeFirebase.FirebaseApp {
  * @returns void
  */
 export function setLogLevel(logLevel: ReactNativeFirebase.LogLevelString): void {
-  return setLogLevelCompat.call(
-    null,
-    logLevel,
-    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
-    MODULAR_DEPRECATION_ARG,
-  );
+  return setLogLevelCompat(logLevel);
 }
 
 /**
@@ -138,12 +115,7 @@ export function setLogLevel(logLevel: ReactNativeFirebase.LogLevelString): void
 export function setReactNativeAsyncStorage(
   asyncStorage: ReactNativeFirebase.ReactNativeAsyncStorage,
 ): void {
-  return setReactNativeAsyncStorageCompat.call(
-    null,
-    asyncStorage,
-    // @ts-expect-error - Extra arg used by deprecation proxy to detect modular calls
-    MODULAR_DEPRECATION_ARG,
-  );
+  return setReactNativeAsyncStorageCompat(asyncStorage);
 }
 
 /**
@@ -151,10 +123,7 @@ export function setReactNativeAsyncStorage(
  * @returns map of key / value pairs containing native meta data
  */
 export function metaGetAll(): Promise<{ [key: string]: string | boolean }> {
-  const RNFBAppModule = getReactNativeModule(
-    APP_NATIVE_MODULE,
-  ) as unknown as RNFBAppModuleInterface;
-  return RNFBAppModule.metaGetAll();
+  return getAppModule().metaGetAll();
 }
 
 /**
@@ -162,10 +131,7 @@ export function metaGetAll(): Promise<{ [key: string]: string | boolean }> {
  * @returns map of key / value pairs containing native firebase.json constants
  */
 export function jsonGetAll(): Promise<{ [key: string]: string | boolean }> {
-  const RNFBAppModule = getReactNativeModule(
-    APP_NATIVE_MODULE,
-  ) as unknown as RNFBAppModuleInterface;
-  return RNFBAppModule.jsonGetAll();
+  return getAppModule().jsonGetAll();
 }
 
 /**
@@ -173,10 +139,7 @@ export function jsonGetAll(): Promise<{ [key: string]: string | boolean }> {
  * @returns Promise<void>
  */
 export function preferencesClearAll(): Promise<void> {
-  const RNFBAppModule = getReactNativeModule(
-    APP_NATIVE_MODULE,
-  ) as unknown as RNFBAppModuleInterface;
-  return RNFBAppModule.preferencesClearAll();
+  return getAppModule().preferencesClearAll();
 }
 
 /**
@@ -184,10 +147,7 @@ export function preferencesClearAll(): Promise<void> {
  * @returns map of key / value pairs containing native preferences data
  */
 export function preferencesGetAll(): Promise<{ [key: string]: string | boolean }> {
-  const RNFBAppModule = getReactNativeModule(
-    APP_NATIVE_MODULE,
-  ) as unknown as RNFBAppModuleInterface;
-  return RNFBAppModule.preferencesGetAll();
+  return getAppModule().preferencesGetAll();
 }
 
 /**
@@ -197,10 +157,7 @@ export function preferencesGetAll(): Promise<{ [key: string]: string | boolean }
  * @returns Promise<void>
  */
 export function preferencesSetBool(key: string, value: boolean): Promise<void> {
-  const RNFBAppModule = getReactNativeModule(
-    APP_NATIVE_MODULE,
-  ) as unknown as RNFBAppModuleInterface;
-  return RNFBAppModule.preferencesSetBool(key, value);
+  return getAppModule().preferencesSetBool(key, value);
 }
 
 /**
@@ -210,10 +167,28 @@ export function preferencesSetBool(key: string, value: boolean): Promise<void> {
  * @returns Promise<void>
  */
 export function preferencesSetString(key: string, value: string): Promise<void> {
-  const RNFBAppModule = getReactNativeModule(
-    APP_NATIVE_MODULE,
-  ) as unknown as RNFBAppModuleInterface;
-  return RNFBAppModule.preferencesSetString(key, value);
+  return getAppModule().preferencesSetString(key, value);
 }
 
-export const SDK_VERSION = sdkVersion;
+export const SDK_VERSION: string = sdkVersion;
+
+/**
+ * Returns the {@link Utils.Module} instance for the default or given {@link ReactNativeFirebase.FirebaseApp}.
+ *
+ * @param app - The Firebase app to use. When omitted, the default app is used.
+ */
+export function getUtils(app?: ReactNativeFirebase.FirebaseApp): Utils.Module {
+  return getUtilsImpl(app);
+}
+
+/**
+ * Native device file paths for use with file-based APIs such as Storage `putFile` or `writeToFile`.
+ */
+export const FilePath: Utils.FilePath = new Proxy({} as Utils.FilePath, {
+  get(_target, prop: string | symbol) {
+    if (typeof prop === 'string') {
+      return UtilsStatics.FilePath[prop as keyof Utils.FilePath];
+    }
+    return undefined;
+  },
+});

package/lib/types/app.ts

@@ -26,6 +26,11 @@ export namespace ReactNativeFirebase {
      */
     readonly code: string;
 
+    /**
+     * Optional extra data included with the error, matching FirebaseError from `@firebase/app`.
+     */
+    customData?: Record<string, unknown>;
+
     /**
      * Firebase error message
      */
@@ -130,7 +135,6 @@ export namespace ReactNativeFirebase {
   /**
    * Base interface for FirebaseApp containing core properties and methods.
    * The concrete FirebaseApp class implements this interface.
-   * Module-specific methods (auth(), analytics(), etc.) are added to FirebaseApp via declaration merging.
    */
   export interface FirebaseAppBase {
     /**
@@ -152,21 +156,12 @@ export namespace ReactNativeFirebase {
      * Make this app unusable and free up resources.
      */
     delete(): Promise<void>;
-
-    utils(): Utils.Module;
   }
 
   /**
    * Full FirebaseApp interface that extends the base interface.
-   * Module-specific methods (auth(), analytics(), etc.) are added here via declaration merging
-   * from individual package .d.ts files.
    */
-  export interface FirebaseApp extends FirebaseAppBase {
-    // Module methods are added here via declaration merging, e.g.:
-    // auth(): FirebaseAuthTypes.Module;
-    // analytics(): FirebaseAnalyticsTypes.Module;
-    // etc.
-  }
+  export interface FirebaseApp extends FirebaseAppBase {}
 
   /**
    * Interface for a supplied `AsyncStorage`.

package/lib/types/internal.ts

@@ -15,8 +15,6 @@
  *
  */
 
-import type { ReactNativeFirebase, Utils } from './app';
-
 /**
  * Internal types for React Native Firebase
  * These types are used internally across multiple files and should not be exported to consumers
@@ -29,7 +27,7 @@ import type { ReactNativeFirebase, Utils } from './app';
 export type FirebaseJsonConfig = Record<string, unknown>;
 
 /**
- * Configuration for module namespace registration
+ * Configuration for a Firebase module instance.
  */
 export interface ModuleConfig {
   namespace: string;
@@ -41,49 +39,6 @@ export interface ModuleConfig {
   turboModule?: boolean;
 }
 
-/**
- * Extended configuration for namespace registration including native module details
- */
-export interface NamespaceConfig extends ModuleConfig {
-  nativeModuleName: string | string[];
-  nativeEvents: boolean | string[];
-  // ModuleClass can be FirebaseModule or any subclass of it
-  // Uses FirebaseAppBase (the concrete class type) rather than FirebaseApp (the augmented interface)
-  ModuleClass: new (
-    app: ReactNativeFirebase.FirebaseAppBase,
-    config: ModuleConfig,
-    customUrlOrRegion?: string | null,
-  ) => ReactNativeFirebase.FirebaseModule;
-  statics?: object;
-  version?: string;
-}
-
-/**
- * Type for a Firebase module getter function that can optionally accept
- * a custom URL/region/databaseId parameter
- */
-export type ModuleGetter = {
-  (customUrlOrRegionOrDatabaseId?: string): ReactNativeFirebase.FirebaseModule;
-  [key: string]: unknown;
-};
-
-/**
- * Type for Firebase root object with module getters
- */
-export interface FirebaseRoot {
-  initializeApp: (
-    options: ReactNativeFirebase.FirebaseAppOptions,
-    configOrName?: string | ReactNativeFirebase.FirebaseAppConfig,
-  ) => Promise<ReactNativeFirebase.FirebaseApp>;
-  setReactNativeAsyncStorage: (asyncStorage: ReactNativeFirebase.ReactNativeAsyncStorage) => void;
-  app: (name?: string) => ReactNativeFirebase.FirebaseApp;
-  apps: ReactNativeFirebase.FirebaseApp[];
-  SDK_VERSION: string;
-  setLogLevel: (logLevel: ReactNativeFirebase.LogLevelString) => void;
-  utils: Utils.Statics & (() => Utils.Module);
-  [key: string]: unknown;
-}
-
 /**
  * Native error types
  */