@firebase/auth-compat 0.5.15-canary.a97ac88db → 0.5.15-canary.e577a408c

package/dist/auth-compat/index.d.ts

@@ -1,112 +1,1129 @@
-/**
- * @license
- * Copyright 2020 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import * as types from '@firebase/auth-types';
-declare module '@firebase/component' {
-    interface NameServiceMapping {
-        'auth-compat': types.FirebaseAuth;
-    }
-}
-declare module '@firebase/app-compat' {
-    interface FirebaseNamespace {
-        auth: {
-            (app?: FirebaseApp): types.FirebaseAuth;
-            Auth: typeof types.FirebaseAuth;
-            EmailAuthProvider: typeof types.EmailAuthProvider;
-            EmailAuthProvider_Instance: typeof types.EmailAuthProvider_Instance;
-            FacebookAuthProvider: typeof types.FacebookAuthProvider;
-            FacebookAuthProvider_Instance: typeof types.FacebookAuthProvider_Instance;
-            GithubAuthProvider: typeof types.GithubAuthProvider;
-            GithubAuthProvider_Instance: typeof types.GithubAuthProvider_Instance;
-            GoogleAuthProvider: typeof types.GoogleAuthProvider;
-            GoogleAuthProvider_Instance: typeof types.GoogleAuthProvider_Instance;
-            OAuthProvider: typeof types.OAuthProvider;
-            SAMLAuthProvider: typeof types.SAMLAuthProvider;
-            PhoneAuthProvider: typeof types.PhoneAuthProvider;
-            PhoneAuthProvider_Instance: typeof types.PhoneAuthProvider_Instance;
-            PhoneMultiFactorGenerator: typeof types.PhoneMultiFactorGenerator;
-            RecaptchaVerifier: typeof types.RecaptchaVerifier;
-            RecaptchaVerifier_Instance: typeof types.RecaptchaVerifier_Instance;
-            TwitterAuthProvider: typeof types.TwitterAuthProvider;
-            TwitterAuthProvider_Instance: typeof types.TwitterAuthProvider_Instance;
-        };
-    }
-    interface FirebaseApp {
-        auth?(): types.FirebaseAuth;
-    }
-}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as types from '@firebase/auth-types';
+declare module '@firebase/component' {
+    interface NameServiceMapping {
+        'auth-compat': types.FirebaseAuth;
+    }
+}
+declare module '@firebase/app-compat' {
+    interface FirebaseNamespace {
+        auth: {
+            (app?: FirebaseApp): types.FirebaseAuth;
+            Auth: typeof types.FirebaseAuth;
+            EmailAuthProvider: typeof types.EmailAuthProvider;
+            EmailAuthProvider_Instance: typeof types.EmailAuthProvider_Instance;
+            FacebookAuthProvider: typeof types.FacebookAuthProvider;
+            FacebookAuthProvider_Instance: typeof types.FacebookAuthProvider_Instance;
+            GithubAuthProvider: typeof types.GithubAuthProvider;
+            GithubAuthProvider_Instance: typeof types.GithubAuthProvider_Instance;
+            GoogleAuthProvider: typeof types.GoogleAuthProvider;
+            GoogleAuthProvider_Instance: typeof types.GoogleAuthProvider_Instance;
+            OAuthProvider: typeof types.OAuthProvider;
+            SAMLAuthProvider: typeof types.SAMLAuthProvider;
+            PhoneAuthProvider: typeof types.PhoneAuthProvider;
+            PhoneAuthProvider_Instance: typeof types.PhoneAuthProvider_Instance;
+            PhoneMultiFactorGenerator: typeof types.PhoneMultiFactorGenerator;
+            RecaptchaVerifier: typeof types.RecaptchaVerifier;
+            RecaptchaVerifier_Instance: typeof types.RecaptchaVerifier_Instance;
+            TwitterAuthProvider: typeof types.TwitterAuthProvider;
+            TwitterAuthProvider_Instance: typeof types.TwitterAuthProvider_Instance;
+        };
+    }
+    interface FirebaseApp {
+        auth?(): types.FirebaseAuth;
+    }
+}
 
 import { FirebaseApp as FirebaseAppCompat } from "@firebase/app-compat";
 import { type User, type Unsubscribe, type ActionCodeInfo, type UserCredential, type Auth, type IdTokenResult, type MultiFactorError, type MultiFactorResolver, type PopupRedirectResolver, type Dependencies, type AuthCredential, type ApplicationVerifier, type ConfirmationResult, type AuthProvider, type MultiFactorUser, type NextOrObserver, type ErrorFn, type CompleteFn, type ActionCodeSettings, type Persistence, type PhoneAuthCredential, type PasswordValidationStatus } from "@firebase/auth";
 declare module "@firebase/auth" {
-    function applyActionCode(auth: types.FirebaseAuth, oobCode: string): Promise<void>;
-    function beforeAuthStateChanged(auth: types.FirebaseAuth, callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
-    function checkActionCode(auth: types.FirebaseAuth, oobCode: string): Promise<ActionCodeInfo>;
-    function confirmPasswordReset(auth: types.FirebaseAuth, oobCode: string, newPassword: string): Promise<void>;
-    function connectAuthEmulator(auth: types.FirebaseAuth, url: string, options?: {
+    /**
+     * Applies a verification code sent to the user by email or other out-of-band mechanism.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param oobCode - A verification code sent to the user.
+     *
+     * @public
+     */
+    export declare function applyActionCode(auth: types.FirebaseAuth, oobCode: string): Promise<void>;
+    /**
+     * Adds a blocking callback that runs before an auth state change
+     * sets a new user.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param callback - callback triggered before new user value is set.
+     *   If this throws, it blocks the user from being set.
+     * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`
+     *   callback throws, allowing you to undo any side effects.
+     */
+    export declare function beforeAuthStateChanged(auth: types.FirebaseAuth, callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
+    /**
+     * Checks a verification code sent to the user by email or other out-of-band mechanism.
+     *
+     * @returns metadata about the code.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param oobCode - A verification code sent to the user.
+     *
+     * @public
+     */
+    export declare function checkActionCode(auth: types.FirebaseAuth, oobCode: string): Promise<ActionCodeInfo>;
+    /**
+     * Completes the password reset process, given a confirmation code and new password.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param oobCode - A confirmation code sent to the user.
+     * @param newPassword - The new password.
+     *
+     * @public
+     */
+    export declare function confirmPasswordReset(auth: types.FirebaseAuth, oobCode: string, newPassword: string): Promise<void>;
+    /**
+     * Changes the {@link Auth} instance to communicate with the Firebase Auth Emulator, instead of production
+     * Firebase Auth services.
+     *
+     * @remarks
+     * This must be called synchronously immediately following the first call to
+     * {@link initializeAuth}.  Do not use with production credentials as emulator
+     * traffic is not encrypted.
+     *
+     *
+     * @example
+     * ```javascript
+     * connectAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param url - The URL at which the emulator is running (eg, 'http://localhost:9099').
+     * @param options - Optional. `options.disableWarnings` defaults to `false`. Set it to
+     * `true` to disable the warning banner attached to the DOM.
+     *
+     * @public
+     */
+    export declare function connectAuthEmulator(auth: types.FirebaseAuth, url: string, options?: {
         disableWarnings: boolean;
     }): void;
-    function createUserWithEmailAndPassword(auth: types.FirebaseAuth, email: string, password: string): Promise<UserCredential>;
-    function deleteUser(user: types.User): Promise<void>;
-    function fetchSignInMethodsForEmail(auth: types.FirebaseAuth, email: string): Promise<string[]>;
-    function getAuth(app?: FirebaseAppCompat): Auth;
-    function getIdToken(user: types.User, forceRefresh?: boolean): Promise<string>;
-    function getIdTokenResult(user: types.User, forceRefresh?: boolean): Promise<IdTokenResult>;
-    function getMultiFactorResolver(auth: types.FirebaseAuth, error: MultiFactorError): MultiFactorResolver;
-    function getRedirectResult(auth: types.FirebaseAuth, resolver?: PopupRedirectResolver): Promise<UserCredential | null>;
-    function initializeAuth(app: FirebaseAppCompat, deps?: Dependencies): Auth;
-    function initializeRecaptchaConfig(auth: types.FirebaseAuth): Promise<void>;
-    function isSignInWithEmailLink(auth: types.FirebaseAuth, emailLink: string): boolean;
-    function linkWithCredential(user: types.User, credential: AuthCredential): Promise<UserCredential>;
-    function linkWithPhoneNumber(user: types.User, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
-    function linkWithPopup(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
-    function linkWithRedirect(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
-    function multiFactor(user: types.User): MultiFactorUser;
-    function onAuthStateChanged(auth: types.FirebaseAuth, nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
-    function onIdTokenChanged(auth: types.FirebaseAuth, nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
-    function reauthenticateWithCredential(user: types.User, credential: AuthCredential): Promise<UserCredential>;
-    function reauthenticateWithPhoneNumber(user: types.User, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
-    function reauthenticateWithPopup(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
-    function reauthenticateWithRedirect(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
-    function reload(user: types.User): Promise<void>;
-    function revokeAccessToken(auth: types.FirebaseAuth, token: string): Promise<void>;
-    function sendEmailVerification(user: types.User, actionCodeSettings?: ActionCodeSettings | null): Promise<void>;
-    function sendPasswordResetEmail(auth: types.FirebaseAuth, email: string, actionCodeSettings?: ActionCodeSettings): Promise<void>;
-    function sendSignInLinkToEmail(auth: types.FirebaseAuth, email: string, actionCodeSettings: ActionCodeSettings): Promise<void>;
-    function setPersistence(auth: types.FirebaseAuth, persistence: Persistence): Promise<void>;
-    function signInAnonymously(auth: types.FirebaseAuth): Promise<UserCredential>;
-    function signInWithCredential(auth: types.FirebaseAuth, credential: AuthCredential): Promise<UserCredential>;
-    function signInWithCustomToken(auth: types.FirebaseAuth, customToken: string): Promise<UserCredential>;
-    function signInWithEmailAndPassword(auth: types.FirebaseAuth, email: string, password: string): Promise<UserCredential>;
-    function signInWithEmailLink(auth: types.FirebaseAuth, email: string, emailLink?: string): Promise<UserCredential>;
-    function signInWithPhoneNumber(auth: types.FirebaseAuth, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
-    function signInWithPopup(auth: types.FirebaseAuth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
-    function signInWithRedirect(auth: types.FirebaseAuth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
-    function signOut(auth: types.FirebaseAuth): Promise<void>;
-    function unlink(user: types.User, providerId: string): Promise<User>;
-    function updateCurrentUser(auth: types.FirebaseAuth, user: User | null): Promise<void>;
-    function updateEmail(user: types.User, newEmail: string): Promise<void>;
-    function updatePassword(user: types.User, newPassword: string): Promise<void>;
-    function updatePhoneNumber(user: types.User, credential: PhoneAuthCredential): Promise<void>;
-    function updateProfile(user: types.User, { displayName, photoURL: photoUrl }: {
+    /**
+     * Creates a new user account associated with the specified email address and password.
+     *
+     * @remarks
+     * On successful creation of the user account, this user will also be signed in to your application.
+     *
+     * User account creation can fail if the account already exists or the password is invalid.
+     *
+     * This method is not supported on {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * Note: The email address acts as a unique identifier for the user and enables an email-based
+     * password reset. This function will create a new user account and set the initial user password.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param email - The user's email address.
+     * @param password - The user's chosen password.
+     *
+     * @public
+     */
+    export declare function createUserWithEmailAndPassword(auth: types.FirebaseAuth, email: string, password: string): Promise<UserCredential>;
+    /**
+     * Deletes and signs out the user.
+     *
+     * @remarks
+     * Important: this is a security-sensitive operation that requires the user to have recently
+     * signed in. If this requirement isn't met, ask the user to authenticate again and then call
+     * {@link reauthenticateWithCredential}.
+     *
+     * @param user - The user.
+     *
+     * @public
+     */
+    export declare function deleteUser(user: types.User): Promise<void>;
+    /**
+     * Gets the list of possible sign in methods for the given email address. This method returns an
+     * empty list when
+     * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+     * is enabled, irrespective of the number of authentication methods available for the given email.
+     *
+     * @remarks
+     * This is useful to differentiate methods of sign-in for the same provider, eg.
+     * {@link EmailAuthProvider} which has 2 methods of sign-in,
+     * {@link SignInMethod}.EMAIL_PASSWORD and
+     * {@link SignInMethod}.EMAIL_LINK.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param email - The user's email address.
+     *
+     * Deprecated. Migrating off of this method is recommended as a security best-practice.
+     * Learn more in the Identity Platform documentation for
+     * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}.
+     * @public
+     */
+    export declare function fetchSignInMethodsForEmail(auth: types.FirebaseAuth, email: string): Promise<string[]>;
+    /**
+     * Returns the Auth instance associated with the provided {@link @firebase/app#FirebaseApp}.
+     * If no instance exists, initializes an Auth instance with platform-specific default dependencies.
+     *
+     * @param app - The Firebase App.
+     *
+     * @public
+     */
+    export declare function getAuth(app?: FirebaseAppCompat): Auth;
+    /**
+     * Returns a JSON Web Token (JWT) used to identify the user to a Firebase service.
+     *
+     * @remarks
+     * Returns the current token if it has not expired or if it will not expire in the next five
+     * minutes. Otherwise, this will refresh the token and return a new one.
+     *
+     * @param user - The user.
+     * @param forceRefresh - Force refresh regardless of token expiration.
+     *
+     * @public
+     */
+    export declare function getIdToken(user: types.User, forceRefresh?: boolean): Promise<string>;
+    /**
+     * Returns a deserialized JSON Web Token (JWT) used to identify the user to a Firebase service.
+     *
+     * @remarks
+     * Returns the current token if it has not expired or if it will not expire in the next five
+     * minutes. Otherwise, this will refresh the token and return a new one.
+     *
+     * @param user - The user.
+     * @param forceRefresh - Force refresh regardless of token expiration.
+     *
+     * @public
+     */
+    export declare function getIdTokenResult(user: types.User, forceRefresh?: boolean): Promise<IdTokenResult>;
+    /**
+     * Provides a {@link MultiFactorResolver} suitable for completion of a
+     * multi-factor flow.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param error - The {@link MultiFactorError} raised during a sign-in, or
+     * reauthentication operation.
+     *
+     * @public
+     */
+    export declare function getMultiFactorResolver(auth: types.FirebaseAuth, error: MultiFactorError): MultiFactorResolver;
+    /**
+     * Returns a {@link UserCredential} from the redirect-based sign-in flow.
+     *
+     * @remarks
+     * If sign-in succeeded, returns the signed in user. If sign-in was unsuccessful, fails with an
+     * error. If no redirect operation was called, returns `null`.
+     *
+     * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * // Sign in using a redirect.
+     * const provider = new FacebookAuthProvider();
+     * // You can add additional scopes to the provider:
+     * provider.addScope('user_birthday');
+     * // Start a sign in process for an unauthenticated user.
+     * await signInWithRedirect(auth, provider);
+     * // This will trigger a full page redirect away from your app
+     *
+     * // After returning from the redirect when your app initializes you can obtain the result
+     * const result = await getRedirectResult(auth);
+     * if (result) {
+     *   // This is the signed-in user
+     *   const user = result.user;
+     *   // This gives you a Facebook Access Token.
+     *   const credential = provider.credentialFromResult(auth, result);
+     *   const token = credential.accessToken;
+     * }
+     * // As this API can be used for sign-in, linking and reauthentication,
+     * // check the operationType to determine what triggered this redirect
+     * // operation.
+     * const operationType = result.operationType;
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+     * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+     *
+     * @public
+     */
+    export declare function getRedirectResult(auth: types.FirebaseAuth, resolver?: PopupRedirectResolver): Promise<UserCredential | null>;
+    /**
+     * Initializes an {@link Auth} instance with fine-grained control over
+     * {@link Dependencies}.
+     *
+     * @remarks
+     *
+     * This function allows more control over the {@link Auth} instance than
+     * {@link getAuth}. `getAuth` uses platform-specific defaults to supply
+     * the {@link Dependencies}. In general, `getAuth` is the easiest way to
+     * initialize Auth and works for most use cases. Use `initializeAuth` if you
+     * need control over which persistence layer is used, or to minimize bundle
+     * size if you're not using either `signInWithPopup` or `signInWithRedirect`.
+     *
+     * For example, if your app only uses anonymous accounts and you only want
+     * accounts saved for the current session, initialize `Auth` with:
+     *
+     * ```js
+     * const auth = initializeAuth(app, {
+     *   persistence: browserSessionPersistence,
+     *   popupRedirectResolver: undefined,
+     * });
+     * ```
+     *
+     * @public
+     */
+    export declare function initializeAuth(app: FirebaseAppCompat, deps?: Dependencies): Auth;
+    /**
+     * Loads the reCAPTCHA configuration into the `Auth` instance.
+     *
+     * @remarks
+     * This will load the reCAPTCHA config, which indicates whether the reCAPTCHA
+     * verification flow should be triggered for each auth provider, into the
+     * current Auth session.
+     *
+     * If initializeRecaptchaConfig() is not invoked, the auth flow will always start
+     * without reCAPTCHA verification. If the provider is configured to require reCAPTCHA
+     * verification, the SDK will transparently load the reCAPTCHA config and restart the
+     * auth flows.
+     *
+     * Thus, by calling this optional method, you will reduce the latency of future auth flows.
+     * Loading the reCAPTCHA config early will also enhance the signal collected by reCAPTCHA.
+     *
+     * This method does not work in a Node.js environment.
+     *
+     * @example
+     * ```javascript
+     * initializeRecaptchaConfig(auth);
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     *
+     * @public
+     */
+    export declare function initializeRecaptchaConfig(auth: types.FirebaseAuth): Promise<void>;
+    /**
+     * Checks if an incoming link is a sign-in with email link suitable for {@link signInWithEmailLink}.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param emailLink - The link sent to the user's email address.
+     *
+     * @public
+     */
+    export declare function isSignInWithEmailLink(auth: types.FirebaseAuth, emailLink: string): boolean;
+    /**
+     * Links the user account with the given credentials.
+     *
+     * @remarks
+     * An {@link AuthProvider} can be used to generate the credential.
+     *
+     * @param user - The user.
+     * @param credential - The auth credential.
+     *
+     * @public
+     */
+    export declare function linkWithCredential(user: types.User, credential: AuthCredential): Promise<UserCredential>;
+    /**
+     * Links the user account with the given phone number.
+     *
+     * @remarks
+     * This method does not work in a Node.js environment.
+     *
+     * @param user - The user.
+     * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).
+     * @param appVerifier - The {@link ApplicationVerifier}.
+     *
+     * @public
+     */
+    export declare function linkWithPhoneNumber(user: types.User, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
+    /**
+     * Links the authenticated provider to the user account using a pop-up based OAuth flow.
+     *
+     * @remarks
+     * If the linking is successful, the returned result will contain the user and the provider's credential.
+     *
+     * This method does not work in a Node.js environment.
+     *
+     * @example
+     * ```javascript
+     * // Sign in using some other provider.
+     * const result = await signInWithEmailAndPassword(auth, email, password);
+     * // Link using a popup.
+     * const provider = new FacebookAuthProvider();
+     * await linkWithPopup(result.user, provider);
+     * ```
+     *
+     * @param user - The user.
+     * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+     * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+     * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+     * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+     *
+     * @public
+     */
+    export declare function linkWithPopup(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+    /**
+     * Links the {@link OAuthProvider} to the user account using a full-page redirect flow.
+     * @remarks
+     * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+     * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+     * | best practices} when using {@link linkWithRedirect}.
+     *
+     * This method does not work in a Node.js environment or with {@link Auth} instances
+     * created with a {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * // Sign in using some other provider.
+     * const result = await signInWithEmailAndPassword(auth, email, password);
+     * // Link using a redirect.
+     * const provider = new FacebookAuthProvider();
+     * await linkWithRedirect(result.user, provider);
+     * // This will trigger a full page redirect away from your app
+     *
+     * // After returning from the redirect when your app initializes you can obtain the result
+     * const result = await getRedirectResult(auth);
+     * ```
+     *
+     * @param user - The user.
+     * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+     * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+     * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+     * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+     *
+     * @public
+     */
+    export declare function linkWithRedirect(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
+    /**
+     * The {@link MultiFactorUser} corresponding to the user.
+     *
+     * @remarks
+     * This is used to access all multi-factor properties and operations related to the user.
+     *
+     * @param user - The user.
+     *
+     * @public
+     */
+    export declare function multiFactor(user: types.User): MultiFactorUser;
+    /**
+     * Adds an observer for changes to the user's sign-in state.
+     *
+     * @remarks
+     * To keep the old behavior, see {@link onIdTokenChanged}.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param nextOrObserver - callback triggered on change.
+     * @param error - Deprecated. This callback is never triggered. Errors
+     * on signing in/out can be caught in promises returned from
+     * sign-in/sign-out functions.
+     * @param completed - Deprecated. This callback is never triggered.
+     *
+     * @public
+     */
+    export declare function onAuthStateChanged(auth: types.FirebaseAuth, nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+    /**
+     * Adds an observer for changes to the signed-in user's ID token.
+     *
+     * @remarks
+     * This includes sign-in, sign-out, and token refresh events.
+     * This will not be triggered automatically upon ID token expiration. Use {@link User.getIdToken} to refresh the ID token.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param nextOrObserver - callback triggered on change.
+     * @param error - Deprecated. This callback is never triggered. Errors
+     * on signing in/out can be caught in promises returned from
+     * sign-in/sign-out functions.
+     * @param completed - Deprecated. This callback is never triggered.
+     *
+     * @public
+     */
+    export declare function onIdTokenChanged(auth: types.FirebaseAuth, nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+    /**
+     * Re-authenticates a user using a fresh credential.
+     *
+     * @remarks
+     * Use before operations such as {@link updatePassword} that require tokens from recent sign-in
+     * attempts. This method can be used to recover from a `CREDENTIAL_TOO_OLD_LOGIN_AGAIN` error
+     * or a `TOKEN_EXPIRED` error.
+     *
+     * This method is not supported on any {@link User} signed in by {@link Auth} instances
+     * created with a {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @param user - The user.
+     * @param credential - The auth credential.
+     *
+     * @public
+     */
+    export declare function reauthenticateWithCredential(user: types.User, credential: AuthCredential): Promise<UserCredential>;
+    /**
+     * Re-authenticates a user using a fresh phone credential.
+     *
+     * @remarks
+     * Use before operations such as {@link updatePassword} that require tokens from recent sign-in attempts.
+     *
+     * This method does not work in a Node.js environment or on any {@link User} signed in by
+     * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @param user - The user.
+     * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).
+     * @param appVerifier - The {@link ApplicationVerifier}.
+     *
+     * @public
+     */
+    export declare function reauthenticateWithPhoneNumber(user: types.User, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
+    /**
+     * Reauthenticates the current user with the specified {@link OAuthProvider} using a pop-up based
+     * OAuth flow.
+     *
+     * @remarks
+     * If the reauthentication is successful, the returned result will contain the user and the
+     * provider's credential.
+     *
+     * This method does not work in a Node.js environment or on any {@link User} signed in by
+     * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * // Sign in using a popup.
+     * const provider = new FacebookAuthProvider();
+     * const result = await signInWithPopup(auth, provider);
+     * // Reauthenticate using a popup.
+     * await reauthenticateWithPopup(result.user, provider);
+     * ```
+     *
+     * @param user - The user.
+     * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+     * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+     * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+     * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+     *
+     * @public
+     */
+    export declare function reauthenticateWithPopup(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+    /**
+     * Reauthenticates the current user with the specified {@link OAuthProvider} using a full-page redirect flow.
+     * @remarks
+     * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+     * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+     * | best practices} when using {@link reauthenticateWithRedirect}.
+     *
+     * This method does not work in a Node.js environment or with {@link Auth} instances
+     * created with a {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * // Sign in using a redirect.
+     * const provider = new FacebookAuthProvider();
+     * const result = await signInWithRedirect(auth, provider);
+     * // This will trigger a full page redirect away from your app
+     *
+     * // After returning from the redirect when your app initializes you can obtain the result
+     * const result = await getRedirectResult(auth);
+     * // Reauthenticate using a redirect.
+     * await reauthenticateWithRedirect(result.user, provider);
+     * // This will again trigger a full page redirect away from your app
+     *
+     * // After returning from the redirect when your app initializes you can obtain the result
+     * const result = await getRedirectResult(auth);
+     * ```
+     *
+     * @param user - The user.
+     * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+     * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+     * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+     * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+     *
+     * @public
+     */
+    export declare function reauthenticateWithRedirect(user: types.User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
+    /**
+     * Reloads user account data, if signed in.
+     *
+     * @param user - The user.
+     *
+     * @public
+     */
+    export declare function reload(user: types.User): Promise<void>;
+    /**
+     * Revokes the given access token. Currently only supports Apple OAuth access tokens.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param token - The Apple OAuth access token.
+     *
+     * @public
+     */
+    export declare function revokeAccessToken(auth: types.FirebaseAuth, token: string): Promise<void>;
+    /**
+     * Sends a verification email to a user.
+     *
+     * @remarks
+     * The verification process is completed by calling {@link applyActionCode}.
+     *
+     * @example
+     * ```javascript
+     * const actionCodeSettings = {
+     *   url: 'https://www.example.com/?email=user@example.com',
+     *   iOS: {
+     *      bundleId: 'com.example.ios'
+     *   },
+     *   android: {
+     *     packageName: 'com.example.android',
+     *     installApp: true,
+     *     minimumVersion: '12'
+     *   },
+     *   handleCodeInApp: true
+     * };
+     * await sendEmailVerification(user, actionCodeSettings);
+     * // Obtain code from the user.
+     * await applyActionCode(auth, code);
+     * ```
+     *
+     * @param user - The user.
+     * @param actionCodeSettings - The {@link ActionCodeSettings}.
+     *
+     * @public
+     */
+    export declare function sendEmailVerification(user: types.User, actionCodeSettings?: ActionCodeSettings | null): Promise<void>;
+    /**
+     * Sends a password reset email to the given email address. This method does not throw an error when
+     * there's no user account with the given email address and
+     * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+     * is enabled.
+     *
+     * @remarks
+     * To complete the password reset, call {@link confirmPasswordReset} with the code supplied in
+     * the email sent to the user, along with the new password specified by the user.
+     *
+     * @example
+     * ```javascript
+     * const actionCodeSettings = {
+     *   url: 'https://www.example.com/?email=user@example.com',
+     *   iOS: {
+     *      bundleId: 'com.example.ios'
+     *   },
+     *   android: {
+     *     packageName: 'com.example.android',
+     *     installApp: true,
+     *     minimumVersion: '12'
+     *   },
+     *   handleCodeInApp: true
+     * };
+     * await sendPasswordResetEmail(auth, 'user@example.com', actionCodeSettings);
+     * // Obtain code from user.
+     * await confirmPasswordReset('user@example.com', code);
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param email - The user's email address.
+     * @param actionCodeSettings - The {@link ActionCodeSettings}.
+     *
+     * @public
+     */
+    export declare function sendPasswordResetEmail(auth: types.FirebaseAuth, email: string, actionCodeSettings?: ActionCodeSettings): Promise<void>;
+    /**
+     * Sends a sign-in email link to the user with the specified email.
+     *
+     * @remarks
+     * The sign-in operation has to always be completed in the app unlike other out of band email
+     * actions (password reset and email verifications). This is because, at the end of the flow,
+     * the user is expected to be signed in and their Auth state persisted within the app.
+     *
+     * To complete sign in with the email link, call {@link signInWithEmailLink} with the email
+     * address and the email link supplied in the email sent to the user.
+     *
+     * @example
+     * ```javascript
+     * const actionCodeSettings = {
+     *   url: 'https://www.example.com/?email=user@example.com',
+     *   iOS: {
+     *      bundleId: 'com.example.ios'
+     *   },
+     *   android: {
+     *     packageName: 'com.example.android',
+     *     installApp: true,
+     *     minimumVersion: '12'
+     *   },
+     *   handleCodeInApp: true
+     * };
+     * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);
+     * // Obtain emailLink from the user.
+     * if(isSignInWithEmailLink(auth, emailLink)) {
+     *   await signInWithEmailLink(auth, 'user@example.com', emailLink);
+     * }
+     * ```
+     *
+     * @param authInternal - The {@link Auth} instance.
+     * @param email - The user's email address.
+     * @param actionCodeSettings - The {@link ActionCodeSettings}.
+     *
+     * @public
+     */
+    export declare function sendSignInLinkToEmail(auth: types.FirebaseAuth, email: string, actionCodeSettings: ActionCodeSettings): Promise<void>;
+    /**
+     * Changes the type of persistence on the {@link Auth} instance for the currently saved
+     * `Auth` session and applies this type of persistence for future sign-in requests, including
+     * sign-in with redirect requests.
+     *
+     * @remarks
+     * This makes it easy for a user signing in to specify whether their session should be
+     * remembered or not. It also makes it easier to never persist the `Auth` state for applications
+     * that are shared by other users or have sensitive data.
+     *
+     * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * setPersistence(auth, browserSessionPersistence);
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param persistence - The {@link Persistence} to use.
+     * @returns A `Promise` that resolves once the persistence change has completed
+     *
+     * @public
+     */
+    export declare function setPersistence(auth: types.FirebaseAuth, persistence: Persistence): Promise<void>;
+    /**
+     * Asynchronously signs in as an anonymous user.
+     *
+     * @remarks
+     * If there is already an anonymous user signed in, that user will be returned; otherwise, a
+     * new anonymous user identity will be created and returned.
+     *
+     * This method is not supported by {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @param auth - The {@link Auth} instance.
+     *
+     * @public
+     */
+    export declare function signInAnonymously(auth: types.FirebaseAuth): Promise<UserCredential>;
+    /**
+     * Asynchronously signs in with the given credentials.
+     *
+     * @remarks
+     * An {@link AuthProvider} can be used to generate the credential.
+     *
+     * This method is not supported by {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param credential - The auth credential.
+     *
+     * @public
+     */
+    export declare function signInWithCredential(auth: types.FirebaseAuth, credential: AuthCredential): Promise<UserCredential>;
+    /**
+     * Asynchronously signs in using a custom token.
+     *
+     * @remarks
+     * Custom tokens are used to integrate Firebase Auth with existing auth systems, and must
+     * be generated by an auth backend using the
+     * {@link https://firebase.google.com/docs/reference/admin/node/admin.auth.Auth#createcustomtoken | createCustomToken}
+     * method in the {@link https://firebase.google.com/docs/auth/admin | Admin SDK} .
+     *
+     * Fails with an error if the token is invalid, expired, or not accepted by the Firebase Auth service.
+     *
+     * This method is not supported by {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param customToken - The custom token to sign in with.
+     *
+     * @public
+     */
+    export declare function signInWithCustomToken(auth: types.FirebaseAuth, customToken: string): Promise<UserCredential>;
+    /**
+     * Asynchronously signs in using an email and password.
+     *
+     * @remarks
+     * Fails with an error if the email address and password do not match. When
+     * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+     * is enabled, this method fails with "auth/invalid-credential" in case of an invalid
+     * email/password.
+     *
+     * This method is not supported on {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * Note: The user's password is NOT the password used to access the user's email account. The
+     * email address serves as a unique identifier for the user, and the password is used to access
+     * the user's account in your Firebase project. See also: {@link createUserWithEmailAndPassword}.
+     *
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param email - The users email address.
+     * @param password - The users password.
+     *
+     * @public
+     */
+    export declare function signInWithEmailAndPassword(auth: types.FirebaseAuth, email: string, password: string): Promise<UserCredential>;
+    /**
+     * Asynchronously signs in using an email and sign-in email link.
+     *
+     * @remarks
+     * If no link is passed, the link is inferred from the current URL.
+     *
+     * Fails with an error if the email address is invalid or OTP in email link expires.
+     *
+     * This method is not supported by {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * Note: Confirm the link is a sign-in email link before calling this method firebase.auth.Auth.isSignInWithEmailLink.
+     *
+     * @example
+     * ```javascript
+     * const actionCodeSettings = {
+     *   url: 'https://www.example.com/?email=user@example.com',
+     *   iOS: {
+     *      bundleId: 'com.example.ios'
+     *   },
+     *   android: {
+     *     packageName: 'com.example.android',
+     *     installApp: true,
+     *     minimumVersion: '12'
+     *   },
+     *   handleCodeInApp: true
+     * };
+     * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);
+     * // Obtain emailLink from the user.
+     * if(isSignInWithEmailLink(auth, emailLink)) {
+     *   await signInWithEmailLink(auth, 'user@example.com', emailLink);
+     * }
+     * ```
+     *
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param email - The user's email address.
+     * @param emailLink - The link sent to the user's email address.
+     *
+     * @public
+     */
+    export declare function signInWithEmailLink(auth: types.FirebaseAuth, email: string, emailLink?: string): Promise<UserCredential>;
+    /* Excluded from this release type: SignInWithIdpResponse */
+    /**
+     * Asynchronously signs in using a phone number.
+     *
+     * @remarks
+     * This method sends a code via SMS to the given
+     * phone number, and returns a {@link ConfirmationResult}. After the user
+     * provides the code sent to their phone, call {@link ConfirmationResult.confirm}
+     * with the code to sign the user in.
+     *
+     * For abuse prevention, this method requires a {@link ApplicationVerifier}.
+     * This SDK includes an implementation based on reCAPTCHA v2, {@link RecaptchaVerifier}.
+     * This function can work on other platforms that do not support the
+     * {@link RecaptchaVerifier} (like React Native), but you need to use a
+     * third-party {@link ApplicationVerifier} implementation.
+     *
+     * If you've enabled project-level reCAPTCHA Enterprise bot protection in
+     * Enforce mode, you can omit the {@link ApplicationVerifier}.
+     *
+     * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * // 'recaptcha-container' is the ID of an element in the DOM.
+     * const applicationVerifier = new firebase.auth.RecaptchaVerifier('recaptcha-container');
+     * const confirmationResult = await signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);
+     * // Obtain a verificationCode from the user.
+     * const credential = await confirmationResult.confirm(verificationCode);
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).
+     * @param appVerifier - The {@link ApplicationVerifier}.
+     *
+     * @public
+     */
+    export declare function signInWithPhoneNumber(auth: types.FirebaseAuth, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
+    /* Excluded from this release type: SignInWithPhoneNumberRequest */
+    /* Excluded from this release type: SignInWithPhoneNumberResponse */
+    /**
+     * Authenticates a Firebase client using a popup-based OAuth authentication flow.
+     *
+     * @remarks
+     * If succeeds, returns the signed in user along with the provider's credential. If sign in was
+     * unsuccessful, returns an error object containing additional information about the error.
+     *
+     * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * // Sign in using a popup.
+     * const provider = new FacebookAuthProvider();
+     * const result = await signInWithPopup(auth, provider);
+     *
+     * // The signed-in user info.
+     * const user = result.user;
+     * // This gives you a Facebook Access Token.
+     * const credential = provider.credentialFromResult(auth, result);
+     * const token = credential.accessToken;
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+     * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+     * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+     * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+     *
+     * @public
+     */
+    export declare function signInWithPopup(auth: types.FirebaseAuth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+    /**
+     * Authenticates a Firebase client using a full-page redirect flow.
+     *
+     * @remarks
+     * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+     * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+     * | best practices} when using {@link signInWithRedirect}.
+     *
+     * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```javascript
+     * // Sign in using a redirect.
+     * const provider = new FacebookAuthProvider();
+     * // You can add additional scopes to the provider:
+     * provider.addScope('user_birthday');
+     * // Start a sign in process for an unauthenticated user.
+     * await signInWithRedirect(auth, provider);
+     * // This will trigger a full page redirect away from your app
+     *
+     * // After returning from the redirect when your app initializes you can obtain the result
+     * const result = await getRedirectResult(auth);
+     * if (result) {
+     *   // This is the signed-in user
+     *   const user = result.user;
+     *   // This gives you a Facebook Access Token.
+     *   const credential = provider.credentialFromResult(auth, result);
+     *   const token = credential.accessToken;
+     * }
+     * // As this API can be used for sign-in, linking and reauthentication,
+     * // check the operationType to determine what triggered this redirect
+     * // operation.
+     * const operationType = result.operationType;
+     * ```
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+     * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+     * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+     * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+     *
+     * @public
+     */
+    export declare function signInWithRedirect(auth: types.FirebaseAuth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
+    /**
+     * Signs out the current user.
+     *
+     * @remarks
+     * This method is not supported by {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @param auth - The {@link Auth} instance.
+     *
+     * @public
+     */
+    export declare function signOut(auth: types.FirebaseAuth): Promise<void>;
+    /**
+     * Unlinks a provider from a user account.
+     *
+     * @param user - The user.
+     * @param providerId - The provider to unlink.
+     *
+     * @public
+     */
+    export declare function unlink(user: types.User, providerId: string): Promise<User>;
+    /**
+     * Asynchronously sets the provided user as {@link Auth.currentUser} on the
+     * {@link Auth} instance.
+     *
+     * @remarks
+     * A new instance copy of the user provided will be made and set as currentUser.
+     *
+     * This will trigger {@link onAuthStateChanged} and {@link onIdTokenChanged} listeners
+     * like other sign in methods.
+     *
+     * The operation fails with an error if the user to be updated belongs to a different Firebase
+     * project.
+     *
+     * This method is not supported by {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param user - The new {@link User}.
+     *
+     * @public
+     */
+    export declare function updateCurrentUser(auth: types.FirebaseAuth, user: User | null): Promise<void>;
+    /**
+     * Updates the user's email address.
+     *
+     * @remarks
+     * An email will be sent to the original email address (if it was set) that allows to revoke the
+     * email address change, in order to protect them from account hijacking.
+     *
+     * This method is not supported on any {@link User} signed in by {@link Auth} instances
+     * created with a {@link @firebase/app#FirebaseServerApp}.
+     *
+     * Important: this is a security sensitive operation that requires the user to have recently signed
+     * in. If this requirement isn't met, ask the user to authenticate again and then call
+     * {@link reauthenticateWithCredential}.
+     *
+     * @param user - The user.
+     * @param newEmail - The new email address.
+     *
+     * Throws "auth/operation-not-allowed" error when
+     * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+     * is enabled.
+     * Deprecated - Use {@link verifyBeforeUpdateEmail} instead.
+     *
+     * @public
+     */
+    export declare function updateEmail(user: types.User, newEmail: string): Promise<void>;
+    /**
+     * Updates the user's password.
+     *
+     * @remarks
+     * Important: this is a security sensitive operation that requires the user to have recently signed
+     * in. If this requirement isn't met, ask the user to authenticate again and then call
+     * {@link reauthenticateWithCredential}.
+     *
+     * @param user - The user.
+     * @param newPassword - The new password.
+     *
+     * @public
+     */
+    export declare function updatePassword(user: types.User, newPassword: string): Promise<void>;
+    /**
+     * Updates the user's phone number.
+     *
+     * @remarks
+     * This method does not work in a Node.js environment or on any {@link User} signed in by
+     * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}.
+     *
+     * @example
+     * ```
+     * // 'recaptcha-container' is the ID of an element in the DOM.
+     * const applicationVerifier = new RecaptchaVerifier('recaptcha-container');
+     * const provider = new PhoneAuthProvider(auth);
+     * const verificationId = await provider.verifyPhoneNumber('+16505550101', applicationVerifier);
+     * // Obtain the verificationCode from the user.
+     * const phoneCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+     * await updatePhoneNumber(user, phoneCredential);
+     * ```
+     *
+     * @param user - The user.
+     * @param credential - A credential authenticating the new phone number.
+     *
+     * @public
+     */
+    export declare function updatePhoneNumber(user: types.User, credential: PhoneAuthCredential): Promise<void>;
+    /**
+     * Updates a user's profile data.
+     *
+     * @param user - The user.
+     * @param profile - The profile's `displayName` and `photoURL` to update.
+     *
+     * @public
+     */
+    export declare function updateProfile(user: types.User, { displayName, photoURL: photoUrl }: {
         displayName?: string | null;
         photoURL?: string | null;
     }): Promise<void>;
-    function useDeviceLanguage(auth: types.FirebaseAuth): void;
-    function validatePassword(auth: types.FirebaseAuth, password: string): Promise<PasswordValidationStatus>;
-    function verifyBeforeUpdateEmail(user: types.User, newEmail: string, actionCodeSettings?: ActionCodeSettings | null): Promise<void>;
-    function verifyPasswordResetCode(auth: types.FirebaseAuth, code: string): Promise<string>;
+    /**
+     * Sets the current language to the default device/browser preference.
+     *
+     * @param auth - The {@link Auth} instance.
+     *
+     * @public
+     */
+    export declare function useDeviceLanguage(auth: types.FirebaseAuth): void;
+    /**
+     * Validates the password against the password policy configured for the project or tenant.
+     *
+     * @remarks
+     * If no tenant ID is set on the `Auth` instance, then this method will use the password
+     * policy configured for the project. Otherwise, this method will use the policy configured
+     * for the tenant. If a password policy has not been configured, then the default policy
+     * configured for all projects will be used.
+     *
+     * If an auth flow fails because a submitted password does not meet the password policy
+     * requirements and this method has previously been called, then this method will use the
+     * most recent policy available when called again.
+     *
+     * @example
+     * ```javascript
+     * validatePassword(auth, 'some-password');
+     * ```
+     *
+     * @param auth The {@link Auth} instance.
+     * @param password The password to validate.
+     *
+     * @public
+     */
+    export declare function validatePassword(auth: types.FirebaseAuth, password: string): Promise<PasswordValidationStatus>;
+    /**
+     * Sends a verification email to a new email address.
+     *
+     * @remarks
+     * The user's email will be updated to the new one after being verified.
+     *
+     * If you have a custom email action handler, you can complete the verification process by calling
+     * {@link applyActionCode}.
+     *
+     * @example
+     * ```javascript
+     * const actionCodeSettings = {
+     *   url: 'https://www.example.com/?email=user@example.com',
+     *   iOS: {
+     *      bundleId: 'com.example.ios'
+     *   },
+     *   android: {
+     *     packageName: 'com.example.android',
+     *     installApp: true,
+     *     minimumVersion: '12'
+     *   },
+     *   handleCodeInApp: true
+     * };
+     * await verifyBeforeUpdateEmail(user, 'newemail@example.com', actionCodeSettings);
+     * // Obtain code from the user.
+     * await applyActionCode(auth, code);
+     * ```
+     *
+     * @param user - The user.
+     * @param newEmail - The new email address to be verified before update.
+     * @param actionCodeSettings - The {@link ActionCodeSettings}.
+     *
+     * @public
+     */
+    export declare function verifyBeforeUpdateEmail(user: types.User, newEmail: string, actionCodeSettings?: ActionCodeSettings | null): Promise<void>;
+    /**
+     * Checks a password reset code sent to the user by email or other out-of-band mechanism.
+     *
+     * @returns the user's email address if valid.
+     *
+     * @param auth - The {@link Auth} instance.
+     * @param code - A verification code sent to the user.
+     *
+     * @public
+     */
+    export declare function verifyPasswordResetCode(auth: types.FirebaseAuth, code: string): Promise<string>;
 }