@firebase/auth 0.22.0 → 0.23.0-20230413163153

package/dist/cordova/src/api/authentication/email_and_password.d.ts

@@ -15,12 +15,16 @@
  * limitations under the License.
  */
 import { ActionCodeOperation, Auth } from '../../model/public_types';
+import { RecaptchaClientType, RecaptchaVersion } from '../index';
 import { IdToken, IdTokenResponse } from '../../model/id_token';
 export interface SignInWithPasswordRequest {
     returnSecureToken?: boolean;
     email: string;
     password: string;
     tenantId?: string;
+    captchaResponse?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
 }
 export interface SignInWithPasswordResponse extends IdTokenResponse {
     email: string;
@@ -48,10 +52,15 @@ export interface PasswordResetRequest extends GetOobCodeRequest {
     requestType: ActionCodeOperation.PASSWORD_RESET;
     email: string;
     captchaResp?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
 }
 export interface EmailSignInRequest extends GetOobCodeRequest {
     requestType: ActionCodeOperation.EMAIL_SIGNIN;
     email: string;
+    captchaResp?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
 }
 export interface VerifyAndChangeEmailRequest extends GetOobCodeRequest {
     requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;

package/dist/cordova/src/api/authentication/recaptcha.d.ts

@@ -14,5 +14,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { RecaptchaClientType, RecaptchaVersion } from '../index';
 import { Auth } from '../../model/public_types';
 export declare function getRecaptchaParams(auth: Auth): Promise<string>;
+interface GetRecaptchaConfigRequest {
+    tenantId?: string;
+    clientType?: RecaptchaClientType;
+    version?: RecaptchaVersion;
+}
+interface RecaptchaEnforcementState {
+    provider: string;
+    enforcementState: string;
+}
+export interface GetRecaptchaConfigResponse {
+    recaptchaKey: string;
+    recaptchaEnforcementState: RecaptchaEnforcementState[];
+}
+export declare function getRecaptchaConfig(auth: Auth, request: GetRecaptchaConfigRequest): Promise<GetRecaptchaConfigResponse>;
+export {};

package/dist/cordova/src/api/authentication/sign_up.d.ts

@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { RecaptchaClientType, RecaptchaVersion } from '../index';
 import { IdTokenResponse } from '../../model/id_token';
 import { Auth } from '../../model/public_types';
 export interface SignUpRequest {
@@ -21,6 +22,9 @@ export interface SignUpRequest {
     email?: string;
     password?: string;
     tenantId?: string;
+    captchaResponse?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
 }
 export interface SignUpResponse extends IdTokenResponse {
     displayName?: string;

package/dist/cordova/src/api/errors.d.ts

@@ -88,7 +88,15 @@ export declare const enum ServerError {
     USER_CANCELLED = "USER_CANCELLED",
     USER_DISABLED = "USER_DISABLED",
     USER_NOT_FOUND = "USER_NOT_FOUND",
-    WEAK_PASSWORD = "WEAK_PASSWORD"
+    WEAK_PASSWORD = "WEAK_PASSWORD",
+    RECAPTCHA_NOT_ENABLED = "RECAPTCHA_NOT_ENABLED",
+    MISSING_RECAPTCHA_TOKEN = "MISSING_RECAPTCHA_TOKEN",
+    INVALID_RECAPTCHA_TOKEN = "INVALID_RECAPTCHA_TOKEN",
+    INVALID_RECAPTCHA_ACTION = "INVALID_RECAPTCHA_ACTION",
+    MISSING_CLIENT_TYPE = "MISSING_CLIENT_TYPE",
+    MISSING_RECAPTCHA_VERSION = "MISSING_RECAPTCHA_VERSION",
+    INVALID_RECAPTCHA_VERSION = "INVALID_RECAPTCHA_VERSION",
+    INVALID_REQ_TYPE = "INVALID_REQ_TYPE"
 }
 /**
  * API Response in the event of an error

package/dist/cordova/src/api/index.d.ts

@@ -29,7 +29,8 @@ export declare const enum HttpHeader {
     X_FIREBASE_LOCALE = "X-Firebase-Locale",
     X_CLIENT_VERSION = "X-Client-Version",
     X_FIREBASE_GMPID = "X-Firebase-gmpid",
-    X_FIREBASE_CLIENT = "X-Firebase-Client"
+    X_FIREBASE_CLIENT = "X-Firebase-Client",
+    X_FIREBASE_APP_CHECK = "X-Firebase-AppCheck"
 }
 export declare const enum Endpoint {
     CREATE_AUTH_URI = "/v1/accounts:createAuthUri",
@@ -51,7 +52,21 @@ export declare const enum Endpoint {
     START_MFA_SIGN_IN = "/v2/accounts/mfaSignIn:start",
     FINALIZE_MFA_SIGN_IN = "/v2/accounts/mfaSignIn:finalize",
     WITHDRAW_MFA = "/v2/accounts/mfaEnrollment:withdraw",
-    GET_PROJECT_CONFIG = "/v1/projects"
+    GET_PROJECT_CONFIG = "/v1/projects",
+    GET_RECAPTCHA_CONFIG = "/v2/recaptchaConfig"
+}
+export declare const enum RecaptchaClientType {
+    WEB = "CLIENT_TYPE_WEB",
+    ANDROID = "CLIENT_TYPE_ANDROID",
+    IOS = "CLIENT_TYPE_IOS"
+}
+export declare const enum RecaptchaVersion {
+    ENTERPRISE = "RECAPTCHA_ENTERPRISE"
+}
+export declare const enum RecaptchaActionName {
+    SIGN_IN_WITH_PASSWORD = "signInWithPassword",
+    GET_OOB_CODE = "getOobCode",
+    SIGN_UP_PASSWORD = "signUpPassword"
 }
 export declare const DEFAULT_API_TIMEOUT_MS: Delay;
 export declare function _addTidIfNecessary<T extends {

package/dist/cordova/src/core/auth/auth_impl.d.ts

@@ -16,6 +16,7 @@
  */
 import { _FirebaseService, FirebaseApp } from '@firebase/app';
 import { Provider } from '@firebase/component';
+import { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';
 import { Auth, AuthErrorMap, AuthSettings, EmulatorConfig, NextOrObserver, Persistence, PopupRedirectResolver, User, CompleteFn, ErrorFn, Unsubscribe } from '../../model/public_types';
 import { ErrorFactory } from '@firebase/util';
 import { AuthInternal, ConfigInternal } from '../../model/auth';
@@ -23,6 +24,7 @@ import { PopupRedirectResolverInternal } from '../../model/popup_redirect';
 import { UserInternal } from '../../model/user';
 import { AuthErrorCode, AuthErrorParams } from '../errors';
 import { PersistenceInternal } from '../persistence';
+import { RecaptchaConfig } from '../../platform_browser/recaptcha/recaptcha';
 export declare const enum DefaultConfig {
     TOKEN_API_HOST = "securetoken.googleapis.com",
     API_HOST = "identitytoolkit.googleapis.com",
@@ -31,6 +33,7 @@ export declare const enum DefaultConfig {
 export declare class AuthImpl implements AuthInternal, _FirebaseService {
     readonly app: FirebaseApp;
     private readonly heartbeatServiceProvider;
+    private readonly appCheckServiceProvider;
     readonly config: ConfigInternal;
     currentUser: User | null;
     emulatorConfig: EmulatorConfig | null;
@@ -48,12 +51,14 @@ export declare class AuthImpl implements AuthInternal, _FirebaseService {
     _initializationPromise: Promise<void> | null;
     _popupRedirectResolver: PopupRedirectResolverInternal | null;
     _errorFactory: ErrorFactory<AuthErrorCode, AuthErrorParams>;
+    _agentRecaptchaConfig: RecaptchaConfig | null;
+    _tenantRecaptchaConfigs: Record<string, RecaptchaConfig>;
     readonly name: string;
     private lastNotifiedUid;
     languageCode: string | null;
     tenantId: string | null;
     settings: AuthSettings;
-    constructor(app: FirebaseApp, heartbeatServiceProvider: Provider<'heartbeat'>, config: ConfigInternal);
+    constructor(app: FirebaseApp, heartbeatServiceProvider: Provider<'heartbeat'>, appCheckServiceProvider: Provider<AppCheckInternalComponentName>, config: ConfigInternal);
     _initializeWithPersistence(persistenceHierarchy: PersistenceInternal[], popupRedirectResolver?: PopupRedirectResolver): Promise<void>;
     /**
      * If the persistence is changed in another window, the user manager will let us know
@@ -68,6 +73,8 @@ export declare class AuthImpl implements AuthInternal, _FirebaseService {
     _updateCurrentUser(user: User | null, skipBeforeStateCallbacks?: boolean): Promise<void>;
     signOut(): Promise<void>;
     setPersistence(persistence: Persistence): Promise<void>;
+    initializeRecaptchaConfig(): Promise<void>;
+    _getRecaptchaConfig(): RecaptchaConfig | null;
     _getPersistence(): string;
     _updateErrorMap(errorMap: AuthErrorMap): void;
     onAuthStateChanged(nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
@@ -100,6 +107,7 @@ export declare class AuthImpl implements AuthInternal, _FirebaseService {
     _logFramework(framework: string): void;
     _getFrameworks(): readonly string[];
     _getAdditionalHeaders(): Promise<Record<string, string>>;
+    _getAppCheckToken(): Promise<string | undefined>;
 }
 /**
  * Method to be used to cast down to our private implmentation of Auth.

package/dist/cordova/src/core/errors.d.ts

@@ -121,7 +121,15 @@ export declare const enum AuthErrorCode {
     USER_SIGNED_OUT = "user-signed-out",
     WEAK_PASSWORD = "weak-password",
     WEB_STORAGE_UNSUPPORTED = "web-storage-unsupported",
-    ALREADY_INITIALIZED = "already-initialized"
+    ALREADY_INITIALIZED = "already-initialized",
+    RECAPTCHA_NOT_ENABLED = "recaptcha-not-enabled",
+    MISSING_RECAPTCHA_TOKEN = "missing-recaptcha-token",
+    INVALID_RECAPTCHA_TOKEN = "invalid-recaptcha-token",
+    INVALID_RECAPTCHA_ACTION = "invalid-recaptcha-action",
+    MISSING_CLIENT_TYPE = "missing-client-type",
+    MISSING_RECAPTCHA_VERSION = "missing-recaptcha-version",
+    INVALID_RECAPTCHA_VERSION = "invalid-recaptcha-version",
+    INVALID_REQ_TYPE = "invalid-req-type"
 }
 export interface ErrorMapRetriever extends AuthErrorMap {
     (): ErrorMap<AuthErrorCode>;
@@ -302,5 +310,13 @@ export declare const AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY: {
     readonly WEAK_PASSWORD: "auth/weak-password";
     readonly WEB_STORAGE_UNSUPPORTED: "auth/web-storage-unsupported";
     readonly ALREADY_INITIALIZED: "auth/already-initialized";
+    readonly RECAPTCHA_NOT_ENABLED: "auth/recaptcha-not-enabled";
+    readonly MISSING_RECAPTCHA_TOKEN: "auth/missing-recaptcha-token";
+    readonly INVALID_RECAPTCHA_TOKEN: "auth/invalid-recaptcha-token";
+    readonly INVALID_RECAPTCHA_ACTION: "auth/invalid-recaptcha-action";
+    readonly MISSING_CLIENT_TYPE: "auth/missing-client-type";
+    readonly MISSING_RECAPTCHA_VERSION: "auth/missing-recaptcha-version";
+    readonly INVALID_RECAPTCHA_VERSION: "auth/invalid-recaptcha-version";
+    readonly INVALID_REQ_TYPE: "auth/invalid-req-type";
 };
 export {};

package/dist/cordova/src/core/index.d.ts

@@ -38,6 +38,32 @@ export { debugErrorMap, prodErrorMap, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY
  * @public
  */
 export declare function setPersistence(auth: Auth, persistence: Persistence): Promise<void>;
+/**
+ * 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.
+ *
+ * @example
+ * ```javascript
+ * initializeRecaptchaConfig(auth);
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ *
+ * @public
+ */
+export declare function initializeRecaptchaConfig(auth: Auth): Promise<void>;
 /**
  * Adds an observer for changes to the signed-in user's ID token.
  *

package/dist/cordova/src/core/util/handler.d.ts

@@ -17,4 +17,4 @@
 import { AuthProvider } from '../../model/public_types';
 import { AuthInternal } from '../../model/auth';
 import { AuthEventType } from '../../model/popup_redirect';
-export declare function _getRedirectUrl(auth: AuthInternal, provider: AuthProvider, authType: AuthEventType, redirectUrl?: string, eventId?: string, additionalParams?: Record<string, string>): string;
+export declare function _getRedirectUrl(auth: AuthInternal, provider: AuthProvider, authType: AuthEventType, redirectUrl?: string, eventId?: string, additionalParams?: Record<string, string>): Promise<string>;

package/dist/cordova/src/core/util/log.d.ts

@@ -19,4 +19,5 @@ export { LogLevel };
 export declare function _getLogLevel(): LogLevel;
 export declare function _setLogLevel(newLevel: LogLevel): void;
 export declare function _logDebug(msg: string, ...args: string[]): void;
+export declare function _logWarn(msg: string, ...args: string[]): void;
 export declare function _logError(msg: string, ...args: string[]): void;

package/dist/cordova/src/model/auth.d.ts

@@ -20,6 +20,7 @@ import { AuthErrorCode, AuthErrorParams } from '../core/errors';
 import { PopupRedirectResolverInternal } from './popup_redirect';
 import { UserInternal } from './user';
 import { ClientPlatform } from '../core/util/version';
+import { RecaptchaConfig } from '../platform_browser/recaptcha/recaptcha';
 export declare type AppName = string;
 export declare type ApiKey = string;
 export declare type AuthDomain = string;
@@ -47,6 +48,8 @@ export interface ConfigInternal extends Config {
 export interface AuthInternal extends Auth {
     currentUser: User | null;
     emulatorConfig: EmulatorConfig | null;
+    _agentRecaptchaConfig: RecaptchaConfig | null;
+    _tenantRecaptchaConfigs: Record<string, RecaptchaConfig>;
     _canInitEmulator: boolean;
     _isInitialized: boolean;
     _initializationPromise: Promise<void> | null;
@@ -61,9 +64,11 @@ export interface AuthInternal extends Auth {
     _startProactiveRefresh(): void;
     _stopProactiveRefresh(): void;
     _getPersistence(): string;
+    _getRecaptchaConfig(): RecaptchaConfig | null;
     _logFramework(framework: string): void;
     _getFrameworks(): readonly string[];
     _getAdditionalHeaders(): Promise<Record<string, string>>;
+    _getAppCheckToken(): Promise<string | undefined>;
     readonly name: AppName;
     readonly config: ConfigInternal;
     languageCode: string | null;
@@ -72,4 +77,5 @@ export interface AuthInternal extends Auth {
     _errorFactory: ErrorFactory<AuthErrorCode, AuthErrorParams>;
     useDeviceLanguage(): void;
     signOut(): Promise<void>;
+    initializeRecaptchaConfig(): Promise<void>;
 }

package/dist/cordova/src/platform_browser/auth_window.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Recaptcha } from './recaptcha/recaptcha';
+import { Recaptcha, GreCAPTCHATopLevel } from './recaptcha/recaptcha';
 /**
  * A specialized window type that melds the normal window type plus the
  * various bits we need. The three different blocks that are &'d together
@@ -23,7 +23,7 @@ import { Recaptcha } from './recaptcha/recaptcha';
 export declare type AuthWindow = {
     [T in keyof Window]: Window[T];
 } & {
-    grecaptcha?: Recaptcha;
+    grecaptcha?: Recaptcha | GreCAPTCHATopLevel;
     ___jsl?: Record<string, any>;
     gapi?: typeof gapi;
 } & {

package/dist/cordova/src/platform_browser/recaptcha/recaptcha.d.ts

@@ -15,9 +15,42 @@
  * limitations under the License.
  */
 import { RecaptchaParameters } from '../../model/public_types';
+import { GetRecaptchaConfigResponse } from '../../api/authentication/recaptcha';
 export interface Recaptcha {
     render: (container: HTMLElement, parameters: RecaptchaParameters) => number;
     getResponse: (id: number) => string;
     execute: (id: number) => unknown;
     reset: (id: number) => unknown;
 }
+export declare function isV2(grecaptcha: Recaptcha | GreCAPTCHA | undefined): grecaptcha is Recaptcha;
+export interface GreCAPTCHATopLevel extends GreCAPTCHA {
+    enterprise: GreCAPTCHA;
+}
+export interface GreCAPTCHA {
+    ready: (callback: () => void) => void;
+    execute: (siteKey: string, options: {
+        action: string;
+    }) => Promise<string>;
+    render: (container: string | HTMLElement, parameters: GreCAPTCHARenderOption) => string;
+}
+export interface GreCAPTCHARenderOption {
+    sitekey: string;
+    size: 'invisible';
+}
+export declare function isEnterprise(grecaptcha: Recaptcha | GreCAPTCHA | undefined): grecaptcha is GreCAPTCHATopLevel;
+declare global {
+    interface Window {
+        grecaptcha?: Recaptcha | GreCAPTCHATopLevel;
+    }
+}
+export declare class RecaptchaConfig {
+    /**
+     * The reCAPTCHA site key.
+     */
+    siteKey: string;
+    /**
+     * The reCAPTCHA enablement status of the {@link EmailAuthProvider} for the current tenant.
+     */
+    emailPasswordEnabled: boolean;
+    constructor(response: GetRecaptchaConfigResponse);
+}

package/dist/cordova/src/platform_browser/recaptcha/recaptcha.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+export {};

package/dist/cordova/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2022 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 { RecaptchaActionName } from '../../api';
+import { Auth } from '../../model/public_types';
+import { AuthInternal } from '../../model/auth';
+export declare const RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = "recaptcha-enterprise";
+export declare class RecaptchaEnterpriseVerifier {
+    /**
+     * Identifies the type of application verifier (e.g. "recaptcha-enterprise").
+     */
+    readonly type = "recaptcha-enterprise";
+    private readonly auth;
+    /**
+     *
+     * @param authExtern - The corresponding Firebase {@link Auth} instance.
+     *
+     */
+    constructor(authExtern: Auth);
+    /**
+     * Executes the verification process.
+     *
+     * @returns A Promise for a token that can be used to assert the validity of a request.
+     */
+    verify(action?: string, forceRefresh?: boolean): Promise<string>;
+}
+export declare function injectRecaptchaFields<T>(auth: AuthInternal, request: T, action: RecaptchaActionName, captchaResp?: boolean): Promise<T>;

package/dist/cordova/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+export {};

package/dist/cordova/src/platform_browser/recaptcha/recaptcha_mock.d.ts

@@ -16,7 +16,7 @@
  */
 import { AuthInternal } from '../../model/auth';
 import { RecaptchaParameters } from '../../model/public_types';
-import { Recaptcha } from './recaptcha';
+import { Recaptcha, GreCAPTCHATopLevel, GreCAPTCHARenderOption, GreCAPTCHA } from './recaptcha';
 export declare const _SOLVE_TIME_MS = 500;
 export declare const _EXPIRATION_TIME_MS = 60000;
 export declare const _WIDGET_ID_START = 1000000000000;
@@ -35,6 +35,21 @@ export declare class MockReCaptcha implements Recaptcha {
     getResponse(optWidgetId?: number): string;
     execute(optWidgetId?: number | string): Promise<string>;
 }
+export declare class MockGreCAPTCHATopLevel implements GreCAPTCHATopLevel {
+    enterprise: GreCAPTCHA;
+    ready(callback: () => void): void;
+    execute(_siteKey: string, _options: {
+        action: string;
+    }): Promise<string>;
+    render(_container: string | HTMLElement, _parameters: GreCAPTCHARenderOption): string;
+}
+export declare class MockGreCAPTCHA implements GreCAPTCHA {
+    ready(callback: () => void): void;
+    execute(_siteKey: string, _options: {
+        action: string;
+    }): Promise<string>;
+    render(_container: string | HTMLElement, _parameters: GreCAPTCHARenderOption): string;
+}
 export declare class MockWidget {
     private readonly params;
     private readonly container;

package/dist/cordova/test/helpers/api/helper.d.ts

@@ -17,4 +17,6 @@
 import { Endpoint } from '../../../src/api';
 import { Route } from '../mock_fetch';
 export declare function endpointUrl(endpoint: Endpoint): string;
+export declare function endpointUrlWithParams(endpoint: Endpoint, params: Record<string, any>): string;
 export declare function mockEndpoint(endpoint: Endpoint, response: object, status?: number): Route;
+export declare function mockEndpointWithParams(endpoint: Endpoint, params: Record<string, any>, response: object, status?: number): Route;

package/dist/cordova/test/helpers/mock_auth.d.ts

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 import { Provider } from '@firebase/component';
+import { AppCheckTokenResult } from '@firebase/app-check-interop-types';
 import { PopupRedirectResolver } from '../../src/model/public_types';
 import { AuthImpl } from '../../src/core/auth/auth_impl';
 import { PersistedBlob } from '../../src/core/persistence';
@@ -33,6 +34,10 @@ export declare const FAKE_HEARTBEAT_CONTROLLER: {
     getHeartbeatsHeader: () => Promise<string>;
 };
 export declare const FAKE_HEARTBEAT_CONTROLLER_PROVIDER: Provider<'heartbeat'>;
+export declare const FAKE_APP_CHECK_CONTROLLER: {
+    getToken: () => Promise<AppCheckTokenResult>;
+};
+export declare const FAKE_APP_CHECK_CONTROLLER_PROVIDER: Provider<'app-check-internal'>;
 export declare class MockPersistenceLayer extends InMemoryPersistence {
     lastObjectSet: PersistedBlob | null;
     _set(key: string, object: PersistedBlob): Promise<void>;