@angular/fire 19.2.0 → 20.0.0-rc.0

package/compat/firestore/collection-group/collection-group.d.ts

@@ -1,65 +0,0 @@
-import firebase from 'firebase/compat/app';
-import { Observable } from 'rxjs';
-import { AngularFirestore } from '../firestore';
-import { DocumentChangeAction, DocumentChangeType, DocumentData, Query } from '../interfaces';
-/**
- * AngularFirestoreCollectionGroup service
- *
- * This class holds a reference to a Firestore Collection Group Query.
- *
- * This class uses Symbol.observable to transform into Observable using Observable.from().
- *
- * This class is rarely used directly and should be created from the AngularFirestore service.
- *
- * Example:
- *
- * const collectionGroup = firebase.firestore.collectionGroup('stocks');
- * const query = collectionRef.where('price', '>', '0.01');
- * const fakeStock = new AngularFirestoreCollectionGroup<Stock>(query, afs);
- *
- * // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.
- * fakeStock.valueChanges().subscribe(value => console.log(value));
- */
-export declare class AngularFirestoreCollectionGroup<T = DocumentData> {
-    private readonly query;
-    private readonly afs;
-    private readonly injector;
-    /**
-     * The constructor takes in a CollectionGroupQuery to provide wrapper methods
-     * for data operations and data streaming.
-     */
-    constructor(query: Query<T>, afs: AngularFirestore);
-    /**
-     * Listen to the latest change in the stream. This method returns changes
-     * as they occur and they are not sorted by query order. This allows you to construct
-     * your own data structure.
-     */
-    stateChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]>;
-    /**
-     * Create a stream of changes as they occur it time. This method is similar to stateChanges()
-     * but it collects each event in an array over time.
-     */
-    auditTrail(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]>;
-    /**
-     * Create a stream of synchronized changes. This method keeps the local array in sorted
-     * query order.
-     */
-    snapshotChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]>;
-    /**
-     * Listen to all documents in the collection and its possible query as an Observable.
-     *
-     * If the `idField` option is provided, document IDs are included and mapped to the
-     * provided `idField` property name.
-     */
-    valueChanges(): Observable<T[]>;
-    valueChanges({}: {}): Observable<T[]>;
-    valueChanges<K extends string>(options: {
-        idField: K;
-    }): Observable<(T & {
-        [T in K]: string;
-    })[]>;
-    /**
-     * Retrieve the results of the query once.
-     */
-    get(options?: firebase.firestore.GetOptions): Observable<firebase.firestore.QuerySnapshot<T>>;
-}

package/compat/firestore/document/document.d.ts

@@ -1,74 +0,0 @@
-import firebase from 'firebase/compat/app';
-import { Observable } from 'rxjs';
-import { AngularFirestoreCollection } from '../collection/collection';
-import { AngularFirestore } from '../firestore';
-import { Action, DocumentData, DocumentReference, DocumentSnapshot, QueryFn, SetOptions } from '../interfaces';
-/**
- * AngularFirestoreDocument service
- *
- * This class creates a reference to a Firestore Document. A reference is provided in
- * in the constructor. The class is generic which gives you type safety for data update
- * methods and data streaming.
- *
- * This class uses Symbol.observable to transform into Observable using Observable.from().
- *
- * This class is rarely used directly and should be created from the AngularFirestore service.
- *
- * Example:
- *
- * const fakeStock = new AngularFirestoreDocument<Stock>(doc('stocks/FAKE'));
- * await fakeStock.set({ name: 'FAKE', price: 0.01 });
- * fakeStock.valueChanges().map(snap => {
- *   if(snap.exists) return snap.data();
- *   return null;
- * }).subscribe(value => console.log(value));
- * // OR! Transform using Observable.from() and the data is unwrapped for you
- * Observable.from(fakeStock).subscribe(value => console.log(value));
- */
-export declare class AngularFirestoreDocument<T = DocumentData> {
-    ref: DocumentReference<T>;
-    private afs;
-    private readonly injector;
-    /**
-     * The constructor takes in a DocumentReference to provide wrapper methods
-     * for data operations, data streaming, and Symbol.observable.
-     */
-    constructor(ref: DocumentReference<T>, afs: AngularFirestore);
-    /**
-     * Create or overwrite a single document.
-     */
-    set(data: T, options?: SetOptions): Promise<void>;
-    /**
-     * Update some fields of a document without overwriting the entire document.
-     */
-    update(data: Partial<T>): Promise<void>;
-    /**
-     * Delete a document.
-     */
-    delete(): Promise<void>;
-    /**
-     * Create a reference to a sub-collection given a path and an optional query
-     * function.
-     */
-    collection<R = DocumentData>(path: string, queryFn?: QueryFn): AngularFirestoreCollection<R>;
-    /**
-     * Listen to snapshot updates from the document.
-     */
-    snapshotChanges(): Observable<Action<DocumentSnapshot<T>>>;
-    /**
-     * Listen to unwrapped snapshot updates from the document.
-     *
-     * If the `idField` option is provided, document IDs are included and mapped to the
-     * provided `idField` property name.
-     */
-    valueChanges(options?: unknown): Observable<T | undefined>;
-    valueChanges<K extends string>(options: {
-        idField: K;
-    }): Observable<(T & {
-        [T in K]: string;
-    }) | undefined>;
-    /**
-     * Retrieve the document once.
-     */
-    get(options?: firebase.firestore.GetOptions): Observable<firebase.firestore.DocumentSnapshot<T>>;
-}

package/compat/firestore/firestore.d.ts

@@ -1,131 +0,0 @@
-import { InjectionToken, NgZone } from '@angular/core';
-import { ɵAngularFireSchedulers } from '@angular/fire';
-import { AppCheckInstances } from '@angular/fire/app-check';
-import { AngularFireAuth } from '@angular/fire/compat/auth';
-import { FirebaseOptions } from 'firebase/app';
-import firebase from 'firebase/compat/app';
-import { Observable } from 'rxjs';
-import { AngularFirestoreCollection } from './collection/collection';
-import { AngularFirestoreCollectionGroup } from './collection-group/collection-group';
-import { AngularFirestoreDocument } from './document/document';
-import { AssociatedReference, CollectionReference, DocumentReference, PersistenceSettings, QueryFn, QueryGroupFn, Settings } from './interfaces';
-import 'firebase/compat/auth';
-import 'firebase/compat/firestore';
-import * as i0 from "@angular/core";
-/**
- * The value of this token determines whether or not the firestore will have persistance enabled
- */
-export declare const ENABLE_PERSISTENCE: InjectionToken<boolean>;
-export declare const PERSISTENCE_SETTINGS: InjectionToken<firebase.firestore.PersistenceSettings>;
-export declare const SETTINGS: InjectionToken<firebase.firestore.Settings>;
-export declare const USE_EMULATOR: InjectionToken<[host: string, port: number, options?: {
-    mockUserToken?: firebase.firestore.EmulatorMockTokenOptions | string;
-}]>;
-/**
- * A utility methods for associating a collection reference with
- * a query.
- *
- * @param collectionRef - A collection reference to query
- * @param queryFn - The callback to create a query
- *
- * Example:
- * const { query, ref } = associateQuery(docRef.collection('items'), ref => {
- *  return ref.where('age', '<', 200);
- * });
- */
-export declare function associateQuery<T>(collectionRef: CollectionReference<T>, queryFn?: (ref: any) => any): AssociatedReference<T>;
-/**
- * AngularFirestore Service
- *
- * This service is the main entry point for this feature module. It provides
- * an API for creating Collection and Reference services. These services can
- * then be used to do data updates and observable streams of the data.
- *
- * Example:
- *
- * import { Component } from '@angular/core';
- * import { AngularFirestore, AngularFirestoreCollection, AngularFirestoreDocument } from '@angular/fire/firestore';
- * import { Observable } from 'rxjs/Observable';
- * import { from } from 'rxjs/observable';
- *
- * @Component({
- *   selector: 'app-my-component',
- *   template: `
- *    <h2>Items for {{ (profile | async)?.name }}
- *    <ul>
- *       <li *ngFor="let item of items | async">{{ item.name }}</li>
- *    </ul>
- *    <div class="control-input">
- *       <input type="text" #itemname />
- *       <button (click)="addItem(itemname.value)">Add Item</button>
- *    </div>
- *   `
- * })
- * export class MyComponent implements OnInit {
- *
- *   // services for data operations and data streaming
- *   private readonly itemsRef: AngularFirestoreCollection<Item>;
- *   private readonly profileRef: AngularFirestoreDocument<Profile>;
- *
- *   // observables for template
- *   items: Observable<Item[]>;
- *   profile: Observable<Profile>;
- *
- *   // inject main service
- *   constructor(private readonly afs: AngularFirestore) {}
- *
- *   ngOnInit() {
- *     this.itemsRef = afs.collection('items', ref => ref.where('user', '==', 'davideast').limit(10));
- *     this.items = this.itemsRef.valueChanges().map(snap => snap.docs.map(data => doc.data()));
- *     // this.items = from(this.itemsRef); // you can also do this with no mapping
- *
- *     this.profileRef = afs.doc('users/davideast');
- *     this.profile = this.profileRef.valueChanges();
- *   }
- *
- *   addItem(name: string) {
- *     const user = 'davideast';
- *     this.itemsRef.add({ name, user });
- *   }
- * }
- */
-export declare class AngularFirestore {
-    schedulers: ɵAngularFireSchedulers;
-    readonly firestore: firebase.firestore.Firestore;
-    readonly persistenceEnabled$: Observable<boolean>;
-    private readonly ngZone;
-    /**
-     * Each Feature of AngularFire has a FirebaseApp injected. This way we
-     * don't rely on the main Firebase App instance and we can create named
-     * apps and use multiple apps.
-     */
-    constructor(options: FirebaseOptions, name: string | null | undefined, shouldEnablePersistence: boolean | null, settings: Settings | null, platformId: Object, zone: NgZone, schedulers: ɵAngularFireSchedulers, persistenceSettings: PersistenceSettings | null, _useEmulator: any, auth: AngularFireAuth, useAuthEmulator: any, authSettings: any, // can't use firebase.auth.AuthSettings here
-    tenantId: string | null, languageCode: string | null, useDeviceLanguage: boolean | null, persistence: string | null, _appCheckInstances: AppCheckInstances);
-    /**
-     * Create a reference to a Firestore Collection based on a path or
-     * CollectionReference and an optional query function to narrow the result
-     * set.
-     */
-    collection<T>(path: string, queryFn?: QueryFn): AngularFirestoreCollection<T>;
-    collection<T>(ref: CollectionReference, queryFn?: QueryFn): AngularFirestoreCollection<T>;
-    /**
-     * Create a reference to a Firestore Collection Group based on a collectionId
-     * and an optional query function to narrow the result
-     * set.
-     */
-    collectionGroup<T>(collectionId: string, queryGroupFn?: QueryGroupFn<T>): AngularFirestoreCollectionGroup<T>;
-    /**
-     * Create a reference to a Firestore Document based on a path or
-     * DocumentReference. Note that documents are not queryable because they are
-     * simply objects. However, documents have sub-collections that return a
-     * Collection reference and can be queried.
-     */
-    doc<T>(path: string): AngularFirestoreDocument<T>;
-    doc<T>(ref: DocumentReference): AngularFirestoreDocument<T>;
-    /**
-     * Returns a generated Firestore Document Id.
-     */
-    createId(): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirestore, [null, { optional: true; }, { optional: true; }, { optional: true; }, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFirestore>;
-}

package/compat/firestore/firestore.module.d.ts

@@ -1,13 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { PersistenceSettings } from './interfaces';
-import * as i0 from "@angular/core";
-export declare class AngularFirestoreModule {
-    constructor();
-    /**
-     * Attempt to enable persistent storage, if possible
-     */
-    static enablePersistence(persistenceSettings?: PersistenceSettings): ModuleWithProviders<AngularFirestoreModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirestoreModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirestoreModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFirestoreModule>;
-}

package/compat/firestore/interfaces.d.ts

@@ -1,70 +0,0 @@
-import firebase from 'firebase/compat/app';
-import { Subscriber } from 'rxjs';
-export type Settings = firebase.firestore.Settings;
-export type CollectionReference<T = DocumentData> = firebase.firestore.CollectionReference<T>;
-export type DocumentReference<T = DocumentData> = firebase.firestore.DocumentReference<T>;
-export type PersistenceSettings = firebase.firestore.PersistenceSettings;
-export type DocumentChangeType = firebase.firestore.DocumentChangeType;
-export type SnapshotOptions = firebase.firestore.SnapshotOptions;
-export type FieldPath = firebase.firestore.FieldPath;
-export type Query<T = DocumentData> = firebase.firestore.Query<T>;
-export type SetOptions = firebase.firestore.SetOptions;
-export type DocumentData = firebase.firestore.DocumentData;
-export interface DocumentSnapshotExists<T> extends firebase.firestore.DocumentSnapshot<T> {
-    readonly exists: true;
-    data(options?: SnapshotOptions): T;
-}
-export interface DocumentSnapshotDoesNotExist extends firebase.firestore.DocumentSnapshot {
-    readonly exists: false;
-    data(options?: SnapshotOptions): undefined;
-    get(fieldPath: string | FieldPath, options?: SnapshotOptions): undefined;
-}
-export type DocumentSnapshot<T> = DocumentSnapshotExists<T> | DocumentSnapshotDoesNotExist;
-export interface QueryDocumentSnapshot<T> extends firebase.firestore.QueryDocumentSnapshot<T> {
-    data(options?: SnapshotOptions): T;
-}
-export interface QuerySnapshot<T> extends firebase.firestore.QuerySnapshot<T> {
-    readonly docs: QueryDocumentSnapshot<T>[];
-}
-export interface DocumentChange<T> extends firebase.firestore.DocumentChange<T> {
-    readonly doc: QueryDocumentSnapshot<T>;
-}
-export interface DocumentChangeAction<T> {
-    type: DocumentChangeType;
-    payload: DocumentChange<T>;
-}
-export interface Action<T> {
-    type: string;
-    payload: T;
-}
-export interface Reference {
-    onSnapshot: (options: firebase.firestore.SnapshotListenOptions, sub: Subscriber<any>) => any;
-}
-export type QueryFn<T = DocumentData> = (ref: CollectionReference<T>) => Query<T>;
-export type QueryGroupFn<T = DocumentData> = (query: Query<T>) => Query<T>;
-/**
- * A structure that provides an association between a reference
- * and a query on that reference. Note: Performing operations
- * on the reference can lead to confusing results with complicated
- * queries.
- *
- * Example:
- *
- * const query = ref.where('type', '==', 'Book').
- *                  .where('price', '>' 18.00)
- *                  .where('price', '<' 100.00)
- *                  .where('category', '==', 'Fiction')
- *                  .where('publisher', '==', 'BigPublisher')
- *
- * // This addition would not be a result of the query above
- * ref.add({
- *  type: 'Magazine',
- *  price: 4.99,
- *  category: 'Sports',
- *  publisher: 'SportsPublisher'
- * });
- */
-export interface AssociatedReference<T = DocumentData> {
-    ref: CollectionReference<T>;
-    query: Query<T>;
-}

package/compat/firestore/observable/fromRef.d.ts

@@ -1,5 +0,0 @@
-import { Observable, SchedulerLike } from 'rxjs';
-import { Action, DocumentReference, DocumentSnapshot, Query, QuerySnapshot } from '../interfaces';
-export declare function fromRef<R, T>(ref: DocumentReference<T> | Query<T>, scheduler?: SchedulerLike): Observable<R>;
-export declare function fromDocRef<T>(ref: DocumentReference<T>, scheduler?: SchedulerLike): Observable<Action<DocumentSnapshot<T>>>;
-export declare function fromCollectionRef<T>(ref: Query<T>, scheduler?: SchedulerLike): Observable<Action<QuerySnapshot<T>>>;

package/compat/firestore/public_api.d.ts

@@ -1,8 +0,0 @@
-export * from './firestore';
-export * from './firestore.module';
-export * from './collection/collection';
-export * from './collection-group/collection-group';
-export * from './document/document';
-export * from './collection/changes';
-export * from './observable/fromRef';
-export * from './interfaces';

package/compat/functions/base.d.ts

@@ -1,5 +0,0 @@
-export declare const proxyPolyfillCompat: {
-    useEmulator: any;
-    useFunctionsEmulator: any;
-    httpsCallable: any;
-};

package/compat/functions/functions.d.ts

@@ -1,21 +0,0 @@
-import { InjectionToken, NgZone } from '@angular/core';
-import { ɵAngularFireSchedulers } from '@angular/fire';
-import { AppCheckInstances } from '@angular/fire/app-check';
-import { ɵPromiseProxy } from '@angular/fire/compat';
-import { HttpsCallableOptions } from '@firebase/functions-types';
-import { FirebaseOptions } from 'firebase/app';
-import firebase from 'firebase/compat/app';
-import { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-export declare const ORIGIN: InjectionToken<string>;
-export declare const REGION: InjectionToken<string>;
-export declare const USE_EMULATOR: InjectionToken<[host: string, port: number]>;
-export interface AngularFireFunctions extends Omit<ɵPromiseProxy<firebase.functions.Functions>, 'httpsCallable'> {
-}
-export declare class AngularFireFunctions {
-    readonly httpsCallable: <T = any, R = any>(name: string, options?: HttpsCallableOptions) => (data: T) => Observable<R>;
-    constructor(options: FirebaseOptions, name: string | null | undefined, zone: NgZone, schedulers: ɵAngularFireSchedulers, region: string | null, origin: string | null, _useEmulator: any, // can't use the tuple here
-    _appCheckInstances: AppCheckInstances);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireFunctions, [null, { optional: true; }, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFireFunctions>;
-}

package/compat/functions/functions.module.d.ts

@@ -1,7 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class AngularFireFunctionsModule {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireFunctionsModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFireFunctionsModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFireFunctionsModule>;
-}

package/compat/functions/public_api.d.ts

@@ -1,3 +0,0 @@
-import 'firebase/compat/functions';
-export * from './functions';
-export * from './functions.module';

package/compat/messaging/base.d.ts

@@ -1,6 +0,0 @@
-export declare const proxyPolyfillCompat: {
-    deleteToken: any;
-    getToken: any;
-    onMessage: any;
-    onBackgroundMessage: any;
-};

package/compat/messaging/messaging.d.ts

@@ -1,22 +0,0 @@
-import { InjectionToken, NgZone } from '@angular/core';
-import { ɵAngularFireSchedulers } from '@angular/fire';
-import { ɵPromiseProxy } from '@angular/fire/compat';
-import { FirebaseOptions } from 'firebase/app';
-import firebase from 'firebase/compat/app';
-import { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-export declare const VAPID_KEY: InjectionToken<string>;
-export declare const SERVICE_WORKER: InjectionToken<Promise<ServiceWorkerRegistration>>;
-export interface AngularFireMessaging extends Omit<ɵPromiseProxy<firebase.messaging.Messaging>, 'deleteToken' | 'getToken' | 'requestPermission'> {
-}
-export declare class AngularFireMessaging {
-    readonly requestPermission: Observable<NotificationPermission>;
-    readonly getToken: Observable<string | null>;
-    readonly tokenChanges: Observable<string | null>;
-    readonly messages: Observable<firebase.messaging.MessagePayload>;
-    readonly requestToken: Observable<string | null>;
-    readonly deleteToken: (token: string) => Observable<boolean>;
-    constructor(options: FirebaseOptions, name: string | null | undefined, platformId: Object, zone: NgZone, schedulers: ɵAngularFireSchedulers, vapidKey: string | null, _serviceWorker: any);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireMessaging, [null, { optional: true; }, null, null, null, { optional: true; }, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFireMessaging>;
-}

package/compat/messaging/messaging.module.d.ts

@@ -1,7 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class AngularFireMessagingModule {
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireMessagingModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFireMessagingModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFireMessagingModule>;
-}

package/compat/messaging/public_api.d.ts

@@ -1,2 +0,0 @@
-export * from './messaging';
-export * from './messaging.module';

package/compat/performance/base.d.ts

@@ -1,6 +0,0 @@
-export declare const proxyPolyfillCompat: {
-    app: any;
-    trace: any;
-    instrumentationEnabled: any;
-    dataCollectionEnabled: any;
-};

package/compat/performance/performance.d.ts

@@ -1,26 +0,0 @@
-import { InjectionToken, NgZone } from '@angular/core';
-import { ɵPromiseProxy } from '@angular/fire/compat';
-import { FirebaseApp } from '@angular/fire/compat';
-import firebase from 'firebase/compat/app';
-import { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-export declare const INSTRUMENTATION_ENABLED: InjectionToken<boolean>;
-export declare const DATA_COLLECTION_ENABLED: InjectionToken<boolean>;
-export interface AngularFirePerformance extends ɵPromiseProxy<firebase.performance.Performance> {
-}
-export declare class AngularFirePerformance {
-    private zone;
-    private readonly performance;
-    constructor(app: FirebaseApp, instrumentationEnabled: boolean | null, dataCollectionEnabled: boolean | null, zone: NgZone, platformId: Object);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirePerformance, [null, { optional: true; }, { optional: true; }, null, null]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFirePerformance>;
-}
-export declare const traceUntil: <T = any>(name: string, test: (a: T) => boolean, options?: {
-    orComplete?: boolean;
-}) => (source$: Observable<T>) => Observable<T>;
-export declare const traceWhile: <T = any>(name: string, test: (a: T) => boolean, options?: {
-    orComplete?: boolean;
-}) => (source$: Observable<T>) => Observable<T>;
-export declare const traceUntilComplete: <T = any>(name: string) => (source$: Observable<T>) => Observable<T>;
-export declare const traceUntilFirst: <T = any>(name: string) => (source$: Observable<T>) => Observable<T>;
-export declare const trace: <T = any>(name: string) => (source$: Observable<T>) => Observable<T>;

package/compat/performance/performance.module.d.ts

@@ -1,9 +0,0 @@
-import { AngularFirePerformance } from './performance';
-import { PerformanceMonitoringService } from './performance.service';
-import * as i0 from "@angular/core";
-export declare class AngularFirePerformanceModule {
-    constructor(perf: AngularFirePerformance, _: PerformanceMonitoringService);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFirePerformanceModule, [null, { optional: true; }]>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFirePerformanceModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFirePerformanceModule>;
-}

package/compat/performance/performance.service.d.ts

@@ -1,9 +0,0 @@
-import { ApplicationRef, OnDestroy } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class PerformanceMonitoringService implements OnDestroy {
-    private disposable;
-    constructor(appRef: ApplicationRef);
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceMonitoringService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<PerformanceMonitoringService>;
-}

package/compat/performance/public_api.d.ts

@@ -1,3 +0,0 @@
-export * from './performance';
-export * from './performance.module';
-export * from './performance.service';

package/compat/proxy.d.ts

@@ -1,32 +0,0 @@
-import { NgZone } from '@angular/core';
-import { Observable } from 'rxjs';
-type MyFunction = (...args: any[]) => any;
-type FunctionPropertyNames<T> = {
-    [K in keyof T]: T[K] extends MyFunction ? K : never;
-}[keyof T];
-type ReturnTypeOrNever<T> = T extends MyFunction ? ReturnType<T> : never;
-type ParametersOrNever<T> = T extends MyFunction ? Parameters<T> : never;
-type PromiseReturningFunctionPropertyNames<T> = {
-    [K in FunctionPropertyNames<T>]: ReturnTypeOrNever<T[K]> extends Promise<any> ? K : never;
-}[FunctionPropertyNames<T>];
-type NonPromiseReturningFunctionPropertyNames<T> = {
-    [K in FunctionPropertyNames<T>]: ReturnTypeOrNever<T[K]> extends Promise<any> ? never : K;
-}[FunctionPropertyNames<T>];
-type NonFunctionPropertyNames<T> = {
-    [K in keyof T]: T[K] extends MyFunction ? never : K;
-}[keyof T];
-export type ɵPromiseProxy<T> = {
-    [K in NonFunctionPropertyNames<T>]: Promise<T[K]>;
-} & {
-    [K in NonPromiseReturningFunctionPropertyNames<T>]: (...args: ParametersOrNever<T[K]>) => Promise<ReturnTypeOrNever<T[K]>>;
-} & {
-    [K in PromiseReturningFunctionPropertyNames<T>]: T[K];
-};
-export declare const ɵlazySDKProxy: (klass: any, observable: Observable<any>, zone: NgZone, options?: {
-    spy?: {
-        get?: ((name: string, it: any) => void);
-        apply?: ((name: string, args: any[], it: any) => void);
-    };
-}) => any;
-export declare const ɵapplyMixins: (derivedCtor: any, constructors: any[]) => void;
-export {};

package/compat/public_api.d.ts

@@ -1,4 +0,0 @@
-export * from './proxy';
-export * from './firebase.app';
-export * from './firebase.app.module';
-export * from './cache';

package/compat/remote-config/base.d.ts

@@ -1,17 +0,0 @@
-export declare const proxyPolyfillCompat: {
-    app: any;
-    settings: any;
-    defaultConfig: any;
-    fetchTimeMillis: any;
-    lastFetchStatus: any;
-    activate: any;
-    ensureInitialized: any;
-    fetch: any;
-    fetchAndActivate: any;
-    getAll: any;
-    getBoolean: any;
-    getNumber: any;
-    getString: any;
-    getValue: any;
-    setLogLevel: any;
-};

package/compat/remote-config/interfaces.d.ts

@@ -1,2 +0,0 @@
-import firebase from 'firebase/compat/app';
-export type Settings = firebase.remoteConfig.Settings;

package/compat/remote-config/public_api.d.ts

@@ -1,2 +0,0 @@
-export * from './remote-config';
-export * from './remote-config.module';

package/compat/remote-config/remote-config.d.ts

@@ -1,52 +0,0 @@
-import { InjectionToken, NgZone } from '@angular/core';
-import { ɵAngularFireSchedulers } from '@angular/fire';
-import { ɵPromiseProxy } from '@angular/fire/compat';
-import { FirebaseOptions } from 'firebase/app';
-import firebase from 'firebase/compat/app';
-import { MonoTypeOperatorFunction, Observable, OperatorFunction } from 'rxjs';
-import { Settings } from './interfaces';
-import * as i0 from "@angular/core";
-export type ConfigTemplate = Record<string, string | number | boolean>;
-export declare const SETTINGS: InjectionToken<firebase.remoteConfig.Settings>;
-export declare const DEFAULTS: InjectionToken<ConfigTemplate>;
-export interface AngularFireRemoteConfig extends ɵPromiseProxy<firebase.remoteConfig.RemoteConfig> {
-}
-export declare class Value implements firebase.remoteConfig.Value {
-    _source: firebase.remoteConfig.ValueSource;
-    _value: string;
-    asBoolean(): boolean;
-    asString(): string;
-    asNumber(): number;
-    getSource(): firebase.remoteConfig.ValueSource;
-    constructor(_source: firebase.remoteConfig.ValueSource, _value: string);
-}
-export declare class Parameter extends Value {
-    key: string;
-    fetchTimeMillis: number;
-    constructor(key: string, fetchTimeMillis: number, source: firebase.remoteConfig.ValueSource, value: string);
-}
-export declare const filterRemote: () => MonoTypeOperatorFunction<Parameter | Parameter[]>;
-export declare const filterFresh: (howRecentInMillis: number) => MonoTypeOperatorFunction<Parameter | Parameter[]>;
-export declare class AngularFireRemoteConfig {
-    private zone;
-    readonly changes: Observable<Parameter>;
-    readonly parameters: Observable<Parameter[]>;
-    readonly numbers: Observable<Record<string, number | undefined>> & Record<string, Observable<number>>;
-    readonly booleans: Observable<Record<string, boolean | undefined>> & Record<string, Observable<boolean>>;
-    readonly strings: Observable<Record<string, string | undefined>> & Record<string, Observable<string | undefined>>;
-    private readonly injector;
-    constructor(options: FirebaseOptions, name: string | null | undefined, settings: Settings | null, defaultConfig: ConfigTemplate | null, zone: NgZone, schedulers: ɵAngularFireSchedulers, platformId: Object);
-    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireRemoteConfig, [null, { optional: true; }, { optional: true; }, { optional: true; }, null, null, null]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFireRemoteConfig>;
-}
-export declare const budget: <T>(interval: number) => MonoTypeOperatorFunction<T>;
-export declare function scanToObject(): OperatorFunction<Parameter, Record<string, string | undefined>>;
-export declare function scanToObject(to: 'numbers'): OperatorFunction<Parameter, Record<string, number | undefined>>;
-export declare function scanToObject(to: 'booleans'): OperatorFunction<Parameter, Record<string, boolean | undefined>>;
-export declare function scanToObject(to: 'strings'): OperatorFunction<Parameter, Record<string, string | undefined>>;
-export declare function scanToObject<T extends ConfigTemplate>(template: T): OperatorFunction<Parameter, T & Record<string, string | undefined>>;
-export declare function mapToObject(): OperatorFunction<Parameter[], Record<string, string | undefined>>;
-export declare function mapToObject(to: 'numbers'): OperatorFunction<Parameter[], Record<string, number | undefined>>;
-export declare function mapToObject(to: 'booleans'): OperatorFunction<Parameter[], Record<string, boolean | undefined>>;
-export declare function mapToObject(to: 'strings'): OperatorFunction<Parameter[], Record<string, string | undefined>>;
-export declare function mapToObject<T extends ConfigTemplate>(template: T): OperatorFunction<Parameter[], T & Record<string, string | undefined>>;