@react-native-firebase/auth 24.1.1 → 25.0.1

package/dist/module/modular.js

@@ -0,0 +1,793 @@
+"use strict";
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { getApp } from '@react-native-firebase/app';
+import { MODULAR_DEPRECATION_ARG } from '@react-native-firebase/app/dist/module/common';
+import { ActionCodeOperation, FactorId, OperationType, ProviderId, SignInMethod } from "./constants.js";
+import PhoneMultiFactorGenerator from "./PhoneMultiFactorGenerator.js";
+import { PhoneAuthState } from "./PhoneAuthState.js";
+import TotpMultiFactorGenerator from "./TotpMultiFactorGenerator.js";
+import { TotpSecret } from "./TotpSecret.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 { ActionCodeURL } from "./ActionCodeURL.js";
+
+/**
+ * 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
+ */
+
+export { ActionCodeOperation, FactorId, OperationType, ProviderId, SignInMethod };
+function appWithAuth(app) {
+  return app ? getApp(app.name) : getApp();
+}
+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)
+  };
+}
+export { ActionCodeURL } from "./ActionCodeURL.js";
+export { AuthCredential, EmailAuthCredential, OAuthCredential, PhoneAuthCredential } from "./credentials/index.js";
+export { AppleAuthProvider, EmailAuthProvider, FacebookAuthProvider, GithubAuthProvider, GoogleAuthProvider, OAuthProvider, OIDCAuthProvider, PhoneAuthProvider, PhoneAuthState, PhoneMultiFactorGenerator, TotpMultiFactorGenerator, TotpSecret, TwitterAuthProvider };
+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, MODULAR_DEPRECATION_ARG);
+}
+function callUserMethod(user, method, ...args) {
+  return method.call(user, ...args, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Returns the Auth instance associated with the provided FirebaseApp.
+ *
+ * @param app - The Firebase app instance. Defaults to the default app.
+ */
+export function getAuth(app) {
+  // Keep getAuth() on the shared namespaced instance; method wrappers add the modular sentinel.
+  return appWithAuth(app).auth();
+}
+
+/**
+ * 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) {
+  // Keep initializeAuth() aligned with getAuth(); passing the sentinel here creates a second module.
+  return appWithAuth(app).auth();
+}
+
+/**
+ * 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.
+ *
+ * @remarks React Native Firebase performs this check through the native bridge and returns
+ * `Promise<boolean>`. The firebase-js-sdk returns a synchronous `boolean`.
+ */
+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 React Native Firebase-specific iOS helper with no firebase-js-sdk equivalent.
+ */
+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 equivalent.
+ */
+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);
+}
+//# sourceMappingURL=modular.js.map