@firebase/auth-types

  • Version 0.11.0
  • Published
  • 16.4 kB
  • No dependencies
  • Apache-2.0 license

Install

npm i @firebase/auth-types
yarn add @firebase/auth-types
pnpm add @firebase/auth-types

Overview

@firebase/auth Types

Index

Classes

Interfaces

Type Aliases

Classes

class ActionCodeInfo

class ActionCodeInfo {}

    property data

    data: {
    email?: string | null;
    fromEmail?: string | null;
    multiFactorInfo?: MultiFactorInfo | null;
    previousEmail?: string | null;
    };

      property operation

      operation: string;

        property Operation

        static Operation: {
        PASSWORD_RESET: Operation;
        RECOVER_EMAIL: Operation;
        EMAIL_SIGNIN: Operation;
        REVERT_SECOND_FACTOR_ADDITION: Operation;
        VERIFY_AND_CHANGE_EMAIL: Operation;
        VERIFY_EMAIL: Operation;
        };

          class ActionCodeURL

          class ActionCodeURL {}

            property apiKey

            apiKey: string;

              property code

              code: string;

                property continueUrl

                continueUrl: string;

                  property languageCode

                  languageCode: string;

                    property operation

                    operation: string;

                      property tenantId

                      tenantId: string;
                        static parseLink: (link: string) => ActionCodeURL | null;

                          class AuthCredential

                          abstract class AuthCredential {}

                            property providerId

                            providerId: string;

                              property signInMethod

                              signInMethod: string;

                                method fromJSON

                                static fromJSON: (json: Object | string) => AuthCredential | null;

                                  method toJSON

                                  toJSON: () => Object;

                                    class EmailAuthProvider

                                    class EmailAuthProvider extends EmailAuthProvider_Instance {}
                                      static EMAIL_LINK_SIGN_IN_METHOD: string;

                                        property EMAIL_PASSWORD_SIGN_IN_METHOD

                                        static EMAIL_PASSWORD_SIGN_IN_METHOD: string;

                                          property PROVIDER_ID

                                          static PROVIDER_ID: string;

                                            method credential

                                            static credential: (email: string, password: string) => AuthCredential;
                                              static credentialWithLink: (email: string, emailLink: string) => AuthCredential;

                                                class EmailAuthProvider_Instance

                                                class EmailAuthProvider_Instance implements AuthProvider {}

                                                  property providerId

                                                  providerId: string;

                                                    class FacebookAuthProvider

                                                    class FacebookAuthProvider extends FacebookAuthProvider_Instance {}

                                                      property FACEBOOK_SIGN_IN_METHOD

                                                      static FACEBOOK_SIGN_IN_METHOD: string;

                                                        property PROVIDER_ID

                                                        static PROVIDER_ID: string;

                                                          method credential

                                                          static credential: (token: string) => AuthCredential;

                                                            class FacebookAuthProvider_Instance

                                                            class FacebookAuthProvider_Instance implements AuthProvider {}

                                                              property providerId

                                                              providerId: string;

                                                                method addScope

                                                                addScope: (scope: string) => AuthProvider;

                                                                  method setCustomParameters

                                                                  setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

                                                                    class FirebaseAuth

                                                                    class FirebaseAuth {}

                                                                      property app

                                                                      app: any;

                                                                        property currentUser

                                                                        currentUser: User;

                                                                          property emulatorConfig

                                                                          readonly emulatorConfig: EmulatorConfig;

                                                                            property languageCode

                                                                            languageCode: string;

                                                                              property Persistence

                                                                              static Persistence: {
                                                                              LOCAL: Persistence;
                                                                              NONE: Persistence;
                                                                              SESSION: Persistence;
                                                                              };

                                                                                property settings

                                                                                settings: AuthSettings;

                                                                                  property tenantId

                                                                                  tenantId: string;

                                                                                    method applyActionCode

                                                                                    applyActionCode: (code: string) => Promise<void>;

                                                                                      method checkActionCode

                                                                                      checkActionCode: (code: string) => Promise<ActionCodeInfo>;

                                                                                        method confirmPasswordReset

                                                                                        confirmPasswordReset: (code: string, newPassword: string) => Promise<void>;

                                                                                          method createUserWithEmailAndPassword

                                                                                          createUserWithEmailAndPassword: (
                                                                                          email: string,
                                                                                          password: string
                                                                                          ) => Promise<UserCredential>;

                                                                                            method fetchSignInMethodsForEmail

                                                                                            fetchSignInMethodsForEmail: (email: string) => Promise<Array<string>>;

                                                                                              method getRedirectResult

                                                                                              getRedirectResult: () => Promise<UserCredential>;
                                                                                                isSignInWithEmailLink: (emailLink: string) => boolean;

                                                                                                  method onAuthStateChanged

                                                                                                  onAuthStateChanged: (
                                                                                                  nextOrObserver: any,
                                                                                                  error?: (a: Error) => any,
                                                                                                  completed?: any
                                                                                                  ) => any;

                                                                                                    method onIdTokenChanged

                                                                                                    onIdTokenChanged: (
                                                                                                    nextOrObserver: any,
                                                                                                    error?: (a: Error) => any,
                                                                                                    completed?: any
                                                                                                    ) => any;

                                                                                                      method sendPasswordResetEmail

                                                                                                      sendPasswordResetEmail: (
                                                                                                      email: string,
                                                                                                      actionCodeSettings?: ActionCodeSettings | null
                                                                                                      ) => Promise<void>;

                                                                                                        method sendSignInLinkToEmail

                                                                                                        sendSignInLinkToEmail: (
                                                                                                        email: string,
                                                                                                        actionCodeSettings: ActionCodeSettings
                                                                                                        ) => Promise<void>;

                                                                                                          method setPersistence

                                                                                                          setPersistence: (persistence: Persistence) => Promise<void>;

                                                                                                            method signInAndRetrieveDataWithCredential

                                                                                                            signInAndRetrieveDataWithCredential: (
                                                                                                            credential: AuthCredential
                                                                                                            ) => Promise<UserCredential>;

                                                                                                              method signInAnonymously

                                                                                                              signInAnonymously: () => Promise<UserCredential>;

                                                                                                                method signInWithCredential

                                                                                                                signInWithCredential: (credential: AuthCredential) => Promise<UserCredential>;

                                                                                                                  method signInWithCustomToken

                                                                                                                  signInWithCustomToken: (token: string) => Promise<UserCredential>;

                                                                                                                    method signInWithEmailAndPassword

                                                                                                                    signInWithEmailAndPassword: (
                                                                                                                    email: string,
                                                                                                                    password: string
                                                                                                                    ) => Promise<UserCredential>;
                                                                                                                      signInWithEmailLink: (
                                                                                                                      email: string,
                                                                                                                      emailLink?: string
                                                                                                                      ) => Promise<UserCredential>;

                                                                                                                        method signInWithPhoneNumber

                                                                                                                        signInWithPhoneNumber: (
                                                                                                                        phoneNumber: string,
                                                                                                                        applicationVerifier: ApplicationVerifier
                                                                                                                        ) => Promise<ConfirmationResult>;

                                                                                                                          method signInWithPopup

                                                                                                                          signInWithPopup: (provider: AuthProvider) => Promise<UserCredential>;

                                                                                                                            method signInWithRedirect

                                                                                                                            signInWithRedirect: (provider: AuthProvider) => Promise<void>;

                                                                                                                              method signOut

                                                                                                                              signOut: () => Promise<void>;

                                                                                                                                method updateCurrentUser

                                                                                                                                updateCurrentUser: (user: User | null) => Promise<void>;

                                                                                                                                  method useDeviceLanguage

                                                                                                                                  useDeviceLanguage: () => void;

                                                                                                                                    method useEmulator

                                                                                                                                    useEmulator: (url: string, options?: { disableWarnings?: boolean }) => void;

                                                                                                                                      method verifyPasswordResetCode

                                                                                                                                      verifyPasswordResetCode: (code: string) => Promise<string>;

                                                                                                                                        class GithubAuthProvider

                                                                                                                                        class GithubAuthProvider extends GithubAuthProvider_Instance {}

                                                                                                                                          property GITHUB_SIGN_IN_METHOD

                                                                                                                                          static GITHUB_SIGN_IN_METHOD: string;

                                                                                                                                            property PROVIDER_ID

                                                                                                                                            static PROVIDER_ID: string;

                                                                                                                                              method credential

                                                                                                                                              static credential: (token: string) => AuthCredential;

                                                                                                                                                class GithubAuthProvider_Instance

                                                                                                                                                class GithubAuthProvider_Instance implements AuthProvider {}

                                                                                                                                                  property providerId

                                                                                                                                                  providerId: string;

                                                                                                                                                    method addScope

                                                                                                                                                    addScope: (scope: string) => AuthProvider;

                                                                                                                                                      method setCustomParameters

                                                                                                                                                      setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

                                                                                                                                                        class GoogleAuthProvider

                                                                                                                                                        class GoogleAuthProvider extends GoogleAuthProvider_Instance {}

                                                                                                                                                          property GOOGLE_SIGN_IN_METHOD

                                                                                                                                                          static GOOGLE_SIGN_IN_METHOD: string;

                                                                                                                                                            property PROVIDER_ID

                                                                                                                                                            static PROVIDER_ID: string;

                                                                                                                                                              method credential

                                                                                                                                                              static credential: (
                                                                                                                                                              idToken?: string | null,
                                                                                                                                                              accessToken?: string | null
                                                                                                                                                              ) => AuthCredential;

                                                                                                                                                                class GoogleAuthProvider_Instance

                                                                                                                                                                class GoogleAuthProvider_Instance implements AuthProvider {}

                                                                                                                                                                  property providerId

                                                                                                                                                                  providerId: string;

                                                                                                                                                                    method addScope

                                                                                                                                                                    addScope: (scope: string) => AuthProvider;

                                                                                                                                                                      method setCustomParameters

                                                                                                                                                                      setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

                                                                                                                                                                        class MultiFactorAssertion

                                                                                                                                                                        abstract class MultiFactorAssertion {}

                                                                                                                                                                          property factorId

                                                                                                                                                                          factorId: string;

                                                                                                                                                                            class MultiFactorResolver

                                                                                                                                                                            class MultiFactorResolver {}

                                                                                                                                                                              property auth

                                                                                                                                                                              auth: FirebaseAuth;

                                                                                                                                                                                property hints

                                                                                                                                                                                hints: MultiFactorInfo[];

                                                                                                                                                                                  property session

                                                                                                                                                                                  session: MultiFactorSession;

                                                                                                                                                                                    method resolveSignIn

                                                                                                                                                                                    resolveSignIn: (assertion: MultiFactorAssertion) => Promise<UserCredential>;

                                                                                                                                                                                      class MultiFactorSession

                                                                                                                                                                                      class MultiFactorSession {}

                                                                                                                                                                                        class OAuthCredential

                                                                                                                                                                                        class OAuthCredential extends AuthCredential {}

                                                                                                                                                                                          property accessToken

                                                                                                                                                                                          accessToken?: string;

                                                                                                                                                                                            property idToken

                                                                                                                                                                                            idToken?: string;

                                                                                                                                                                                              property secret

                                                                                                                                                                                              secret?: string;

                                                                                                                                                                                                class OAuthProvider

                                                                                                                                                                                                class OAuthProvider implements AuthProvider {}

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(providerId: string);

                                                                                                                                                                                                    property providerId

                                                                                                                                                                                                    providerId: string;

                                                                                                                                                                                                      method addScope

                                                                                                                                                                                                      addScope: (scope: string) => AuthProvider;

                                                                                                                                                                                                        method credential

                                                                                                                                                                                                        credential: (
                                                                                                                                                                                                        optionsOrIdToken: OAuthCredentialOptions | string | null,
                                                                                                                                                                                                        accessToken?: string
                                                                                                                                                                                                        ) => OAuthCredential;

                                                                                                                                                                                                          method setCustomParameters

                                                                                                                                                                                                          setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

                                                                                                                                                                                                            class PhoneAuthCredential

                                                                                                                                                                                                            class PhoneAuthCredential extends AuthCredential {}

                                                                                                                                                                                                              class PhoneAuthProvider

                                                                                                                                                                                                              class PhoneAuthProvider extends PhoneAuthProvider_Instance {}

                                                                                                                                                                                                                property PHONE_SIGN_IN_METHOD

                                                                                                                                                                                                                static PHONE_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                  property PROVIDER_ID

                                                                                                                                                                                                                  static PROVIDER_ID: string;

                                                                                                                                                                                                                    method credential

                                                                                                                                                                                                                    static credential: (
                                                                                                                                                                                                                    verificationId: string,
                                                                                                                                                                                                                    verificationCode: string
                                                                                                                                                                                                                    ) => AuthCredential;

                                                                                                                                                                                                                      class PhoneAuthProvider_Instance

                                                                                                                                                                                                                      class PhoneAuthProvider_Instance implements AuthProvider {}

                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                        constructor(auth?: FirebaseAuth);

                                                                                                                                                                                                                          property providerId

                                                                                                                                                                                                                          providerId: string;

                                                                                                                                                                                                                            method verifyPhoneNumber

                                                                                                                                                                                                                            verifyPhoneNumber: (
                                                                                                                                                                                                                            phoneInfoOptions: PhoneInfoOptions | string,
                                                                                                                                                                                                                            applicationVerifier: ApplicationVerifier
                                                                                                                                                                                                                            ) => Promise<string>;

                                                                                                                                                                                                                              class PhoneMultiFactorAssertion

                                                                                                                                                                                                                              class PhoneMultiFactorAssertion extends MultiFactorAssertion {}

                                                                                                                                                                                                                                class PhoneMultiFactorGenerator

                                                                                                                                                                                                                                class PhoneMultiFactorGenerator {}

                                                                                                                                                                                                                                  property FACTOR_ID

                                                                                                                                                                                                                                  static FACTOR_ID: string;

                                                                                                                                                                                                                                    method assertion

                                                                                                                                                                                                                                    static assertion: (
                                                                                                                                                                                                                                    phoneAuthCredential: PhoneAuthCredential
                                                                                                                                                                                                                                    ) => PhoneMultiFactorAssertion;

                                                                                                                                                                                                                                      class RecaptchaVerifier

                                                                                                                                                                                                                                      class RecaptchaVerifier extends RecaptchaVerifier_Instance {}

                                                                                                                                                                                                                                        class RecaptchaVerifier_Instance

                                                                                                                                                                                                                                        class RecaptchaVerifier_Instance implements ApplicationVerifier {}

                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                          constructor(container: any, parameters?: Object, app?: any);

                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                              method clear

                                                                                                                                                                                                                                              clear: () => void;

                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                render: () => Promise<number>;

                                                                                                                                                                                                                                                  method verify

                                                                                                                                                                                                                                                  verify: () => Promise<string>;

                                                                                                                                                                                                                                                    class SAMLAuthProvider

                                                                                                                                                                                                                                                    class SAMLAuthProvider implements AuthProvider {}

                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                      constructor(providerId: string);

                                                                                                                                                                                                                                                        property providerId

                                                                                                                                                                                                                                                        providerId: string;

                                                                                                                                                                                                                                                          class TwitterAuthProvider

                                                                                                                                                                                                                                                          class TwitterAuthProvider extends TwitterAuthProvider_Instance {}

                                                                                                                                                                                                                                                            property PROVIDER_ID

                                                                                                                                                                                                                                                            static PROVIDER_ID: string;

                                                                                                                                                                                                                                                              property TWITTER_SIGN_IN_METHOD

                                                                                                                                                                                                                                                              static TWITTER_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                                                method credential

                                                                                                                                                                                                                                                                static credential: (token: string, secret: string) => AuthCredential;

                                                                                                                                                                                                                                                                  class TwitterAuthProvider_Instance

                                                                                                                                                                                                                                                                  class TwitterAuthProvider_Instance implements AuthProvider {}

                                                                                                                                                                                                                                                                    property providerId

                                                                                                                                                                                                                                                                    providerId: string;

                                                                                                                                                                                                                                                                      method setCustomParameters

                                                                                                                                                                                                                                                                      setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

                                                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                                                        interface ApplicationVerifier

                                                                                                                                                                                                                                                                        interface ApplicationVerifier {}

                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                                                                            method verify

                                                                                                                                                                                                                                                                            verify: () => Promise<string>;

                                                                                                                                                                                                                                                                              interface AuthError

                                                                                                                                                                                                                                                                              interface AuthError extends Error {}

                                                                                                                                                                                                                                                                                property credential

                                                                                                                                                                                                                                                                                credential?: AuthCredential;

                                                                                                                                                                                                                                                                                  property email

                                                                                                                                                                                                                                                                                  email?: string;

                                                                                                                                                                                                                                                                                    property phoneNumber

                                                                                                                                                                                                                                                                                    phoneNumber?: string;

                                                                                                                                                                                                                                                                                      property tenantId

                                                                                                                                                                                                                                                                                      tenantId?: string;

                                                                                                                                                                                                                                                                                        interface AuthProvider

                                                                                                                                                                                                                                                                                        interface AuthProvider {}

                                                                                                                                                                                                                                                                                          property providerId

                                                                                                                                                                                                                                                                                          providerId: string;

                                                                                                                                                                                                                                                                                            interface AuthSettings

                                                                                                                                                                                                                                                                                            interface AuthSettings {}

                                                                                                                                                                                                                                                                                              property appVerificationDisabledForTesting

                                                                                                                                                                                                                                                                                              appVerificationDisabledForTesting: boolean;

                                                                                                                                                                                                                                                                                                interface ConfirmationResult

                                                                                                                                                                                                                                                                                                interface ConfirmationResult {}

                                                                                                                                                                                                                                                                                                  property verificationId

                                                                                                                                                                                                                                                                                                  verificationId: string;

                                                                                                                                                                                                                                                                                                    method confirm

                                                                                                                                                                                                                                                                                                    confirm: (verificationCode: string) => Promise<UserCredential>;

                                                                                                                                                                                                                                                                                                      interface EmulatorConfig

                                                                                                                                                                                                                                                                                                      interface EmulatorConfig {}

                                                                                                                                                                                                                                                                                                        property host

                                                                                                                                                                                                                                                                                                        readonly host: string;

                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                          readonly options: {
                                                                                                                                                                                                                                                                                                          readonly disableWarnings: boolean;
                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                            property port

                                                                                                                                                                                                                                                                                                            readonly port: number | null;

                                                                                                                                                                                                                                                                                                              property protocol

                                                                                                                                                                                                                                                                                                              readonly protocol: string;

                                                                                                                                                                                                                                                                                                                interface Error

                                                                                                                                                                                                                                                                                                                interface Error {}

                                                                                                                                                                                                                                                                                                                  property code

                                                                                                                                                                                                                                                                                                                  code: string;

                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                    message: string;

                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                        property stack

                                                                                                                                                                                                                                                                                                                        stack?: string;

                                                                                                                                                                                                                                                                                                                          interface IdTokenResult

                                                                                                                                                                                                                                                                                                                          interface IdTokenResult {}

                                                                                                                                                                                                                                                                                                                            property authTime

                                                                                                                                                                                                                                                                                                                            authTime: string;

                                                                                                                                                                                                                                                                                                                              property claims

                                                                                                                                                                                                                                                                                                                              claims: {
                                                                                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                property expirationTime

                                                                                                                                                                                                                                                                                                                                expirationTime: string;

                                                                                                                                                                                                                                                                                                                                  property issuedAtTime

                                                                                                                                                                                                                                                                                                                                  issuedAtTime: string;

                                                                                                                                                                                                                                                                                                                                    property signInProvider

                                                                                                                                                                                                                                                                                                                                    signInProvider: string | null;

                                                                                                                                                                                                                                                                                                                                      property signInSecondFactor

                                                                                                                                                                                                                                                                                                                                      signInSecondFactor: string | null;

                                                                                                                                                                                                                                                                                                                                        property token

                                                                                                                                                                                                                                                                                                                                        token: string;

                                                                                                                                                                                                                                                                                                                                          interface MultiFactorError

                                                                                                                                                                                                                                                                                                                                          interface MultiFactorError extends AuthError {}

                                                                                                                                                                                                                                                                                                                                            property resolver

                                                                                                                                                                                                                                                                                                                                            resolver: MultiFactorResolver;

                                                                                                                                                                                                                                                                                                                                              interface MultiFactorInfo

                                                                                                                                                                                                                                                                                                                                              interface MultiFactorInfo {}

                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                displayName?: string | null;

                                                                                                                                                                                                                                                                                                                                                  property enrollmentTime

                                                                                                                                                                                                                                                                                                                                                  enrollmentTime: string;

                                                                                                                                                                                                                                                                                                                                                    property factorId

                                                                                                                                                                                                                                                                                                                                                    factorId: string;

                                                                                                                                                                                                                                                                                                                                                      property uid

                                                                                                                                                                                                                                                                                                                                                      uid: string;

                                                                                                                                                                                                                                                                                                                                                        interface MultiFactorUser

                                                                                                                                                                                                                                                                                                                                                        interface MultiFactorUser {}

                                                                                                                                                                                                                                                                                                                                                          property enrolledFactors

                                                                                                                                                                                                                                                                                                                                                          enrolledFactors: MultiFactorInfo[];

                                                                                                                                                                                                                                                                                                                                                            method enroll

                                                                                                                                                                                                                                                                                                                                                            enroll: (
                                                                                                                                                                                                                                                                                                                                                            assertion: MultiFactorAssertion,
                                                                                                                                                                                                                                                                                                                                                            displayName?: string | null
                                                                                                                                                                                                                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                              method getSession

                                                                                                                                                                                                                                                                                                                                                              getSession: () => Promise<MultiFactorSession>;

                                                                                                                                                                                                                                                                                                                                                                method unenroll

                                                                                                                                                                                                                                                                                                                                                                unenroll: (option: MultiFactorInfo | string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                  interface OAuthCredentialOptions

                                                                                                                                                                                                                                                                                                                                                                  interface OAuthCredentialOptions {}

                                                                                                                                                                                                                                                                                                                                                                    property accessToken

                                                                                                                                                                                                                                                                                                                                                                    accessToken?: string;

                                                                                                                                                                                                                                                                                                                                                                      property idToken

                                                                                                                                                                                                                                                                                                                                                                      idToken?: string;

                                                                                                                                                                                                                                                                                                                                                                        property rawNonce

                                                                                                                                                                                                                                                                                                                                                                        rawNonce?: string;

                                                                                                                                                                                                                                                                                                                                                                          interface PhoneMultiFactorEnrollInfoOptions

                                                                                                                                                                                                                                                                                                                                                                          interface PhoneMultiFactorEnrollInfoOptions {}

                                                                                                                                                                                                                                                                                                                                                                            property phoneNumber

                                                                                                                                                                                                                                                                                                                                                                            phoneNumber: string;

                                                                                                                                                                                                                                                                                                                                                                              property session

                                                                                                                                                                                                                                                                                                                                                                              session: MultiFactorSession;

                                                                                                                                                                                                                                                                                                                                                                                interface PhoneMultiFactorInfo

                                                                                                                                                                                                                                                                                                                                                                                interface PhoneMultiFactorInfo extends MultiFactorInfo {}

                                                                                                                                                                                                                                                                                                                                                                                  property phoneNumber

                                                                                                                                                                                                                                                                                                                                                                                  phoneNumber: string;

                                                                                                                                                                                                                                                                                                                                                                                    interface PhoneMultiFactorSignInInfoOptions

                                                                                                                                                                                                                                                                                                                                                                                    interface PhoneMultiFactorSignInInfoOptions {}

                                                                                                                                                                                                                                                                                                                                                                                      property multiFactorHint

                                                                                                                                                                                                                                                                                                                                                                                      multiFactorHint?: MultiFactorInfo;

                                                                                                                                                                                                                                                                                                                                                                                        property multiFactorUid

                                                                                                                                                                                                                                                                                                                                                                                        multiFactorUid?: string;

                                                                                                                                                                                                                                                                                                                                                                                          property session

                                                                                                                                                                                                                                                                                                                                                                                          session: MultiFactorSession;

                                                                                                                                                                                                                                                                                                                                                                                            interface PhoneSingleFactorInfoOptions

                                                                                                                                                                                                                                                                                                                                                                                            interface PhoneSingleFactorInfoOptions {}

                                                                                                                                                                                                                                                                                                                                                                                              property phoneNumber

                                                                                                                                                                                                                                                                                                                                                                                              phoneNumber: string;

                                                                                                                                                                                                                                                                                                                                                                                                interface User

                                                                                                                                                                                                                                                                                                                                                                                                interface User extends UserInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                  property emailVerified

                                                                                                                                                                                                                                                                                                                                                                                                  emailVerified: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                    property isAnonymous

                                                                                                                                                                                                                                                                                                                                                                                                    isAnonymous: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                                                                                                                                      metadata: UserMetadata;

                                                                                                                                                                                                                                                                                                                                                                                                        property multiFactor

                                                                                                                                                                                                                                                                                                                                                                                                        multiFactor: MultiFactorUser;

                                                                                                                                                                                                                                                                                                                                                                                                          property phoneNumber

                                                                                                                                                                                                                                                                                                                                                                                                          phoneNumber: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                            property providerData

                                                                                                                                                                                                                                                                                                                                                                                                            providerData: (UserInfo | null)[];

                                                                                                                                                                                                                                                                                                                                                                                                              property refreshToken

                                                                                                                                                                                                                                                                                                                                                                                                              refreshToken: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property tenantId

                                                                                                                                                                                                                                                                                                                                                                                                                readonly tenantId: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                  method delete

                                                                                                                                                                                                                                                                                                                                                                                                                  delete: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                    method getIdToken

                                                                                                                                                                                                                                                                                                                                                                                                                    getIdToken: (forceRefresh?: boolean) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                      method getIdTokenResult

                                                                                                                                                                                                                                                                                                                                                                                                                      getIdTokenResult: (forceRefresh?: boolean) => Promise<IdTokenResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                        method linkAndRetrieveDataWithCredential

                                                                                                                                                                                                                                                                                                                                                                                                                        linkAndRetrieveDataWithCredential: (
                                                                                                                                                                                                                                                                                                                                                                                                                        credential: AuthCredential
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Promise<UserCredential>;

                                                                                                                                                                                                                                                                                                                                                                                                                          method linkWithCredential

                                                                                                                                                                                                                                                                                                                                                                                                                          linkWithCredential: (credential: AuthCredential) => Promise<UserCredential>;

                                                                                                                                                                                                                                                                                                                                                                                                                            method linkWithPhoneNumber

                                                                                                                                                                                                                                                                                                                                                                                                                            linkWithPhoneNumber: (
                                                                                                                                                                                                                                                                                                                                                                                                                            phoneNumber: string,
                                                                                                                                                                                                                                                                                                                                                                                                                            applicationVerifier: ApplicationVerifier
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<ConfirmationResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                              method linkWithPopup

                                                                                                                                                                                                                                                                                                                                                                                                                              linkWithPopup: (provider: AuthProvider) => Promise<UserCredential>;

                                                                                                                                                                                                                                                                                                                                                                                                                                method linkWithRedirect

                                                                                                                                                                                                                                                                                                                                                                                                                                linkWithRedirect: (provider: AuthProvider) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method reauthenticateAndRetrieveDataWithCredential

                                                                                                                                                                                                                                                                                                                                                                                                                                  reauthenticateAndRetrieveDataWithCredential: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  credential: AuthCredential
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<UserCredential>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method reauthenticateWithCredential

                                                                                                                                                                                                                                                                                                                                                                                                                                    reauthenticateWithCredential: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    credential: AuthCredential
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<UserCredential>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method reauthenticateWithPhoneNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                      reauthenticateWithPhoneNumber: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      phoneNumber: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                      applicationVerifier: ApplicationVerifier
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<ConfirmationResult>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method reauthenticateWithPopup

                                                                                                                                                                                                                                                                                                                                                                                                                                        reauthenticateWithPopup: (provider: AuthProvider) => Promise<UserCredential>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method reauthenticateWithRedirect

                                                                                                                                                                                                                                                                                                                                                                                                                                          reauthenticateWithRedirect: (provider: AuthProvider) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method reload

                                                                                                                                                                                                                                                                                                                                                                                                                                            reload: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method sendEmailVerification

                                                                                                                                                                                                                                                                                                                                                                                                                                              sendEmailVerification: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              actionCodeSettings?: ActionCodeSettings | null
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                toJSON: () => Object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  unlink: (providerId: string) => Promise<User>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method updateEmail

                                                                                                                                                                                                                                                                                                                                                                                                                                                    updateEmail: (newEmail: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method updatePassword

                                                                                                                                                                                                                                                                                                                                                                                                                                                      updatePassword: (newPassword: string) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method updatePhoneNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                        updatePhoneNumber: (phoneCredential: AuthCredential) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method updateProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                          updateProfile: (profile: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          displayName?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          photoURL?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method verifyBeforeUpdateEmail

                                                                                                                                                                                                                                                                                                                                                                                                                                                            verifyBeforeUpdateEmail: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            newEmail: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            actionCodeSettings?: ActionCodeSettings | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface UserInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface UserInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                displayName: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property email

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  email: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property phoneNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    phoneNumber: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property photoURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      photoURL: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property providerId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        providerId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property uid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          uid: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UserMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UserMetadata {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property creationTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              creationTime?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property lastSignInTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lastSignInTime?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ActionCodeSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ActionCodeSettings = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  android?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  installApp?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minimumVersion?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  packageName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handleCodeInApp?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iOS?: { bundleId: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dynamicLinkDomain?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AdditionalUserInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AdditionalUserInfo = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isNewUser: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    profile: Object | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    providerId: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    username?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Operation = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Persistence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Persistence = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PhoneInfoOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PhoneInfoOptions =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | PhoneSingleFactorInfoOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | PhoneMultiFactorEnrollInfoOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | PhoneMultiFactorSignInInfoOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UserCredential

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UserCredential = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            additionalUserInfo?: AdditionalUserInfo | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            credential: AuthCredential | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            operationType?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            user: User | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@firebase/auth-types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@firebase/auth-types)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@firebase/auth-types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>