@react-native-firebase/auth 25.1.0 → 26.0.0

package/dist/module/index.js

@@ -16,14 +16,1229 @@
  * limitations under the License.
  *
  */
-// modular API
 
+/**
+ * Modular Auth API for React Native Firebase.
+ *
+ * Most exports mirror the [firebase-js-sdk modular Auth API](https://firebase.google.com/docs/reference/js/auth).
+ * Remarks on individual symbols call out React Native-specific behavior, unsupported
+ * web-only APIs, and return-type differences.
+ *
+ * @packageDocumentation
+ */
+
+import "./types/internal.js";
 export { ActionCodeURL } from "./ActionCodeURL.js";
 export { AuthCredential, EmailAuthCredential, OAuthCredential, PhoneAuthCredential } from "./credentials/index.js";
-export * from "./modular.js";
+import { isAndroid, isBoolean, isNull, isOther, isString, isValidUrl, parseListenerOrObserver } from '@react-native-firebase/app/dist/module/common';
+import { setReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
+import { FirebaseModule, getOrCreateModularInstance } from '@react-native-firebase/app/dist/module/internal';
+import ConfirmationResultClass from "./ConfirmationResult.js";
+import { ActionCodeURL } from "./ActionCodeURL.js";
+import { PhoneAuthState } from "./PhoneAuthState.js";
+import PhoneAuthListenerClass from "./PhoneAuthListener.js";
+import PhoneMultiFactorGenerator from "./PhoneMultiFactorGenerator.js";
+import TotpMultiFactorGenerator from "./TotpMultiFactorGenerator.js";
+import { TotpSecret } from "./TotpSecret.js";
+import Settings from "./Settings.js";
+import UserClass from "./User.js";
+import { getMultiFactorResolver as createMultiFactorResolver } from "./getMultiFactorResolver.js";
+import { MultiFactorUser as MultiFactorUserModule } from "./multiFactor.js";
+import AppleAuthProvider from "./providers/AppleAuthProvider.js";
+import EmailAuthProvider from "./providers/EmailAuthProvider.js";
+import FacebookAuthProvider from "./providers/FacebookAuthProvider.js";
+import GithubAuthProvider from "./providers/GithubAuthProvider.js";
+import GoogleAuthProvider from "./providers/GoogleAuthProvider.js";
+import OAuthProvider from "./providers/OAuthProvider.js";
+import OIDCAuthProvider from "./providers/OIDCAuthProvider.js";
+import PhoneAuthProvider from "./providers/PhoneAuthProvider.js";
+import TwitterAuthProvider from "./providers/TwitterAuthProvider.js";
+import { version } from "./version.js";
+import { ActionCodeOperation, FactorId, OperationType, ProviderId, SignInMethod } from "./constants.js";
+import fallBackModule from './web/RNFBAuthModule';
+import { PasswordPolicyMixin } from "./password-policy/PasswordPolicyMixin.js";
+const nativeEvents = ['auth_state_changed', 'auth_id_token_changed', 'phone_auth_state_changed'];
+const namespace = 'auth';
+const nativeModuleName = 'NativeRNFBTurboAuth';
+const config = {
+  namespace,
+  nativeModuleName,
+  nativeEvents,
+  hasMultiAppSupport: true,
+  hasCustomUrlOrRegionSupport: false,
+  turboModule: true
+};
+class FirebaseAuthModule extends FirebaseModule {
+  constructor(app, config, customUrlOrRegion) {
+    super(app, config, customUrlOrRegion);
+    this._user = null;
+    this._settings = null;
+    this._authResult = false;
+    this._languageCode = this.native.APP_LANGUAGE[this.app.name] ?? '';
+    this._tenantId = null;
+    this._projectPasswordPolicy = null;
+    this._tenantPasswordPolicies = {};
+    this._emulatorConfig = null;
+    this._authStateReadyPromise = null;
+    this._beforeAuthStateChangedCallbacks = [];
+    if (!this.languageCode) {
+      this._languageCode = this.native.APP_LANGUAGE['[DEFAULT]'] ?? '';
+    }
+    const initialUser = this.native.APP_USER[this.app.name];
+    if (initialUser) {
+      this._setUser(initialUser);
+    }
+    this.emitter.addListener(this.eventNameForApp('auth_state_changed'), event => {
+      const authEvent = event;
+      void this._handleAuthStateChanged(authEvent.user);
+    });
+    this.emitter.addListener(this.eventNameForApp('phone_auth_state_changed'), event => {
+      const phoneAuthEvent = event;
+      const eventKey = `phone:auth:${phoneAuthEvent.requestKey}:${phoneAuthEvent.type}`;
+      this.emitter.emit(eventKey, phoneAuthEvent.state);
+    });
+    this.emitter.addListener(this.eventNameForApp('auth_id_token_changed'), event => {
+      const authEvent = event;
+      this._setUser(authEvent.user);
+      this.emitter.emit(this.eventNameForApp('onIdTokenChanged'), this._user);
+    });
+    this.native.addAuthStateListener();
+    this.native.addIdTokenListener();
+
+    // custom authDomain in only available from App's FirebaseOptions,
+    // but we need it in Auth if it exists. During app configuration we store
+    // mappings from app name to authDomain, this auth constructor
+    // is a reasonable time to use the mapping and set it into auth natively
+    if (!isOther) {
+      // Only supported on native platforms
+      this.native.configureAuthDomain();
+    }
+  }
+  get languageCode() {
+    return this._languageCode;
+  }
+  set languageCode(code) {
+    // For modular API, not recommended to set languageCode directly as it should be set in the native SDKs first
+    if (!isString(code) && !isNull(code)) {
+      throw new Error("firebase.auth().languageCode = (*) expected 'languageCode' to be a string or null value");
+    }
+    // as this is a setter, we can't use async/await. So we set it first so it is available immediately
+    if (code === null) {
+      this._languageCode = this.native.APP_LANGUAGE[this.app.name] ?? '';
+      if (!this.languageCode) {
+        this._languageCode = this.native.APP_LANGUAGE['[DEFAULT]'] ?? '';
+      }
+    } else {
+      this._languageCode = code;
+    }
+    // This sets it natively
+    void this.setLanguageCode(code);
+  }
+  get config() {
+    // Native iOS/Android Firebase Auth SDKs do not expose the firebase-js-sdk config object.
+    return {};
+  }
+  get tenantId() {
+    return this._tenantId;
+  }
+  set tenantId(tenantId) {
+    void this.setTenantId(tenantId);
+  }
+  get emulatorConfig() {
+    return this._emulatorConfig;
+  }
+  authStateReady() {
+    if (this._authResult) {
+      return Promise.resolve();
+    }
+    if (!this._authStateReadyPromise) {
+      this._authStateReadyPromise = new Promise(resolve => {
+        const unsubscribe = this.onAuthStateChanged(() => {
+          if (this._authResult) {
+            unsubscribe();
+            resolve();
+          }
+        });
+        if (this._authResult) {
+          unsubscribe();
+          resolve();
+        }
+      });
+    }
+    return this._authStateReadyPromise;
+  }
+  beforeAuthStateChanged(callback, onAbort) {
+    const entry = {
+      callback,
+      onAbort
+    };
+    this._beforeAuthStateChangedCallbacks.push(entry);
+    return () => {
+      const index = this._beforeAuthStateChangedCallbacks.indexOf(entry);
+      if (index >= 0) {
+        this._beforeAuthStateChangedCallbacks.splice(index, 1);
+      }
+    };
+  }
+  async updateCurrentUser(user) {
+    if (user === null) {
+      await this.signOut();
+      return;
+    }
+    const userInternal = user;
+    if (!userInternal._auth || userInternal._auth !== this) {
+      throw new Error("firebase.auth().updateCurrentUser() expected 'user' to be an Auth instance from the same Firebase App");
+    }
+    if (!userInternal._user) {
+      throw new Error("firebase.auth().updateCurrentUser(*) expected 'user' to be a valid User");
+    }
+    this._setUser(userInternal._user);
+  }
+  async _handleAuthStateChanged(nativeUser) {
+    const pendingUser = nativeUser ? new UserClass(this, nativeUser) : null;
+    for (const {
+      callback,
+      onAbort
+    } of [...this._beforeAuthStateChangedCallbacks]) {
+      try {
+        await callback(pendingUser);
+      } catch {
+        onAbort?.();
+        return;
+      }
+    }
+    this._setUser(nativeUser);
+    this.emitter.emit(this.eventNameForApp('onAuthStateChanged'), this._user);
+  }
+  get settings() {
+    if (!this._settings) {
+      this._settings = new Settings(this);
+    }
+    return this._settings;
+  }
+  get currentUser() {
+    return this._user;
+  }
+  _setUser(user) {
+    this._user = user ? new UserClass(this, user) : null;
+    this._authResult = true;
+    this.emitter.emit(this.eventNameForApp('onUserChanged'), this._user);
+    return this._user;
+  }
+  _setUserCredential(userCredential) {
+    const user = new UserClass(this, userCredential.user);
+    this._user = user;
+    this._authResult = true;
+    this.emitter.emit(this.eventNameForApp('onUserChanged'), this._user);
+    return {
+      additionalUserInfo: userCredential.additionalUserInfo,
+      user
+    };
+  }
+  async setLanguageCode(code) {
+    if (!isString(code) && !isNull(code)) {
+      throw new Error("firebase.auth().setLanguageCode(*) expected 'languageCode' to be a string or null value");
+    }
+    await this.native.setLanguageCode(code);
+    if (code === null) {
+      this._languageCode = this.native.APP_LANGUAGE[this.app.name] ?? '';
+      if (!this.languageCode) {
+        this._languageCode = this.native.APP_LANGUAGE['[DEFAULT]'] ?? '';
+      }
+    } else {
+      this._languageCode = code;
+    }
+  }
+  async setTenantId(tenantId) {
+    if (!isString(tenantId) && !isNull(tenantId)) {
+      throw new Error("firebase.auth().setTenantId(*) expected 'tenantId' to be a string");
+    }
+    await this.native.setTenantId(tenantId);
+    this._tenantId = tenantId;
+  }
+  onAuthStateChanged(listenerOrObserver) {
+    const listener = parseListenerOrObserver(listenerOrObserver);
+    const subscription = this.emitter.addListener(this.eventNameForApp('onAuthStateChanged'), listener);
+    if (this._authResult) {
+      Promise.resolve().then(() => {
+        listener(this._user || null);
+      });
+    }
+    return () => subscription.remove();
+  }
+  onIdTokenChanged(listenerOrObserver) {
+    const listener = parseListenerOrObserver(listenerOrObserver);
+    const subscription = this.emitter.addListener(this.eventNameForApp('onIdTokenChanged'), listener);
+    if (this._authResult) {
+      Promise.resolve().then(() => {
+        listener(this._user || null);
+      });
+    }
+    return () => subscription.remove();
+  }
+  onUserChanged(listenerOrObserver) {
+    const listener = parseListenerOrObserver(listenerOrObserver);
+    const subscription = this.emitter.addListener(this.eventNameForApp('onUserChanged'), listener);
+    if (this._authResult) {
+      Promise.resolve().then(() => {
+        listener(this._user || null);
+      });
+    }
+    return () => {
+      subscription.remove();
+    };
+  }
+  signOut() {
+    return this.native.signOut().then(() => {
+      this._setUser(null);
+    });
+  }
+  signInAnonymously() {
+    return this.native.signInAnonymously().then(userCredential => this._setUserCredential(userCredential));
+  }
+  signInWithPhoneNumber(phoneNumber, forceResend) {
+    return this.native.signInWithPhoneNumber(phoneNumber, forceResend || false).then(result => new ConfirmationResultClass(this, result.verificationId));
+  }
+  verifyPhoneNumber(phoneNumber, autoVerifyTimeoutOrForceResend, forceResend) {
+    let _forceResend = forceResend;
+    let _autoVerifyTimeout = 60;
+    if (isBoolean(autoVerifyTimeoutOrForceResend)) {
+      _forceResend = autoVerifyTimeoutOrForceResend;
+    } else {
+      _autoVerifyTimeout = autoVerifyTimeoutOrForceResend;
+    }
+    return new PhoneAuthListenerClass(this, phoneNumber, _autoVerifyTimeout, _forceResend);
+  }
+  verifyPhoneNumberWithMultiFactorInfo(multiFactorHint, session) {
+    return this.native.verifyPhoneNumberWithMultiFactorInfo(multiFactorHint.uid, session);
+  }
+  verifyPhoneNumberForMultiFactor(phoneInfoOptions) {
+    const {
+      phoneNumber,
+      session
+    } = phoneInfoOptions;
+    return this.native.verifyPhoneNumberForMultiFactor(phoneNumber, session);
+  }
+  resolveMultiFactorSignIn(session, verificationId, verificationCode) {
+    return this.native.resolveMultiFactorSignIn(session, verificationId, verificationCode).then(userCredential => {
+      return this._setUserCredential(userCredential);
+    });
+  }
+  resolveTotpSignIn(session, uid, totpSecret) {
+    return this.native.resolveTotpSignIn(session, uid, totpSecret).then(userCredential => {
+      return this._setUserCredential(userCredential);
+    });
+  }
+  createUserWithEmailAndPassword(email, password) {
+    return this.native.createUserWithEmailAndPassword(email, password).then(userCredential => this._setUserCredential(userCredential))
+    /* istanbul ignore next - native error handling cannot be unit tested */.catch(error => {
+      if (error.code === 'auth/password-does-not-meet-requirements') {
+        return this._recachePasswordPolicy().catch(() => {
+          // Silently ignore recache failures - the original error matters more
+        }).then(() => {
+          throw error;
+        });
+      }
+      throw error;
+    });
+  }
+  signInWithEmailAndPassword(email, password) {
+    return this.native.signInWithEmailAndPassword(email, password).then(userCredential => this._setUserCredential(userCredential))
+    /* istanbul ignore next - native error handling cannot be unit tested */.catch(error => {
+      if (error.code === 'auth/password-does-not-meet-requirements') {
+        return this._recachePasswordPolicy().catch(() => {
+          // Silently ignore recache failures - the original error matters more
+        }).then(() => {
+          throw error;
+        });
+      }
+      throw error;
+    });
+  }
+  signInWithCustomToken(customToken) {
+    return this.native.signInWithCustomToken(customToken).then(userCredential => this._setUserCredential(userCredential));
+  }
+  signInWithCredential(credential) {
+    return this.native.signInWithCredential(credential.providerId, credential.token, credential.secret).then(userCredential => this._setUserCredential(userCredential));
+  }
+  revokeToken(authorizationCode) {
+    return this.native.revokeToken(authorizationCode);
+  }
+  sendPasswordResetEmail(email, actionCodeSettings = null) {
+    return this.native.sendPasswordResetEmail(email, actionCodeSettings);
+  }
+  _resolveActionCodeSettings(actionCodeSettings) {
+    if (actionCodeSettings && isString(actionCodeSettings.url)) {
+      return actionCodeSettings;
+    }
+    const authDomain = this.app.options.authDomain;
+    let url = 'https://localhost';
+    if (authDomain && isString(authDomain)) {
+      url = isValidUrl(authDomain) ? authDomain : `https://${authDomain}`;
+    }
+    return {
+      ...(actionCodeSettings ?? {}),
+      url,
+      handleCodeInApp: actionCodeSettings?.handleCodeInApp ?? true
+    };
+  }
+  sendSignInLinkToEmail(email, actionCodeSettings) {
+    return this.native.sendSignInLinkToEmail(email, this._resolveActionCodeSettings(actionCodeSettings));
+  }
+  isSignInWithEmailLink(emailLink) {
+    return this.native.isSignInWithEmailLink(emailLink);
+  }
+  signInWithEmailLink(email, emailLink) {
+    return this.native.signInWithEmailLink(email, emailLink ?? '').then(userCredential => this._setUserCredential(userCredential));
+  }
+  confirmPasswordReset(code, newPassword) {
+    return this.native.confirmPasswordReset(code, newPassword)
+    /* istanbul ignore next - native error handling cannot be unit tested */.catch(error => {
+      if (error.code === 'auth/password-does-not-meet-requirements') {
+        return this._recachePasswordPolicy().catch(() => {
+          // Silently ignore recache failures - the original error matters more
+        }).then(() => {
+          throw error;
+        });
+      }
+      throw error;
+    });
+  }
+  applyActionCode(code) {
+    return this.native.applyActionCode(code).then(user => {
+      this._setUser(user);
+    });
+  }
+  checkActionCode(code) {
+    return this.native.checkActionCode(code);
+  }
+  fetchSignInMethodsForEmail(email) {
+    return this.native.fetchSignInMethodsForEmail(email);
+  }
+  verifyPasswordResetCode(code) {
+    return this.native.verifyPasswordResetCode(code);
+  }
+  useUserAccessGroup(userAccessGroup) {
+    if (isAndroid) {
+      return Promise.resolve();
+    }
+    return this.native.useUserAccessGroup(userAccessGroup).then(() => undefined);
+  }
+  getRedirectResult() {
+    throw new Error('firebase.auth().getRedirectResult() is unsupported by the native Firebase SDKs.');
+  }
+  setPersistence() {
+    throw new Error('firebase.auth().setPersistence() is unsupported by the native Firebase SDKs.');
+  }
+  signInWithPopup(provider) {
+    return this.native.signInWithProvider(provider.toObject()).then(userCredential => this._setUserCredential(userCredential));
+  }
+  signInWithRedirect(provider) {
+    return this.native.signInWithProvider(provider.toObject()).then(userCredential => this._setUserCredential(userCredential));
+  }
+
+  // firebase issue - https://github.com/invertase/react-native-firebase/pull/655#issuecomment-349904680
+  useDeviceLanguage() {
+    throw new Error('firebase.auth().useDeviceLanguage() is unsupported by the native Firebase SDKs.');
+  }
+  useEmulator(url, options) {
+    if (!url || !isString(url) || !isValidUrl(url)) {
+      throw new Error('firebase.auth().useEmulator() takes a non-empty string URL');
+    }
+    let _url = url;
+    const androidBypassEmulatorUrlRemap = typeof this.firebaseJson.android_bypass_emulator_url_remap === 'boolean' && this.firebaseJson.android_bypass_emulator_url_remap;
+    if (!androidBypassEmulatorUrlRemap && isAndroid && _url) {
+      if (_url.startsWith('http://localhost')) {
+        _url = _url.replace('http://localhost', 'http://10.0.2.2');
+        // eslint-disable-next-line no-console
+        console.log('Mapping auth host "localhost" to "10.0.2.2" for android emulators. Use real IP on real devices. You can bypass this behaviour with "android_bypass_emulator_url_remap" flag.');
+      }
+      if (_url.startsWith('http://127.0.0.1')) {
+        _url = _url.replace('http://127.0.0.1', 'http://10.0.2.2');
+        // eslint-disable-next-line no-console
+        console.log('Mapping auth host "127.0.0.1" to "10.0.2.2" for android emulators. Use real IP on real devices. You can bypass this behaviour with "android_bypass_emulator_url_remap" flag.');
+      }
+    }
+
+    // Native calls take the host and port split out
+    const hostPortRegex = /^http:\/\/([\w\d-.]+):(\d+)$/;
+    const urlMatches = _url.match(hostPortRegex);
+    if (!urlMatches) {
+      throw new Error('firebase.auth().useEmulator() unable to parse host and port from URL');
+    }
+    const host = urlMatches[1];
+    const portString = urlMatches[2];
+    if (!host) {
+      throw new Error('firebase.auth().useEmulator() unable to parse host from URL');
+    }
+    const port = portString ? parseInt(portString, 10) : undefined;
+    this._emulatorConfig = {
+      protocol: 'http',
+      host,
+      port: port ?? null,
+      options: {
+        disableWarnings: options?.disableWarnings ?? false
+      }
+    };
+    this.native.useEmulator(host, port);
+    // @ts-ignore - undocumented return, useful for unit testing
+    return [host, port];
+  }
+  getMultiFactorResolver(error) {
+    return createMultiFactorResolver(this, error);
+  }
+  multiFactor(user) {
+    if (!this.currentUser || user.uid !== this.currentUser.uid) {
+      throw new Error('firebase.auth().multiFactor() only operates on currentUser');
+    }
+    return new MultiFactorUserModule(this, user);
+  }
+  getCustomAuthDomain() {
+    return this.native.getCustomAuthDomain();
+  }
+}
+
+// Apply password policy mixin to FirebaseAuthModule
+Object.assign(FirebaseAuthModule.prototype, PasswordPolicyMixin);
+export { AppleAuthProvider, EmailAuthProvider, FacebookAuthProvider, GithubAuthProvider, GoogleAuthProvider, OAuthProvider, OIDCAuthProvider, PhoneAuthProvider, PhoneAuthState, PhoneMultiFactorGenerator, TotpMultiFactorGenerator, TotpSecret, TwitterAuthProvider, ActionCodeOperation, FactorId, OperationType, ProviderId, SignInMethod };
+function getAuthInternal(auth) {
+  return auth;
+}
+function getUserInternal(user) {
+  return user;
+}
+function normalizeAdditionalUserInfo(info) {
+  return {
+    ...info,
+    isNewUser: Boolean(info.isNewUser),
+    profile: info.profile ?? null,
+    providerId: info.providerId ?? null,
+    username: info.username ?? null
+  };
+}
+function normalizeUserCredential(userCredential, overrides = {}) {
+  const normalizedUserCredential = {
+    user: userCredential.user,
+    providerId: overrides.providerId ?? userCredential.providerId ?? userCredential.additionalUserInfo?.providerId ?? null,
+    operationType: overrides.operationType ?? userCredential.operationType ?? OperationType.SIGN_IN
+  };
+  if (userCredential.additionalUserInfo) {
+    normalizedUserCredential.additionalUserInfo = normalizeAdditionalUserInfo(userCredential.additionalUserInfo);
+  }
+  return normalizedUserCredential;
+}
+function normalizeMultiFactorInfo(info) {
+  const normalizedInfo = {
+    uid: info.uid,
+    displayName: info.displayName ?? null,
+    enrollmentTime: info.enrollmentTime,
+    factorId: info.factorId
+  };
+  if ('phoneNumber' in info) {
+    return {
+      ...normalizedInfo,
+      phoneNumber: info.phoneNumber
+    };
+  }
+  return normalizedInfo;
+}
+function normalizeActionCodeInfo(actionCodeInfo) {
+  const data = actionCodeInfo.data ?? {};
+  return {
+    data: {
+      email: data.email ?? null,
+      multiFactorInfo: 'multiFactorInfo' in data && data.multiFactorInfo ? normalizeMultiFactorInfo(data.multiFactorInfo) : null,
+      previousEmail: ('previousEmail' in data ? data.previousEmail : undefined) ?? ('fromEmail' in data ? data.fromEmail : undefined) ?? null
+    },
+    operation: actionCodeInfo.operation
+  };
+}
+function normalizeConfirmationResult(confirmationResult) {
+  if (!confirmationResult.verificationId) {
+    throw new Error('signInWithPhoneNumber() did not return a verificationId.');
+  }
+  return {
+    verificationId: confirmationResult.verificationId,
+    async confirm(verificationCode) {
+      const userCredential = await confirmationResult.confirm(verificationCode);
+      if (!userCredential) {
+        throw new Error('signInWithPhoneNumber().confirm() returned no user credential.');
+      }
+      return normalizeUserCredential(userCredential, {
+        providerId: ProviderId.PHONE,
+        operationType: OperationType.SIGN_IN
+      });
+    }
+  };
+}
+function normalizeMultiFactorResolver(resolver) {
+  return {
+    hints: resolver.hints.map(normalizeMultiFactorInfo),
+    session: resolver.session,
+    async resolveSignIn(assertion) {
+      return normalizeUserCredential(await resolver.resolveSignIn(assertion), {
+        providerId: assertion.factorId === FactorId.PHONE ? ProviderId.PHONE : null,
+        operationType: OperationType.SIGN_IN
+      });
+    }
+  };
+}
+function normalizeMultiFactorUser(multiFactorUser) {
+  return {
+    enrolledFactors: multiFactorUser.enrolledFactors.map(normalizeMultiFactorInfo),
+    getSession: () => multiFactorUser.getSession(),
+    enroll: (assertion, displayName) => multiFactorUser.enroll(assertion, displayName),
+    unenroll: option => multiFactorUser.unenroll(option)
+  };
+}
+function normalizeAuthListener(nextOrObserver) {
+  if (typeof nextOrObserver === 'function') {
+    return nextOrObserver;
+  }
+  if (typeof nextOrObserver.next !== 'function') {
+    return {
+      next: () => {}
+    };
+  }
+  return nextOrObserver;
+}
+function callAuthMethod(auth, method, ...args) {
+  return method.call(auth, ...args);
+}
+function callUserMethod(user, method, ...args) {
+  return method.call(user, ...args);
+}
+
+/**
+ * Returns the Auth instance associated with the provided FirebaseApp.
+ *
+ * @param app - The Firebase app instance. Defaults to the default app.
+ */
+export function getAuth(app) {
+  return getOrCreateModularInstance(FirebaseAuthModule, config, app);
+}
+
+/**
+ * This function allows more control over the Auth instance than getAuth().
+ *
+ * @param app - The Firebase app to initialize Auth for.
+ * @param _deps - Optional firebase-js-sdk dependency bag.
+ *
+ * @remarks
+ * The optional `deps` argument exists for firebase-js-sdk API parity. React Native Firebase
+ * ignores persistence, popup redirect resolver, and error-map dependencies because native
+ * iOS/Android SDKs manage auth state and do not support the web-only persistence stack.
+ * `initializeAuth()` returns the same shared Auth instance as {@link getAuth}.
+ */
+export function initializeAuth(app, _deps) {
+  return getAuth(app);
+}
+
+/**
+ * Applies an out-of-band email action code (for example from a password reset or email verification link).
+ */
+export function applyActionCode(auth, oobCode) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.applyActionCode, oobCode);
+}
+
+/**
+ * Registers a callback to run before an auth state change is committed.
+ *
+ * @returns An unsubscribe function.
+ */
+export function beforeAuthStateChanged(auth, callback, onAbort) {
+  const authInternal = getAuthInternal(auth);
+  return authInternal.beforeAuthStateChanged(callback, onAbort);
+}
+
+/**
+ * Checks the validity of an out-of-band email action code and returns metadata about the pending operation.
+ *
+ * @remarks React Native Firebase normalizes native results toward firebase-js-sdk shapes, including mapping
+ * `fromEmail` to `previousEmail` and coercing multi-factor info objects.
+ */
+export function checkActionCode(auth, oobCode) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.checkActionCode, oobCode).then(normalizeActionCodeInfo);
+}
+
+/**
+ * Confirms a password reset using the out-of-band code from the reset email.
+ */
+export function confirmPasswordReset(auth, oobCode, newPassword) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.confirmPasswordReset, oobCode, newPassword);
+}
+
+/**
+ * Connects the Auth instance to the Auth emulator.
+ *
+ * @remarks Delegates to the native `useEmulator` bridge. Accepts the firebase-js-sdk
+ * `options.disableWarnings` flag for {@link Auth.emulatorConfig} parity. On web, that flag
+ * suppresses the emulator DOM warning banner; native iOS/Android SDKs do not surface that banner,
+ * so the value is recorded on `auth.emulatorConfig.options` only. When `options` is provided,
+ * `disableWarnings` is required (matching firebase-js-sdk).
+ */
+export function connectAuthEmulator(auth, url, options) {
+  const authInternal = getAuthInternal(auth);
+  callAuthMethod(authInternal, authInternal.useEmulator, url, options);
+}
+
+/**
+ * Creates a new user with an email address and password.
+ *
+ * @remarks Returned {@link UserCredential} objects include top-level `providerId` and `operationType`
+ * fields. `additionalUserInfo`, when present, is attached as a non-enumerable property.
+ */
+export function createUserWithEmailAndPassword(auth, email, password) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.createUserWithEmailAndPassword, email, password).then(userCredential => normalizeUserCredential(userCredential, {
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Fetches the sign-in methods available for the given email address.
+ */
+export function fetchSignInMethodsForEmail(auth, email) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.fetchSignInMethodsForEmail, email);
+}
+
+/**
+ * Extracts a {@link MultiFactorResolver} from a {@link MultiFactorError}.
+ *
+ * @throws If the error does not contain resolver hints.
+ */
+export function getMultiFactorResolver(auth, error) {
+  const authInternal = getAuthInternal(auth);
+  const resolver = callAuthMethod(authInternal, authInternal.getMultiFactorResolver, error);
+  if (!resolver) {
+    throw new Error('The provided auth error did not contain a multi-factor resolver.');
+  }
+  return normalizeMultiFactorResolver(resolver);
+}
+
+/**
+ * Returns the redirect sign-in result after a browser redirect flow completes.
+ *
+ * @remarks
+ * **Not supported on React Native Firebase.** Always throws synchronously because native provider
+ * flows do not use the browser redirect contract from the firebase-js-sdk.
+ */
+export function getRedirectResult(_auth, _resolver) {
+  throw new Error('getRedirectResult is unsupported by the native Firebase SDKs.');
+}
+
+/**
+ * Checks whether an email link is a valid sign-in with email link URL.
+ *
+ */
+export function isSignInWithEmailLink(auth, emailLink) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.isSignInWithEmailLink, emailLink);
+}
+
+/**
+ * Subscribes to auth state changes for the given Auth instance.
+ *
+ * @returns An unsubscribe function.
+ *
+ * @remarks The legacy `error` and `completed` callback overload exists for firebase-js-sdk API parity.
+ * Native auth listeners never invoke separate error or completed callbacks.
+ */
+export function onAuthStateChanged(auth, nextOrObserver, _error, _completed) {
+  // The legacy callback overload exists for JS SDK compatibility, but native auth listeners
+  // never invoke separate error/completed callbacks.
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.onAuthStateChanged, normalizeAuthListener(nextOrObserver));
+}
+
+/**
+ * Subscribes to ID token changes for the given Auth instance.
+ *
+ * @returns An unsubscribe function.
+ *
+ * @remarks The legacy `error` and `completed` callback overload exists for firebase-js-sdk API parity.
+ * Native auth listeners never invoke separate error or completed callbacks.
+ */
+export function onIdTokenChanged(auth, nextOrObserver, _error, _completed) {
+  // The legacy callback overload exists for JS SDK compatibility, but native auth listeners
+  // never invoke separate error/completed callbacks.
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.onIdTokenChanged, normalizeAuthListener(nextOrObserver));
+}
+
+/**
+ * Revokes the given OAuth access token for the current user.
+ *
+ * @remarks
+ * **Web only.** Always throws synchronously on React Native Firebase.
+ */
+export function revokeAccessToken(_auth, _token) {
+  throw new Error('revokeAccessToken() is only supported on Web');
+}
+
+/**
+ * Revokes a user's Sign in with Apple token.
+ *
+ * @remarks
+ * React Native Firebase-specific API required by Apple's account-deletion guidelines.
+ * **Supported on iOS** via the native `revokeTokenWithAuthorizationCode` bridge.
+ * On Android and Web the bridge resolves without performing revocation (no-op).
+ * Distinct from firebase-js-sdk {@link revokeAccessToken}, which revokes OAuth access tokens on Web only.
+ */
+export function revokeToken(auth, authorizationCode) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.revokeToken, authorizationCode);
+}
+
+/**
+ * Sends a password reset email to the given address.
+ */
+export function sendPasswordResetEmail(auth, email, actionCodeSettings) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.sendPasswordResetEmail, email, actionCodeSettings);
+}
+
+/**
+ * Sends a sign-in with email link to the given address.
+ *
+ * @remarks `actionCodeSettings` is required in the modular API (matching firebase-js-sdk).
+ * The namespaced `firebase.auth().sendSignInLinkToEmail(email, settings?)` API still supplies
+ * defaults when settings are omitted.
+ */
+export function sendSignInLinkToEmail(auth, email, actionCodeSettings) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.sendSignInLinkToEmail, email, actionCodeSettings);
+}
+
+/**
+ * Sets the persistence type for the Auth instance.
+ *
+ * @remarks
+ * **Not supported on React Native Firebase.** Always throws synchronously because auth state is
+ * managed by the native iOS/Android SDKs rather than the web persistence stack.
+ */
+export function setPersistence(_auth, _persistence) {
+  throw new Error('setPersistence is unsupported by the native Firebase SDKs.');
+}
+
+/**
+ * Signs in anonymously.
+ */
+export function signInAnonymously(auth) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInAnonymously).then(userCredential => normalizeUserCredential(userCredential, {
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Signs in with the given auth credential.
+ */
+export function signInWithCredential(auth, credential) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInWithCredential, credential).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: credential.providerId,
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Signs in with a custom authentication token.
+ */
+export function signInWithCustomToken(auth, customToken) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInWithCustomToken, customToken).then(userCredential => normalizeUserCredential(userCredential, {
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Signs in with an email address and password.
+ */
+export function signInWithEmailAndPassword(auth, email, password) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInWithEmailAndPassword, email, password).then(userCredential => normalizeUserCredential(userCredential, {
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Signs in using an email and sign-in with email link.
+ *
+ * @remarks The `emailLink` argument is optional, matching firebase-js-sdk.
+ */
+export function signInWithEmailLink(auth, email, emailLink) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInWithEmailLink, email, emailLink).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: ProviderId.PASSWORD,
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Signs in with a phone number and returns a confirmation result for SMS verification.
+ *
+ * @remarks
+ * Native SDKs own the phone verification flow. The optional `appVerifier` argument from the
+ * firebase-js-sdk is ignored. This modular API also does not accept RNFB's legacy `forceResend`
+ * argument — use {@link verifyPhoneNumber} for the native listener / force-resend flow instead.
+ */
+export function signInWithPhoneNumber(auth, phoneNumber, _appVerifier) {
+  // Native SDKs own the verification flow, so the modular wrapper intentionally ignores the
+  // JS SDK's optional ApplicationVerifier and forwards only the phone number.
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInWithPhoneNumber, phoneNumber).then(normalizeConfirmationResult);
+}
+
+/**
+ * Starts native phone number verification and returns a listener for verification events.
+ *
+ * @remarks React Native Firebase-specific API with no firebase-js-sdk equivalent. Use this for
+ * auto-verification, resend, and multi-step phone auth flows that require native callbacks.
+ */
+export function verifyPhoneNumber(auth, phoneNumber, autoVerifyTimeoutOrForceResend, forceResend) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.verifyPhoneNumber, phoneNumber, autoVerifyTimeoutOrForceResend, forceResend);
+}
+
+/**
+ * Signs in with the given provider using a native popup-style flow where supported.
+ */
+export function signInWithPopup(auth, provider, _resolver) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInWithPopup, provider).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: provider.providerId,
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Signs in with the given provider using a redirect-style flow.
+ *
+ * @remarks On React Native Firebase, native provider flows complete immediately and resolve with a
+ * {@link UserCredential} instead of following the browser redirect contract used by the
+ * firebase-js-sdk (which resolves later via {@link getRedirectResult}).
+ */
+export function signInWithRedirect(auth, provider, _resolver) {
+  // Native provider flows complete immediately and return a credential instead of following the
+  // browser redirect contract from the Firebase JS SDK.
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signInWithRedirect, provider).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: provider.providerId,
+    operationType: OperationType.SIGN_IN
+  }));
+}
+
+/**
+ * Signs out the current user for the given Auth instance.
+ */
+export function signOut(auth) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.signOut);
+}
+
+/**
+ * Updates the currently signed-in user on the Auth instance.
+ */
+export function updateCurrentUser(auth, user) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.updateCurrentUser, user);
+}
+
+/**
+ * Sets the Auth `languageCode` from the device locale.
+ *
+ * @remarks
+ * **Not supported on React Native Firebase.** Always throws synchronously. Set `auth.languageCode`
+ * directly or use {@link setLanguageCode}.
+ */
+export function useDeviceLanguage(_auth) {
+  throw new Error('useDeviceLanguage is unsupported by the native Firebase SDKs');
+}
+
+/**
+ * Sets the Auth language code.
+ *
+ * @remarks React Native Firebase exposes this as a modular helper. The firebase-js-sdk only exposes
+ * the writable `auth.languageCode` property.
+ */
+export function setLanguageCode(auth, languageCode) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.setLanguageCode, languageCode);
+}
+
+/**
+ * Configures iOS keychain access group sharing for the Auth instance.
+ *
+ * @remarks **iOS only** React Native Firebase helper with no firebase-js-sdk equivalent.
+ * Enables sharing auth state across apps in the same access group (e.g. app extensions).
+ */
+export function useUserAccessGroup(auth, userAccessGroup) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.useUserAccessGroup, userAccessGroup).then(() => undefined);
+}
+
+/**
+ * Verifies a password reset code and returns the associated email address.
+ */
+export function verifyPasswordResetCode(auth, code) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.verifyPasswordResetCode, code);
+}
+
+/**
+ * Parses an email action link string.
+ *
+ * @param link - The email action link to parse.
+ * @returns The {@link ActionCodeURL} object, or `null` if the link is invalid.
+ *
+ * @remarks Pure URL parsing (ported from firebase-js-sdk). Works on all platforms without a native
+ * bridge. See also {@link ActionCodeURL.parseLink}.
+ */
+export function parseActionCodeURL(link) {
+  return ActionCodeURL.parseLink(link);
+}
+
+/**
+ * Deletes the given user account.
+ */
+export function deleteUser(user) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.delete);
+}
+
+/**
+ * Returns the current ID token for the user.
+ */
+export function getIdToken(user, forceRefresh) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.getIdToken, forceRefresh);
+}
+
+/**
+ * Returns the decoded ID token result for the user.
+ */
+export function getIdTokenResult(user, forceRefresh) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.getIdTokenResult, forceRefresh);
+}
+
+/**
+ * Links the user account with the given credential.
+ */
+export function linkWithCredential(user, credential) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.linkWithCredential, credential).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: credential.providerId,
+    operationType: OperationType.LINK
+  }));
+}
+
+/**
+ * Links the user account with a phone number using SMS verification.
+ *
+ * @remarks
+ * **Not supported on React Native Firebase.** Always throws synchronously.
+ */
+export function linkWithPhoneNumber(_user, _phoneNumber, _appVerifier) {
+  throw new Error('linkWithPhoneNumber is unsupported by the native Firebase SDKs');
+}
+
+/**
+ * Links the user account with the given provider using a native popup-style flow where supported.
+ */
+export function linkWithPopup(user, provider, _resolver) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.linkWithPopup, provider).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: provider.providerId,
+    operationType: OperationType.LINK
+  }));
+}
+
+/**
+ * Links the user account with the given provider using a redirect-style flow.
+ *
+ * @remarks On React Native Firebase, native provider flows complete immediately and resolve with a
+ * {@link UserCredential} instead of following the browser redirect contract used by the
+ * firebase-js-sdk.
+ */
+export function linkWithRedirect(user, provider, _resolver) {
+  // Native provider flows complete immediately and return a credential instead of following the
+  // browser redirect contract from the Firebase JS SDK.
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.linkWithRedirect, provider).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: provider.providerId,
+    operationType: OperationType.LINK
+  }));
+}
+
+/**
+ * Returns the multi-factor interface for the given user.
+ *
+ * @remarks Uses the user's own Auth instance instead of always calling {@link getAuth}, which fixes
+ * secondary Firebase app usage compared with earlier RNFB behavior.
+ */
+export function multiFactor(user) {
+  return normalizeMultiFactorUser(new MultiFactorUserModule(user._auth || getAuth(), user));
+}
+
+/**
+ * Reauthenticates the user with the given credential.
+ */
+export function reauthenticateWithCredential(user, credential) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.reauthenticateWithCredential, credential).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: credential.providerId,
+    operationType: OperationType.REAUTHENTICATE
+  }));
+}
+
+/**
+ * Reauthenticates the user with a phone number using SMS verification.
+ *
+ * @remarks
+ * **Not supported on React Native Firebase.** Always throws synchronously.
+ */
+export function reauthenticateWithPhoneNumber(_user, _phoneNumber, _appVerifier) {
+  throw new Error('reauthenticateWithPhoneNumber is unsupported by the native Firebase SDKs');
+}
+
+/**
+ * Reauthenticates the user with the given provider using a native popup-style flow where supported.
+ */
+export function reauthenticateWithPopup(user, provider, _resolver) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.reauthenticateWithPopup, provider).then(userCredential => normalizeUserCredential(userCredential, {
+    providerId: provider.providerId,
+    operationType: OperationType.REAUTHENTICATE
+  }));
+}
+
+/**
+ * Reauthenticates the user with the given provider using a redirect-style flow.
+ *
+ * @remarks On React Native Firebase, native provider flows do not follow the browser redirect
+ * contract. This resolves with `void` after the native flow completes instead of the
+ * firebase-js-sdk `Promise<never>` signature used for unresolved browser redirects.
+ */
+export function reauthenticateWithRedirect(user, provider, _resolver) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.reauthenticateWithRedirect, provider);
+}
+
+/**
+ * Reloads the user's profile data from the server.
+ */
+export function reload(user) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.reload);
+}
+
+/**
+ * Sends an email verification message to the user.
+ */
+export function sendEmailVerification(user, actionCodeSettings) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.sendEmailVerification, actionCodeSettings ?? undefined);
+}
+
+/**
+ * Unlinks a provider from the user account.
+ */
+export function unlink(user, providerId) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.unlink, providerId);
+}
+
+/**
+ * Updates the user's email address.
+ */
+export function updateEmail(user, newEmail) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.updateEmail, newEmail);
+}
+
+/**
+ * Updates the user's password.
+ */
+export function updatePassword(user, newPassword) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.updatePassword, newPassword);
+}
+
+/**
+ * Updates the user's phone number using a phone auth credential.
+ */
+export function updatePhoneNumber(user, credential) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.updatePhoneNumber, credential);
+}
+
+/**
+ * Updates the user's display name and/or photo URL.
+ */
+export function updateProfile(user, profile) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.updateProfile, {
+    displayName: profile.displayName,
+    photoURL: profile.photoURL
+  });
+}
+
+/**
+ * Sends a verification email to the new address before updating the user's email.
+ */
+export function verifyBeforeUpdateEmail(user, newEmail, actionCodeSettings) {
+  const userInternal = getUserInternal(user);
+  return callUserMethod(userInternal, userInternal.verifyBeforeUpdateEmail, newEmail, actionCodeSettings ?? undefined);
+}
+
+/**
+ * Returns additional OAuth / federated sign-in information from a {@link UserCredential}.
+ *
+ * @remarks Returns firebase-js-sdk core fields plus any extra native keys copied from the bridge.
+ */
+export function getAdditionalUserInfo(userCredential) {
+  if (userCredential.additionalUserInfo) {
+    return userCredential.additionalUserInfo;
+  }
+  const info = userCredential.additionalUserInfo;
+  if (!info) {
+    return null;
+  }
+  return normalizeAdditionalUserInfo(info);
+}
+
+/**
+ * Returns the configured custom auth domain for the Auth instance.
+ *
+ * @remarks React Native Firebase-specific helper with no firebase-js-sdk modular equivalent.
+ * Reads the custom domain configured for the Firebase project through the native Auth SDK.
+ */
+export function getCustomAuthDomain(auth) {
+  const authInternal = getAuthInternal(auth);
+  return callAuthMethod(authInternal, authInternal.getCustomAuthDomain);
+}
+
+/**
+ * Validates a password against the project's password policy.
+ */
+export function validatePassword(auth, password) {
+  if (!auth || !('app' in auth)) {
+    throw new Error(`firebase.auth().validatePassword(*) 'auth' must be a valid Auth instance with an 'app' property`);
+  }
+  if (password === null || password === undefined) {
+    throw new Error("firebase.auth().validatePassword(*) expected 'password' to be a non-null or a defined value.");
+  }
+  const authWithPasswordValidation = getAuthInternal(auth);
+  return callAuthMethod(authWithPasswordValidation, authWithPasswordValidation.validatePassword, password);
+}
+export const SDK_VERSION = version;
 
-// namespaced API
-export * from "./types/namespaced.js";
-export * from "./namespaced.js";
-export { default } from "./namespaced.js";
+// Register the interop module for non-native platforms.
+setReactNativeModule(nativeModuleName, fallBackModule);
 //# sourceMappingURL=index.js.map