@depup/firebase__auth 1.12.1-depup.0

package/dist/src/model/user.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @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 { IdTokenResult, User, UserCredential, UserInfo } from './public_types';
+import { NextFn } from '@firebase/util';
+import { APIUserInfo } from '../api/account_management/account';
+import { FinalizeMfaResponse } from '../api/authentication/mfa';
+import { PersistedBlob } from '../core/persistence';
+import { StsTokenManager } from '../core/user/token_manager';
+import { UserMetadata } from '../core/user/user_metadata';
+import { AuthInternal } from './auth';
+import { IdTokenResponse, TaggedWithTokenResponse } from './id_token';
+import { ProviderId } from './enums';
+export type MutableUserInfo = {
+    -readonly [K in keyof UserInfo]: UserInfo[K];
+};
+export interface UserParameters {
+    uid: string;
+    auth: AuthInternal;
+    stsTokenManager: StsTokenManager;
+    displayName?: string | null;
+    email?: string | null;
+    phoneNumber?: string | null;
+    photoURL?: string | null;
+    isAnonymous?: boolean | null;
+    emailVerified?: boolean | null;
+    tenantId?: string | null;
+    providerData?: MutableUserInfo[] | null;
+    createdAt?: string | null;
+    lastLoginAt?: string | null;
+}
+/**
+ * UserInternal and AuthInternal reference each other, so both of them are included in the public typings.
+ * In order to exclude them, we mark them as internal explicitly.
+ *
+ * @internal
+ */
+export interface UserInternal extends User {
+    displayName: string | null;
+    email: string | null;
+    phoneNumber: string | null;
+    photoURL: string | null;
+    auth: AuthInternal;
+    providerId: ProviderId.FIREBASE;
+    refreshToken: string;
+    emailVerified: boolean;
+    tenantId: string | null;
+    providerData: MutableUserInfo[];
+    metadata: UserMetadata;
+    stsTokenManager: StsTokenManager;
+    _redirectEventId?: string;
+    _updateTokensIfNecessary(response: IdTokenResponse | FinalizeMfaResponse, reload?: boolean): Promise<void>;
+    _assign(user: UserInternal): void;
+    _clone(auth: AuthInternal): UserInternal;
+    _onReload: (cb: NextFn<APIUserInfo>) => void;
+    _notifyReloadListener: NextFn<APIUserInfo>;
+    _startProactiveRefresh: () => void;
+    _stopProactiveRefresh: () => void;
+    getIdToken(forceRefresh?: boolean): Promise<string>;
+    getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
+    reload(): Promise<void>;
+    delete(): Promise<void>;
+    toJSON(): PersistedBlob;
+}
+/**
+ * @internal
+ */
+export interface UserCredentialInternal extends UserCredential, TaggedWithTokenResponse {
+    user: UserInternal;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * @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 { 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
+ * cant be defined in the same block together.
+ */
+export type AuthWindow = {
+    [T in keyof Window]: Window[T];
+} & {
+    grecaptcha?: Recaptcha | GreCAPTCHATopLevel;
+    ___jsl?: Record<string, any>;
+    gapi?: typeof gapi;
+} & {
+    [callback: string]: (...args: unknown[]) => void;
+};
+/**
+ * Lazy accessor for window, since the compat layer won't tree shake this out,
+ * we need to make sure not to mess with window unless we have to
+ */
+export declare function _window(): AuthWindow;
+export declare function _setWindowLocation(url: string): void;

package/dist/src/platform_browser/iframe/gapi.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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 { AuthInternal } from '../../model/auth';
+export declare function _loadGapi(auth: AuthInternal): Promise<gapi.iframes.Context>;
+export declare function _resetLoader(): void;

package/dist/src/platform_browser/iframe/gapi.iframes.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @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.
+ */
+declare namespace gapi {
+    type LoadCallback = () => void;
+    interface LoadConfig {
+    }
+    interface LoadOptions {
+        callback?: LoadCallback;
+        timeout?: number;
+        ontimeout?: LoadCallback;
+    }
+    function load(features: 'gapi.iframes', options?: LoadOptions | LoadCallback): void;
+}
+declare namespace gapi.iframes {
+    interface Message {
+        type: string;
+    }
+    type IframesFilter = (iframe: Iframe) => boolean;
+    type MessageHandler<T extends Message> = (message: T) => unknown | Promise<void>;
+    type SendCallback = () => void;
+    type Callback = (iframe: Iframe) => void;
+    class Context {
+        open(options: Record<string, unknown>, callback?: Callback): Promise<Iframe>;
+    }
+    class Iframe {
+        register<T extends Message>(message: string, handler: MessageHandler<T>, filter?: IframesFilter): void;
+        send<T extends Message, U extends Message>(type: string, data: T, callback?: MessageHandler<U>, filter?: IframesFilter): void;
+        ping(callback: SendCallback, data?: unknown): Promise<unknown[]>;
+        restyle(style: Record<string, string | boolean>, callback?: SendCallback): Promise<unknown[]>;
+    }
+    const CROSS_ORIGIN_IFRAMES_FILTER: IframesFilter;
+    function getContext(): Context;
+}

package/dist/src/platform_browser/iframe/iframe.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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 { AuthInternal } from '../../model/auth';
+export declare function _openIframe(auth: AuthInternal): Promise<gapi.iframes.Iframe>;

package/dist/src/platform_browser/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2021 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 { FirebaseApp } from '@firebase/app';
+import { Auth } from '../model/public_types';
+/**
+ * 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?: FirebaseApp): Auth;

package/dist/src/platform_browser/load_js.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @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.
+ */
+interface ExternalJSProvider {
+    loadJS(url: string): Promise<Event>;
+    recaptchaV2Script: string;
+    recaptchaEnterpriseScript: string;
+    gapiScript: string;
+}
+export declare function _setExternalJSProvider(p: ExternalJSProvider): void;
+export declare function _loadJS(url: string): Promise<Event>;
+export declare function _recaptchaV2ScriptUrl(): string;
+export declare function _recaptchaEnterpriseScriptUrl(): string;
+export declare function _gapiScriptUrl(): string;
+export declare function _generateCallbackName(prefix: string): string;
+export {};

package/dist/src/platform_browser/messagechannel/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2019 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 { PromiseSettledResult } from './promise';
+export declare const enum _TimeoutDuration {
+    ACK = 50,
+    COMPLETION = 3000,
+    LONG_ACK = 800
+}
+/**
+ * Enumeration of possible response types from the Receiver.
+ */
+export declare const enum _Status {
+    ACK = "ack",
+    DONE = "done"
+}
+export declare const enum _MessageError {
+    CONNECTION_CLOSED = "connection_closed",
+    CONNECTION_UNAVAILABLE = "connection_unavailable",
+    INVALID_RESPONSE = "invalid_response",
+    TIMEOUT = "timeout",
+    UNKNOWN = "unknown_error",
+    UNSUPPORTED_EVENT = "unsupported_event"
+}
+/**
+ * Enumeration of possible events sent by the Sender.
+ */
+export declare const enum _EventType {
+    KEY_CHANGED = "keyChanged",
+    PING = "ping"
+}
+/**
+ * Response to a {@link EventType.KEY_CHANGED} event.
+ */
+export interface KeyChangedResponse {
+    keyProcessed: boolean;
+}
+/**
+ * Response to a {@link EventType.PING} event.
+ */
+export type _PingResponse = _EventType[];
+export type _ReceiverResponse = KeyChangedResponse | _PingResponse;
+interface MessageEvent {
+    eventType: _EventType;
+    eventId: string;
+}
+/**
+ * Request for a {@link EventType.KEY_CHANGED} event.
+ */
+export interface KeyChangedRequest {
+    key: string;
+}
+/**
+ * Request for a {@link EventType.PING} event.
+ */
+export interface PingRequest {
+}
+/** Data sent by Sender */
+export type _SenderRequest = KeyChangedRequest | PingRequest;
+/** Receiver handler to process events sent by the Sender */
+export interface ReceiverHandler<T extends _ReceiverResponse, S extends _SenderRequest> {
+    (origin: string, data: S): T | Promise<T>;
+}
+/** Full message sent by Sender  */
+export interface SenderMessageEvent<T extends _SenderRequest> extends MessageEvent {
+    data: T;
+}
+export type _ReceiverMessageResponse<T extends _ReceiverResponse> = Array<PromiseSettledResult<T>> | null;
+/** Full message sent by Receiver */
+export interface ReceiverMessageEvent<T extends _ReceiverResponse> extends MessageEvent {
+    status: _Status;
+    response: _ReceiverMessageResponse<T>;
+}
+export {};

package/dist/src/platform_browser/messagechannel/promise.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2019 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.
+ */
+/** TODO: remove this once tslib has a polyfill for Promise.allSettled */
+interface PromiseFulfilledResult<T> {
+    fulfilled: true;
+    value: T;
+}
+interface PromiseRejectedResult {
+    fulfilled: false;
+    reason: any;
+}
+export type PromiseSettledResult<T> = PromiseFulfilledResult<T> | PromiseRejectedResult;
+/**
+ * Shim for Promise.allSettled, note the slightly different format of `fulfilled` vs `status`.
+ *
+ * @param promises - Array of promises to wait on.
+ */
+export declare function _allSettled<T>(promises: Array<Promise<T>>): Promise<Array<PromiseSettledResult<T>>>;
+export {};

package/dist/src/platform_browser/messagechannel/receiver.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2019 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 { ReceiverHandler, _EventType, _ReceiverResponse, _SenderRequest } from './index';
+/**
+ * Interface class for receiving messages.
+ *
+ */
+export declare class Receiver {
+    private readonly eventTarget;
+    private static readonly receivers;
+    private readonly boundEventHandler;
+    private readonly handlersMap;
+    constructor(eventTarget: EventTarget);
+    /**
+     * Obtain an instance of a Receiver for a given event target, if none exists it will be created.
+     *
+     * @param eventTarget - An event target (such as window or self) through which the underlying
+     * messages will be received.
+     */
+    static _getInstance(eventTarget: EventTarget): Receiver;
+    private isListeningto;
+    /**
+     * Fans out a MessageEvent to the appropriate listeners.
+     *
+     * @remarks
+     * Sends an {@link Status.ACK} upon receipt and a {@link Status.DONE} once all handlers have
+     * finished processing.
+     *
+     * @param event - The MessageEvent.
+     *
+     */
+    private handleEvent;
+    /**
+     * Subscribe an event handler for a particular event.
+     *
+     * @param eventType - Event name to subscribe to.
+     * @param eventHandler - The event handler which should receive the events.
+     *
+     */
+    _subscribe<T extends _ReceiverResponse, S extends _SenderRequest>(eventType: _EventType, eventHandler: ReceiverHandler<T, S>): void;
+    /**
+     * Unsubscribe an event handler from a particular event.
+     *
+     * @param eventType - Event name to unsubscribe from.
+     * @param eventHandler - Optional event handler, if none provided, unsubscribe all handlers on this event.
+     *
+     */
+    _unsubscribe<T extends _ReceiverResponse, S extends _SenderRequest>(eventType: _EventType, eventHandler?: ReceiverHandler<T, S>): void;
+}

package/dist/src/platform_browser/messagechannel/sender.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2019 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 { _SenderRequest, _EventType, _ReceiverMessageResponse, _ReceiverResponse, _TimeoutDuration } from './index';
+/**
+ * Interface for sending messages and waiting for a completion response.
+ *
+ */
+export declare class Sender {
+    private readonly target;
+    private readonly handlers;
+    constructor(target: ServiceWorker);
+    /**
+     * Unsubscribe the handler and remove it from our tracking Set.
+     *
+     * @param handler - The handler to unsubscribe.
+     */
+    private removeMessageHandler;
+    /**
+     * Send a message to the Receiver located at {@link target}.
+     *
+     * @remarks
+     * We'll first wait a bit for an ACK , if we get one we will wait significantly longer until the
+     * receiver has had a chance to fully process the event.
+     *
+     * @param eventType - Type of event to send.
+     * @param data - The payload of the event.
+     * @param timeout - Timeout for waiting on an ACK from the receiver.
+     *
+     * @returns An array of settled promises from all the handlers that were listening on the receiver.
+     */
+    _send<T extends _ReceiverResponse, S extends _SenderRequest>(eventType: _EventType, data: S, timeout?: _TimeoutDuration): Promise<_ReceiverMessageResponse<T>>;
+}

package/dist/src/platform_browser/mfa/assertions/phone.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @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 { PhoneMultiFactorAssertion } from '../../../model/public_types';
+import { MultiFactorAssertionImpl } from '../../../mfa/mfa_assertion';
+import { AuthInternal } from '../../../model/auth';
+import { PhoneAuthCredential } from '../../../core/credentials/phone';
+import { FinalizeMfaResponse } from '../../../api/authentication/mfa';
+/**
+ * {@inheritdoc PhoneMultiFactorAssertion}
+ *
+ * @public
+ */
+export declare class PhoneMultiFactorAssertionImpl extends MultiFactorAssertionImpl implements PhoneMultiFactorAssertion {
+    private readonly credential;
+    private constructor();
+    /** @internal */
+    static _fromCredential(credential: PhoneAuthCredential): PhoneMultiFactorAssertionImpl;
+    /** @internal */
+    _finalizeEnroll(auth: AuthInternal, idToken: string, displayName?: string | null): Promise<FinalizeMfaResponse>;
+    /** @internal */
+    _finalizeSignIn(auth: AuthInternal, mfaPendingCredential: string): Promise<FinalizeMfaResponse>;
+}
+/**
+ * Provider for generating a {@link PhoneMultiFactorAssertion}.
+ *
+ * @public
+ */
+export declare class PhoneMultiFactorGenerator {
+    private constructor();
+    /**
+     * Provides a {@link PhoneMultiFactorAssertion} to confirm ownership of the phone second factor.
+     *
+     * @remarks
+     * This method does not work in a Node.js environment.
+     *
+     * @param phoneAuthCredential - A credential provided by {@link PhoneAuthProvider.credential}.
+     * @returns A {@link PhoneMultiFactorAssertion} which can be used with
+     * {@link MultiFactorResolver.resolveSignIn}
+     */
+    static assertion(credential: PhoneAuthCredential): PhoneMultiFactorAssertion;
+    /**
+     * The identifier of the phone second factor: `phone`.
+     */
+    static FACTOR_ID: string;
+}

package/dist/src/platform_browser/persistence/browser.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2019 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 { PersistenceValue, PersistenceType } from '../../core/persistence';
+export declare abstract class BrowserPersistenceClass {
+    protected readonly storageRetriever: () => Storage;
+    readonly type: PersistenceType;
+    protected constructor(storageRetriever: () => Storage, type: PersistenceType);
+    _isAvailable(): Promise<boolean>;
+    _set(key: string, value: PersistenceValue): Promise<void>;
+    _get<T extends PersistenceValue>(key: string): Promise<T | null>;
+    _remove(key: string): Promise<void>;
+    protected get storage(): Storage;
+}

package/dist/src/platform_browser/persistence/cookie_storage.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 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 { Persistence } from '../../model/public_types';
+import { PersistenceInternal, PersistenceType, PersistenceValue, StorageEventListener } from '../../core/persistence';
+export declare class CookiePersistence implements PersistenceInternal {
+    static type: 'COOKIE';
+    readonly type = PersistenceType.COOKIE;
+    listenerUnsubscribes: Map<StorageEventListener, () => void>;
+    _getFinalTarget(originalUrl: string): URL | string;
+    _isAvailable(): Promise<boolean>;
+    _set(_key: string, _value: PersistenceValue): Promise<void>;
+    _get<T extends PersistenceValue>(key: string): Promise<T | null>;
+    _remove(key: string): Promise<void>;
+    _addListener(key: string, listener: StorageEventListener): void;
+    _removeListener(_key: string, listener: StorageEventListener): void;
+}
+/**
+ * An implementation of {@link Persistence} of type `COOKIE`, for use on the client side in
+ * applications leveraging hybrid rendering and middleware.
+ *
+ * @remarks This persistence method requires companion middleware to function, such as that provided
+ * by {@link https://firebaseopensource.com/projects/firebaseextended/reactfire/ | ReactFire} for
+ * NextJS.
+ * @beta
+ */
+export declare const browserCookiePersistence: Persistence;

package/dist/src/platform_browser/persistence/indexed_db.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2019 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 { Persistence } from '../../model/public_types';
+import { PersistenceValue } from '../../core/persistence/';
+export declare const DB_NAME = "firebaseLocalStorageDb";
+export declare function _clearDatabase(db: IDBDatabase): Promise<void>;
+export declare function _deleteDatabase(): Promise<void>;
+export declare function _openDatabase(): Promise<IDBDatabase>;
+export declare function _putObject(db: IDBDatabase, key: string, value: PersistenceValue | string): Promise<void>;
+export declare function _deleteObject(db: IDBDatabase, key: string): Promise<void>;
+export declare const _POLLING_INTERVAL_MS = 800;
+export declare const _TRANSACTION_RETRY_COUNT = 3;
+/**
+ * An implementation of {@link Persistence} of type `LOCAL` using `indexedDB`
+ * for the underlying storage.
+ *
+ * @public
+ */
+export declare const indexedDBLocalPersistence: Persistence;