@firebase/auth-types

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

operation: string;

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

apiKey: string;

code: string;

continueUrl: string;

languageCode: string;

operation: string;

tenantId: string;

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

providerId: string;

signInMethod: string;

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

toJSON: () => Object;

static EMAIL_LINK_SIGN_IN_METHOD: string;

static EMAIL_PASSWORD_SIGN_IN_METHOD: string;

static PROVIDER_ID: string;

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

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

providerId: string;

static FACEBOOK_SIGN_IN_METHOD: string;

static PROVIDER_ID: string;

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

providerId: string;

addScope: (scope: string) => AuthProvider;

setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

app: FirebaseApp;

currentUser: User;

readonly emulatorConfig: EmulatorConfig;

languageCode: string;

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

settings: AuthSettings;

tenantId: string;

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

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

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

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

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

getRedirectResult: () => Promise<UserCredential>;

isSignInWithEmailLink: (emailLink: string) => boolean;

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

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

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

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

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

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

signInAnonymously: () => Promise<UserCredential>;

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

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

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

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

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

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

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

signOut: () => Promise<void>;

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

useDeviceLanguage: () => void;

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

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

static GITHUB_SIGN_IN_METHOD: string;

static PROVIDER_ID: string;

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

providerId: string;

addScope: (scope: string) => AuthProvider;

setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

static GOOGLE_SIGN_IN_METHOD: string;

static PROVIDER_ID: string;

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

providerId: string;

addScope: (scope: string) => AuthProvider;

setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

factorId: string;

auth: FirebaseAuth;

hints: MultiFactorInfo[];

session: MultiFactorSession;

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

accessToken?: string;

idToken?: string;

secret?: string;

constructor(providerId: string);

providerId: string;

addScope: (scope: string) => AuthProvider;

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

setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

static PHONE_SIGN_IN_METHOD: string;

static PROVIDER_ID: string;

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

constructor(auth?: FirebaseAuth);

providerId: string;

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

static FACTOR_ID: string;

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

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

type: string;

clear: () => void;

render: () => Promise<number>;

verify: () => Promise<string>;

constructor(providerId: string);

providerId: string;

static PROVIDER_ID: string;

static TWITTER_SIGN_IN_METHOD: string;

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

providerId: string;

setCustomParameters: (customOAuthParameters: Object) => AuthProvider;

type: string;

verify: () => Promise<string>;

credential?: AuthCredential;

email?: string;

phoneNumber?: string;

tenantId?: string;

providerId: string;

appVerificationDisabledForTesting: boolean;

verificationId: string;

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

readonly host: string;

readonly options: {
    readonly disableWarnings: boolean;
};

readonly port: number | null;

readonly protocol: string;

code: string;

message: string;

name: string;

stack?: string;

authTime: string;

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

expirationTime: string;

issuedAtTime: string;

signInProvider: string | null;

signInSecondFactor: string | null;

token: string;

resolver: MultiFactorResolver;

displayName?: string | null;

enrollmentTime: string;

factorId: string;

uid: string;

enrolledFactors: MultiFactorInfo[];

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

getSession: () => Promise<MultiFactorSession>;

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

accessToken?: string;

idToken?: string;

rawNonce?: string;

phoneNumber: string;

session: MultiFactorSession;

phoneNumber: string;

multiFactorHint?: MultiFactorInfo;

multiFactorUid?: string;

session: MultiFactorSession;

phoneNumber: string;

emailVerified: boolean;

isAnonymous: boolean;

metadata: UserMetadata;

multiFactor: MultiFactorUser;

phoneNumber: string | null;

providerData: (UserInfo | null)[];

refreshToken: string;

readonly tenantId: string | null;

delete: () => Promise<void>;

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

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

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

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

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

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

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

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

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

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

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

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

reload: () => Promise<void>;

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

toJSON: () => Object;

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

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

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

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

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

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

displayName: string | null;

email: string | null;

phoneNumber: string | null;

photoURL: string | null;

providerId: string;

uid: string;

creationTime?: string;

lastSignInTime?: string;