@react-native-firebase/auth 25.0.1 → 26.0.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,30 +1,35 @@
-import { reload } from './modular';
+import type { MultiFactorAssertion as ModularMultiFactorAssertion, User } from './types/auth';
 import type {
-  MultiFactorAssertion as ModularMultiFactorAssertion,
-  User,
+  MultiFactorInfo,
+  MultiFactorSession,
+  MultiFactorUser as MultiFactorUserType,
+  MultiFactorAssertion,
 } from './types/auth';
-import type { FirebaseAuthTypes } from './types/namespaced';
-import type { AuthInternal, MultiFactorEnrollmentAssertionInternal } from './types/internal';
+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) {
@@ -34,7 +39,7 @@ export class MultiFactorUser {
     this.enrolledFactors = user.multiFactor?.enrolledFactors ?? [];
   }
 
-  getSession(): Promise<FirebaseAuthTypes.MultiFactorSession> {
+  getSession(): Promise<MultiFactorSession> {
     return this._auth.native.getSession();
   }
 
@@ -44,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;
@@ -68,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/OIDCAuthProvider.ts

@@ -38,11 +38,7 @@ export default class OIDCAuthProvider {
     return providerId;
   }
 
-  static credential(
-    oidcSuffix: string,
-    idToken: string,
-    accessToken?: string,
-  ): AuthCredentialType {
+  static credential(oidcSuffix: string, idToken: string, accessToken?: string): AuthCredentialType {
     const resolvedProviderId = providerId + oidcSuffix;
     return new AuthCredential(resolvedProviderId, resolvedProviderId, idToken, accessToken ?? '');
   }

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

@@ -284,6 +284,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 +393,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>;
@@ -282,17 +271,14 @@ export interface RNFBAuthModule {
   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 +286,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 +304,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>;
@@ -329,27 +313,28 @@ export interface RNFBAuthModule {
     token: string,
     secret?: string | null,
   ): Promise<NativeUserInternal>;
-  updateProfile(
-    updates: { displayName?: string | null; photoURL?: string | null },
-  ): Promise<NativeUserInternal>;
+  updateProfile(updates: {
+    displayName?: string | null;
+    photoURL?: string | null;
+  }): 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,
@@ -359,7 +344,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>;
@@ -370,24 +355,23 @@ 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,
     actionCodeSettings?: ActionCodeSettings | null,
   ): Promise<void>;
-  sendSignInLinkToEmail(
-    email: string,
-    actionCodeSettings?: ActionCodeSettings,
-  ): Promise<void>;
+  sendSignInLinkToEmail(email: string, actionCodeSettings?: ActionCodeSettings): Promise<void>;
   setLanguageCode(code: string | null): Promise<void>;
   signInAnonymously(): Promise<UserCredentialWithAdditionalUserInfoInternal>;
-  signInWithCredential(credential: AuthCredential): Promise<UserCredentialWithAdditionalUserInfoInternal>;
+  signInWithCredential(
+    credential: AuthCredential,
+  ): Promise<UserCredentialWithAdditionalUserInfoInternal>;
   signInWithCustomToken(customToken: string): Promise<UserCredentialWithAdditionalUserInfoInternal>;
   signInWithEmailAndPassword(
     email: string,
@@ -415,6 +399,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,28 +415,32 @@ 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>;
-  linkWithCredential(credential: AuthCredential): Promise<UserCredentialWithAdditionalUserInfoInternal>;
-  linkWithPopup(provider: AuthProviderWithObjectInternal): Promise<UserCredentialWithAdditionalUserInfoInternal>;
+  linkWithCredential(
+    credential: AuthCredential,
+  ): Promise<UserCredentialWithAdditionalUserInfoInternal>;
+  linkWithPopup(
+    provider: AuthProviderWithObjectInternal,
+  ): Promise<UserCredentialWithAdditionalUserInfoInternal>;
   linkWithRedirect(
     provider: AuthProviderWithObjectInternal,
   ): Promise<UserCredentialWithAdditionalUserInfoInternal>;
@@ -465,11 +460,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.0.1';
+export const version = '26.0.0';

package/lib/web/RNFBAuthModule.ts

@@ -583,13 +583,15 @@ export default {
    * Check if a sign in with email link is valid
    * @param {string} appName - The name of the app to get the auth instance for.
    * @param {string} emailLink - The email link to sign in with.
-   * @returns {Promise<boolean>} - Whether the link is a valid sign in with email link.
+   * @returns {boolean} - Whether the link is a valid sign in with email link.
    */
-  async isSignInWithEmailLink(appName: string, emailLink: string) {
-    return guard(async () => {
+  isSignInWithEmailLink(appName: string, emailLink: string) {
+    try {
       const auth = getCachedAuthInstance(appName);
-      return await isSignInWithEmailLink(auth, emailLink);
-    });
+      return isSignInWithEmailLink(auth, emailLink);
+    } catch (e) {
+      throw getWebError(e as Error & { code?: string });
+    }
   },
 
   /**
@@ -667,7 +669,7 @@ export default {
    * @param {string} appName - The name of the app to get the auth instance for.
    * @returns {Promise<null>}
    */
-  async delete(appName: string) {
+  async deleteUser(appName: string) {
     return guard(async () => {
       const auth = getCachedAuthInstance(appName);
 
@@ -1254,10 +1256,11 @@ export default {
   generateQrCodeUrl(_appName: string, secretKey: string, accountName?: string, issuer?: string) {
     const totpSecret = totpSecretMap.get(secretKey);
     if (!totpSecret) {
-      return rejectPromiseWithCodeAndMessage(
-        'invalid-multi-factor-secret',
-        "can't find secret for provided key",
-      );
+      throw getWebError({
+        name: 'FirebaseError',
+        code: 'auth/invalid-multi-factor-secret',
+        message: "can't find secret for provided key",
+      });
     }
     return totpSecret.generateQrCodeUrl(accountName, issuer);
   },