@react-native-firebase/auth 25.1.0 → 26.1.0

package/lib/internal/syncNativeError.ts

@@ -0,0 +1,89 @@
+/*
+ * 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 { isObject } from '@react-native-firebase/app/dist/module/common';
+import NativeFirebaseError from '@react-native-firebase/app/dist/module/internal/NativeFirebaseError';
+import type { NativeError } from '@react-native-firebase/app/dist/module/types/internal';
+
+const INVALID_TOTP_SECRET_CODE = 'invalid-multi-factor-secret';
+const INVALID_TOTP_SECRET_MESSAGE = "can't find secret for provided key";
+
+function hasAuthFirebaseErrorCode(error: unknown): error is { code: string } {
+  return (
+    isObject(error) &&
+    'code' in error &&
+    typeof (error as { code?: unknown }).code === 'string' &&
+    ((error as { code: string }).code.startsWith('auth/') ||
+      (error as { code: string }).code === INVALID_TOTP_SECRET_CODE)
+  );
+}
+
+function getNativeErrorUserInfo(error: unknown): NativeError['userInfo'] | null {
+  if (!isObject(error)) {
+    return null;
+  }
+
+  if ('userInfo' in error && isObject((error as NativeError).userInfo)) {
+    return (error as NativeError).userInfo;
+  }
+
+  if ('code' in error && 'message' in error) {
+    const code = (error as { code?: unknown }).code;
+    const message = (error as { message?: unknown }).message;
+    if (typeof code === 'string' && typeof message === 'string') {
+      return { code, message };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Converts sync native TurboModule throws into {@link NativeFirebaseError} using the same
+ * {@code code}/{@code message} shape as promise rejects.
+ */
+export function rethrowAuthSyncNativeError(error: unknown): never {
+  if (error instanceof NativeFirebaseError) {
+    throw error;
+  }
+
+  if (hasAuthFirebaseErrorCode(error)) {
+    throw error;
+  }
+
+  const userInfo = getNativeErrorUserInfo(error);
+  if (userInfo?.code && userInfo.message) {
+    throw new NativeFirebaseError({ userInfo }, new Error().stack!, 'auth');
+  }
+
+  const message = error instanceof Error ? error.message : String(error);
+  const name = error instanceof Error ? error.name : undefined;
+
+  if (message === INVALID_TOTP_SECRET_MESSAGE || name === INVALID_TOTP_SECRET_CODE) {
+    throw new NativeFirebaseError(
+      {
+        userInfo: {
+          code: INVALID_TOTP_SECRET_CODE,
+          message: INVALID_TOTP_SECRET_MESSAGE,
+        },
+      },
+      new Error().stack!,
+      'auth',
+    );
+  }
+
+  throw error;
+}

package/lib/multiFactor.ts

@@ -1,27 +1,35 @@
-import { reload } from './modular';
 import type { MultiFactorAssertion as ModularMultiFactorAssertion, User } from './types/auth';
-import type { FirebaseAuthTypes } from './types/namespaced';
-import type { AuthInternal, MultiFactorEnrollmentAssertionInternal } from './types/internal';
+import type {
+  MultiFactorInfo,
+  MultiFactorSession,
+  MultiFactorUser as MultiFactorUserType,
+  MultiFactorAssertion,
+} from './types/auth';
+import type {
+  AuthInternal,
+  MultiFactorEnrollmentAssertionInternal,
+  UserInternal,
+} from './types/internal';
 
 type MultiFactorAuthHost = {
-  currentUser: FirebaseAuthTypes.User | null;
+  currentUser: User | null;
   native: AuthInternal['native'];
 };
 /**
  * Return a MultiFactorUser instance the gateway to multi-factor operations.
  */
-export function multiFactor(auth: MultiFactorAuthHost): FirebaseAuthTypes.MultiFactorUser {
+export function multiFactor(auth: MultiFactorAuthHost): MultiFactorUserType {
   return new MultiFactorUser(auth);
 }
 
 export class MultiFactorUser {
-  readonly enrolledFactors: FirebaseAuthTypes.MultiFactorInfo[];
+  readonly enrolledFactors: MultiFactorInfo[];
   private readonly _auth: MultiFactorAuthHost;
 
-  constructor(auth: MultiFactorAuthHost, user?: FirebaseAuthTypes.User) {
+  constructor(auth: MultiFactorAuthHost, user?: User) {
     this._auth = auth;
     if (user === undefined) {
-      user = auth.currentUser as FirebaseAuthTypes.User;
+      user = auth.currentUser as User;
     }
 
     if (!user) {
@@ -31,7 +39,7 @@ export class MultiFactorUser {
     this.enrolledFactors = user.multiFactor?.enrolledFactors ?? [];
   }
 
-  getSession(): Promise<FirebaseAuthTypes.MultiFactorSession> {
+  getSession(): Promise<MultiFactorSession> {
     return this._auth.native.getSession();
   }
 
@@ -41,7 +49,7 @@ export class MultiFactorUser {
    * profile, which is necessary to see the multi-factor changes.
    */
   async enroll(
-    multiFactorAssertion: FirebaseAuthTypes.MultiFactorAssertion | ModularMultiFactorAssertion,
+    multiFactorAssertion: MultiFactorAssertion | ModularMultiFactorAssertion,
     displayName?: string | null,
   ): Promise<void> {
     const assertion = multiFactorAssertion as MultiFactorEnrollmentAssertionInternal;
@@ -65,16 +73,17 @@ export class MultiFactorUser {
 
     // We need to reload the user otherwise the changes are not visible
     // TODO reload not working on Other platform
-    await reload(this._auth.currentUser as unknown as User);
+    const currentUser = this._auth.currentUser as UserInternal | null;
+    if (currentUser) {
+      await currentUser.reload();
+    }
   }
 
-  async unenroll(enrollmentId: FirebaseAuthTypes.MultiFactorInfo | string): Promise<void> {
-    await this._auth.native.unenrollMultiFactor(
-      enrollmentId as string | FirebaseAuthTypes.MultiFactorInfo,
-    );
+  async unenroll(enrollmentId: MultiFactorInfo | string): Promise<void> {
+    await this._auth.native.unenrollMultiFactor(enrollmentId as string | MultiFactorInfo);
 
     if (this._auth.currentUser) {
-      await reload(this._auth.currentUser as unknown as User);
+      await (this._auth.currentUser as UserInternal).reload();
     }
   }
 }

package/lib/providers/AppleAuthProvider.ts

@@ -15,8 +15,8 @@
  *
  */
 
-import { AuthCredential } from '../credentials';
-import type { AuthCredential as AuthCredentialType } from '../types/auth';
+import { OAuthCredential } from '../credentials';
+import type { AppleFullPersonName } from '../types/auth';
 
 const providerId = 'apple.com' as const;
 
@@ -26,7 +26,7 @@ const providerId = 'apple.com' as const;
  * @example
  * ```js
  * const provider = new OAuthProvider('apple.com');
- * const credential = provider.credential({ idToken, rawNonce });
+ * const credential = provider.credential({ idToken, rawNonce, fullName });
  * ```
  */
 export default class AppleAuthProvider {
@@ -38,7 +38,23 @@ export default class AppleAuthProvider {
     return providerId;
   }
 
-  static credential(token: string, secret?: string): AuthCredentialType {
-    return new AuthCredential(providerId, providerId, token, secret ?? '');
+  /**
+   * @param token The Apple identity token.
+   * @param secret The raw nonce used to obtain the identity token.
+   * @param fullName The user's full name, as shared by Sign in with Apple on the user's first
+   * authorization. See {@link OAuthCredentialOptions.fullName} for platform support.
+   */
+  static credential(
+    token: string,
+    secret?: string,
+    fullName?: AppleFullPersonName,
+  ): OAuthCredential {
+    return new OAuthCredential(providerId, {
+      idToken: token,
+      rawNonce: secret,
+      fullName,
+      bridgeToken: token,
+      bridgeSecret: secret ?? '',
+    });
   }
 }

package/lib/providers/OAuthProvider.ts

@@ -94,6 +94,7 @@ export default class OAuthProvider {
       idToken: credential.idToken,
       accessToken: credential.accessToken,
       rawNonce: credential.rawNonce ?? credential.nonce,
+      fullName: credential.fullName,
     });
   }
 
@@ -112,6 +113,7 @@ export default class OAuthProvider {
       idToken: params.idToken,
       accessToken: params.accessToken,
       rawNonce: params.rawNonce,
+      fullName: params.fullName,
     });
   }
 

package/lib/providers/PhoneAuthProvider.ts

@@ -16,6 +16,7 @@
  */
 
 import { createPhoneAuthCredential } from '../credentials';
+import type { AuthInternal } from '../types/internal';
 import type {
   ApplicationVerifier,
   Auth,
@@ -35,20 +36,7 @@ type FirebaseError = AuthError;
 
 const providerId = 'phone' as const;
 
-type PhoneAuthProviderAuth = {
-  app: {
-    auth(): {
-      verifyPhoneNumber(phoneNumber: string): PhoneAuthListener;
-      verifyPhoneNumberWithMultiFactorInfo(
-        hint: Pick<MultiFactorInfo, 'uid'>,
-        session: PhoneMultiFactorSignInInfoOptions['session'],
-      ): Promise<string>;
-      verifyPhoneNumberForMultiFactor(
-        phoneInfoOptions: PhoneMultiFactorEnrollInfoOptions,
-      ): Promise<string>;
-    };
-  };
-};
+type PhoneAuthProviderAuth = AuthInternal;
 
 function isPhoneMultiFactorSignInOptions(
   phoneInfoOptions: PhoneInfoOptions,
@@ -131,7 +119,7 @@ export default class PhoneAuthProvider {
     _appVerifier?: ApplicationVerifier,
   ): Promise<string> {
     if (typeof phoneInfoOptions === 'string') {
-      return verificationIdFromListener(this._auth.app.auth().verifyPhoneNumber(phoneInfoOptions));
+      return verificationIdFromListener(this._auth.verifyPhoneNumber(phoneInfoOptions));
     }
 
     if (isPhoneMultiFactorSignInOptions(phoneInfoOptions)) {
@@ -139,19 +127,18 @@ export default class PhoneAuthProvider {
         uid: phoneInfoOptions.multiFactorUid!,
       };
 
-      return this._auth.app
-        .auth()
-        .verifyPhoneNumberWithMultiFactorInfo(multiFactorHint, phoneInfoOptions.session);
+      return this._auth.verifyPhoneNumberWithMultiFactorInfo(
+        multiFactorHint as MultiFactorInfo,
+        phoneInfoOptions.session,
+      );
     }
 
     if (isPhoneMultiFactorEnrollOptions(phoneInfoOptions)) {
-      return this._auth.app.auth().verifyPhoneNumberForMultiFactor(phoneInfoOptions);
+      return this._auth.verifyPhoneNumberForMultiFactor(phoneInfoOptions);
     }
 
     if (isPhoneSingleFactorOptions(phoneInfoOptions)) {
-      return verificationIdFromListener(
-        this._auth.app.auth().verifyPhoneNumber(phoneInfoOptions.phoneNumber),
-      );
+      return verificationIdFromListener(this._auth.verifyPhoneNumber(phoneInfoOptions.phoneNumber));
     }
 
     throw new Error(

package/lib/types/auth.ts

@@ -169,10 +169,37 @@ export interface ApplicationVerifier {
 
 export type CustomParameters = Record<string, string>;
 
+/**
+ * The user's full name, as shared by Sign in with Apple.
+ *
+ * Apple only shares this data on the user's first authorization for a given app; it is
+ * omitted from the `ASAuthorizationAppleIDCredential` on subsequent sign-ins, so it should be
+ * captured and forwarded on the first sign-in.
+ */
+export interface AppleFullPersonName {
+  namePrefix?: string | null;
+  givenName?: string | null;
+  middleName?: string | null;
+  familyName?: string | null;
+  nameSuffix?: string | null;
+  nickname?: string | null;
+}
+
 export interface OAuthCredentialOptions {
   idToken?: string;
   accessToken?: string;
   rawNonce?: string;
+  /**
+   * The user's full name, as shared by Sign in with Apple on the user's first authorization.
+   *
+   * @remarks Only retained for `apple.com` credentials with at least one non-empty name field,
+   * and only forwarded to the native SDK on iOS, where it is passed to
+   * `FIROAuthProvider.appleCredentialWithIDToken:rawNonce:fullName:` so Firebase can store it as
+   * {@link User.displayName} while creating the account. The Firebase Android SDK has no
+   * equivalent credential-level API; on Android (and Web) this field is ignored and the display
+   * name must be set with {@link updateProfile} after sign-in.
+   */
+  fullName?: AppleFullPersonName;
 }
 
 export interface AuthProvider {
@@ -284,6 +311,8 @@ export interface User extends UserInfo {
   readonly providerData: UserInfo[];
   readonly refreshToken: string;
   readonly tenantId: string | null;
+  /** Present on native user instances returned from auth state listeners. */
+  readonly multiFactor?: MultiFactor | null;
   delete(): Promise<void>;
   getIdToken(forceRefresh?: boolean): Promise<string>;
   getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
@@ -391,3 +420,16 @@ export type PhoneInfoOptions =
 export interface TotpMultiFactorAssertion extends MultiFactorAssertion {}
 
 export interface TotpMultiFactorInfo extends MultiFactorInfo {}
+
+export type AuthListenerCallback = (user: User | null) => void;
+
+export type CallbackOrObserver<T extends (...args: any[]) => any> = T | { next: T };
+
+export interface UpdateProfile {
+  displayName?: string | null;
+  photoURL?: string | null;
+}
+
+export interface MultiFactor {
+  enrolledFactors: MultiFactorInfo[];
+}

package/lib/types/internal.ts

@@ -25,26 +25,23 @@ import type EventEmitter from 'react-native/Libraries/vendor/emitter/EventEmitte
 import type {
   ActionCodeInfo,
   ActionCodeSettings,
+  AdditionalUserInfo,
   Auth,
   AuthCredential,
   AuthProvider,
+  ConfirmationResult,
   IdTokenResult,
+  MultiFactor,
   MultiFactorAssertion,
+  MultiFactorInfo,
+  MultiFactorResolver,
+  MultiFactorSession,
   PhoneAuthListener,
   User,
   UserCredential,
 } from './auth';
-import type { CallbackOrObserver, FirebaseAuthTypes } from './namespaced';
 
-export type AuthModularDeprecationArg = string;
-
-export type WithAuthDeprecationArg<F> = F extends (...args: infer P) => infer R
-  ? (...args: [...P, AuthModularDeprecationArg]) => R
-  : never;
-
-export interface AppWithAuthInternal {
-  auth(deprecationArg?: AuthModularDeprecationArg): Auth;
-}
+export type { CallbackOrObserver } from './auth';
 
 export type AuthListenerCallbackInternal = (user: User | null) => void;
 
@@ -53,14 +50,14 @@ export type AuthProviderWithObjectInternal = AuthProvider & {
 };
 
 export type UserCredentialWithAdditionalUserInfoInternal = UserCredential & {
-  user: FirebaseAuthTypes.User;
-  additionalUserInfo?: FirebaseAuthTypes.AdditionalUserInfo;
+  user: User;
+  additionalUserInfo?: AdditionalUserInfo;
 };
 
-export type UserCredentialResultInternal = FirebaseAuthTypes.UserCredential &
+export type UserCredentialResultInternal = UserCredential &
   Partial<Pick<UserCredential, 'operationType' | 'providerId'>>;
 
-export type ActionCodeInfoResultInternal = FirebaseAuthTypes.ActionCodeInfo | ActionCodeInfo;
+export type ActionCodeInfoResultInternal = ActionCodeInfo;
 
 export type ConfirmationResultResultInternal = {
   verificationId: string | null;
@@ -68,23 +65,18 @@ export type ConfirmationResultResultInternal = {
 };
 
 export type MultiFactorResolverResultInternal = {
-  hints: FirebaseAuthTypes.MultiFactorInfo[];
-  session: FirebaseAuthTypes.MultiFactorSession;
-  resolveSignIn(
-    assertion: FirebaseAuthTypes.MultiFactorAssertion | MultiFactorAssertion,
-  ): Promise<UserCredentialResultInternal>;
+  hints: MultiFactorInfo[];
+  session: MultiFactorSession;
+  resolveSignIn(assertion: MultiFactorAssertion): Promise<UserCredentialResultInternal>;
 };
 
-export type MultiFactorUserSourceInternal = FirebaseAuthTypes.User;
+export type MultiFactorUserSourceInternal = User;
 
 export type MultiFactorUserResultInternal = {
-  enrolledFactors: FirebaseAuthTypes.MultiFactorInfo[];
-  getSession(): Promise<FirebaseAuthTypes.MultiFactorSession>;
-  enroll(
-    assertion: FirebaseAuthTypes.MultiFactorAssertion | MultiFactorAssertion,
-    displayName?: string | null,
-  ): Promise<void>;
-  unenroll(option: FirebaseAuthTypes.MultiFactorInfo | string): Promise<void>;
+  enrolledFactors: MultiFactorInfo[];
+  getSession(): Promise<MultiFactorSession>;
+  enroll(assertion: MultiFactorAssertion, displayName?: string | null): Promise<void>;
+  unenroll(option: MultiFactorInfo | string): Promise<void>;
 };
 
 export type MultiFactorEnrollmentAssertionInternal =
@@ -123,14 +115,14 @@ export interface NativeUserInternal {
   emailVerified?: boolean;
   isAnonymous?: boolean;
   metadata: NativeUserMetadataInternal;
-  multiFactor?: FirebaseAuthTypes.MultiFactor | null;
+  multiFactor?: MultiFactor | null;
   phoneNumber?: string | null;
   photoURL?: string | null;
   tenantId?: string | null;
 }
 
 export interface NativeUserCredentialInternal {
-  additionalUserInfo?: FirebaseAuthTypes.AdditionalUserInfo;
+  additionalUserInfo?: AdditionalUserInfo;
   user: NativeUserInternal;
 }
 
@@ -247,21 +239,18 @@ export interface RNFBAuthModule {
     timeout?: number,
     forceResend?: boolean,
   ): void | Promise<void>;
-  verifyPhoneNumberWithMultiFactorInfo(
-    uid: string,
-    session: FirebaseAuthTypes.MultiFactorSession,
-  ): Promise<string>;
+  verifyPhoneNumberWithMultiFactorInfo(uid: string, session: MultiFactorSession): Promise<string>;
   verifyPhoneNumberForMultiFactor(
     phoneNumber: string,
-    session: FirebaseAuthTypes.MultiFactorSession,
+    session: MultiFactorSession,
   ): Promise<string>;
   resolveMultiFactorSignIn(
-    session: FirebaseAuthTypes.MultiFactorSession,
+    session: MultiFactorSession,
     verificationId: string,
     verificationCode: string,
   ): Promise<NativeUserCredentialInternal>;
   resolveTotpSignIn(
-    session: FirebaseAuthTypes.MultiFactorSession,
+    session: MultiFactorSession,
     uid: string,
     totpSecret: string,
   ): Promise<NativeUserCredentialInternal>;
@@ -278,21 +267,20 @@ export interface RNFBAuthModule {
     providerId: string,
     token: string,
     secret?: string | null,
+    // Sign in with Apple full name (iOS only; see AppleFullPersonName in ./auth.ts).
+    fullName?: Record<string, unknown> | null,
   ): Promise<NativeUserCredentialInternal>;
   revokeToken(authorizationCode: string): Promise<void>;
   sendPasswordResetEmail(
     email: string,
-    actionCodeSettings?: FirebaseAuthTypes.ActionCodeSettings | null,
-  ): Promise<void>;
-  sendSignInLinkToEmail(
-    email: string,
-    actionCodeSettings?: FirebaseAuthTypes.ActionCodeSettings,
+    actionCodeSettings?: ActionCodeSettings | null,
   ): Promise<void>;
-  isSignInWithEmailLink(emailLink: string): Promise<boolean>;
+  sendSignInLinkToEmail(email: string, actionCodeSettings?: ActionCodeSettings): Promise<void>;
+  isSignInWithEmailLink(emailLink: string): boolean;
   signInWithEmailLink(email: string, emailLink?: string): Promise<NativeUserCredentialInternal>;
   confirmPasswordReset(code: string, newPassword: string): Promise<void>;
   applyActionCode(code: string): Promise<NativeUserInternal | null | undefined>;
-  checkActionCode(code: string): Promise<FirebaseAuthTypes.ActionCodeInfo>;
+  checkActionCode(code: string): Promise<ActionCodeInfo>;
   fetchSignInMethodsForEmail(email: string): Promise<string[]>;
   verifyPasswordResetCode(code: string): Promise<string>;
   useUserAccessGroup(userAccessGroup: string): Promise<null | void>;
@@ -300,7 +288,7 @@ export interface RNFBAuthModule {
   useEmulator(host: string, port?: number): void;
   getCustomAuthDomain(): Promise<string>;
   confirmationResultConfirm(verificationCode: string): Promise<NativeUserCredentialInternal>;
-  delete(): Promise<void>;
+  deleteUser(): Promise<void>;
   getIdToken(forceRefresh: boolean): Promise<string>;
   getIdTokenResult(forceRefresh: boolean): Promise<IdTokenResult>;
   linkWithCredential(
@@ -318,9 +306,7 @@ export interface RNFBAuthModule {
     provider: Record<string, unknown>,
   ): Promise<NativeUserCredentialInternal>;
   reload(): Promise<NativeUserInternal>;
-  sendEmailVerification(
-    actionCodeSettings?: FirebaseAuthTypes.ActionCodeSettings,
-  ): Promise<NativeUserInternal>;
+  sendEmailVerification(actionCodeSettings?: ActionCodeSettings): Promise<NativeUserInternal>;
   unlink(providerId: string): Promise<NativeUserInternal>;
   updateEmail(email: string): Promise<NativeUserInternal>;
   updatePassword(password: string): Promise<NativeUserInternal>;
@@ -335,22 +321,22 @@ export interface RNFBAuthModule {
   }): Promise<NativeUserInternal>;
   verifyBeforeUpdateEmail(
     newEmail: string,
-    actionCodeSettings?: FirebaseAuthTypes.ActionCodeSettings,
+    actionCodeSettings?: ActionCodeSettings,
   ): Promise<NativeUserInternal>;
   forceRecaptchaFlowForTesting(forceRecaptchaFlow: boolean): void | Promise<void>;
   setAppVerificationDisabledForTesting(disabled: boolean): void | Promise<void>;
   setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber: string, smsCode: string): Promise<null>;
-  getSession(): Promise<FirebaseAuthTypes.MultiFactorSession>;
+  getSession(): Promise<MultiFactorSession>;
   finalizeMultiFactorEnrollment(token: string, secret: string, displayName?: string): Promise<void>;
   finalizeTotpEnrollment(
     totpSecret: string,
     verificationCode: string,
     displayName?: string,
   ): Promise<void>;
-  unenrollMultiFactor(enrollmentId: string | FirebaseAuthTypes.MultiFactorInfo): Promise<void>;
+  unenrollMultiFactor(enrollmentId: string | MultiFactorInfo): Promise<void>;
   getMultiFactorResolver(error: unknown): MultiFactorResolverResultInternal | null;
-  generateTotpSecret(session: FirebaseAuthTypes.MultiFactorSession): Promise<{ secretKey: string }>;
-  generateQrCodeUrl(secretKey: string, accountName: string, issuer: string): Promise<string>;
+  generateTotpSecret(session: MultiFactorSession): Promise<{ secretKey: string }>;
+  generateQrCodeUrl(secretKey: string, accountName: string, issuer: string): string;
   openInOtpApp(secretKey: string, qrCodeUrl: string): string | void;
   assertionForSignIn(
     uid: string,
@@ -360,7 +346,7 @@ export interface RNFBAuthModule {
 
 export type AuthInternal = Auth & {
   app: ReactNativeFirebase.FirebaseApp;
-  currentUser: FirebaseAuthTypes.User | null;
+  currentUser: User | null;
   applyActionCode(code: string): Promise<void>;
   checkActionCode(code: string): Promise<ActionCodeInfoResultInternal>;
   confirmPasswordReset(code: string, newPassword: string): Promise<void>;
@@ -371,12 +357,12 @@ export type AuthInternal = Auth & {
   fetchSignInMethodsForEmail(email: string): Promise<string[]>;
   getCustomAuthDomain(): Promise<string>;
   getMultiFactorResolver(error: unknown): MultiFactorResolverResultInternal | null;
-  isSignInWithEmailLink(emailLink: string): Promise<boolean>;
+  isSignInWithEmailLink(emailLink: string): boolean;
   onAuthStateChanged(
-    listenerOrObserver: CallbackOrObserver<AuthListenerCallbackInternal>,
+    listenerOrObserver: import('./auth').CallbackOrObserver<AuthListenerCallbackInternal>,
   ): () => void;
   onIdTokenChanged(
-    listenerOrObserver: CallbackOrObserver<AuthListenerCallbackInternal>,
+    listenerOrObserver: import('./auth').CallbackOrObserver<AuthListenerCallbackInternal>,
   ): () => void;
   sendPasswordResetEmail(
     email: string,
@@ -415,6 +401,13 @@ export type AuthInternal = Auth & {
     autoVerifyTimeoutOrForceResend?: number | boolean,
     forceResend?: boolean,
   ): PhoneAuthListener;
+  verifyPhoneNumberWithMultiFactorInfo(
+    multiFactorHint: MultiFactorInfo,
+    session: MultiFactorSession,
+  ): Promise<string>;
+  verifyPhoneNumberForMultiFactor(
+    phoneInfoOptions: import('./auth').PhoneMultiFactorEnrollInfoOptions,
+  ): Promise<string>;
   verifyPasswordResetCode(code: string): Promise<string>;
   revokeToken(authorizationCode: string): Promise<void>;
   native: RNFBAuthModule;
@@ -424,23 +417,23 @@ export type AuthInternal = Auth & {
   _tenantId: string | null;
   _projectPasswordPolicy: PasswordPolicyInternal | null;
   _tenantPasswordPolicies: Record<string, PasswordPolicyInternal | null>;
-  _setUser(user?: NativeUserInternal | null): FirebaseAuthTypes.User | null;
+  _setUser(user?: NativeUserInternal | null): User | null;
   _setUserCredential(
     userCredential: NativeUserCredentialInternal,
   ): UserCredentialWithAdditionalUserInfoInternal;
   resolveMultiFactorSignIn(
-    session: FirebaseAuthTypes.MultiFactorSession,
+    session: MultiFactorSession,
     verificationId: string,
     verificationCode: string,
   ): Promise<UserCredentialWithAdditionalUserInfoInternal>;
   resolveTotpSignIn(
-    session: FirebaseAuthTypes.MultiFactorSession,
+    session: MultiFactorSession,
     uid: string,
     totpSecret: string,
   ): Promise<UserCredentialWithAdditionalUserInfoInternal>;
 } & PasswordPolicyMixinInternal;
 
-export type UserInternal = FirebaseAuthTypes.User & {
+export type UserInternal = User & {
   _auth?: AuthInternal;
   _user?: NativeUserInternal;
   getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
@@ -469,11 +462,11 @@ export type UserInternal = FirebaseAuthTypes.User & {
   verifyBeforeUpdateEmail(newEmail: string, actionCodeSettings?: ActionCodeSettings): Promise<void>;
 };
 
-export type ConfirmationResultInternal = FirebaseAuthTypes.ConfirmationResult;
-export type MultiFactorResolverInternal = FirebaseAuthTypes.MultiFactorResolver;
+export type ConfirmationResultInternal = ConfirmationResult;
+export type MultiFactorResolverInternal = MultiFactorResolver;
 
 declare module '@react-native-firebase/app/dist/module/internal/NativeModules' {
   interface ReactNativeFirebaseNativeModules {
-    RNFBAuthModule: RNFBAuthModule;
+    NativeRNFBTurboAuth: RNFBAuthModule;
   }
 }

package/lib/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '25.1.0';
+export const version = '26.1.0';