Deployed the page to Github Pages.

node_modules/@angular/fire/compat/firestore/collection/changes.d.ts

@@ -0,0 +1,22 @@
+import { Observable, SchedulerLike } from 'rxjs';
+import { DocumentChange, DocumentChangeAction, DocumentChangeType, Query } from '../interfaces';
+/**
+ * Return a stream of document changes on a query. These results are not in sort order but in
+ * order of occurence.
+ */
+export declare function docChanges<T>(query: Query, scheduler?: SchedulerLike): Observable<DocumentChangeAction<T>[]>;
+/**
+ * Return a stream of document changes on a query. These results are in sort order.
+ */
+export declare function sortedChanges<T>(query: Query, events: DocumentChangeType[], scheduler?: SchedulerLike): Observable<DocumentChangeAction<T>[]>;
+/**
+ * Combines the total result set from the current set of changes from an incoming set
+ * of changes.
+ */
+export declare function combineChanges<T>(current: DocumentChange<T>[], changes: DocumentChange<T>[], events: DocumentChangeType[]): DocumentChange<T>[];
+/**
+ * Creates a new sorted array from a new change.
+ * Build our own because we allow filtering of action types ('added', 'removed', 'modified') before scanning
+ * and so we have greater control over change detection (by breaking ===)
+ */
+export declare function combineChange<T>(combined: DocumentChange<T>[], change: DocumentChange<T>): DocumentChange<T>[];

node_modules/@angular/fire/compat/firestore/collection/collection.d.ts

@@ -0,0 +1,89 @@
+import { Observable } from 'rxjs';
+import firebase from 'firebase/compat/app';
+import { CollectionReference, DocumentChangeAction, DocumentChangeType, DocumentData, DocumentReference, Query } from '../interfaces';
+import { AngularFirestoreDocument } from '../document/document';
+import { AngularFirestore } from '../firestore';
+export declare function validateEventsArray(events?: DocumentChangeType[]): firebase.firestore.DocumentChangeType[];
+/**
+ * AngularFirestoreCollection service
+ *
+ * This class creates a reference to a Firestore Collection. A reference and a query are provided in
+ * in the constructor. The query can be the unqueried reference if no query is desired.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 collectionRef = firebase.firestore.collection('stocks');
+ * const query = collectionRef.where('price', '>', '0.01');
+ * const fakeStock = new AngularFirestoreCollection<Stock>(collectionRef, query);
+ *
+ * // NOTE!: the updates are performed on the reference not the query
+ * await fakeStock.add({ name: 'FAKE', price: 0.01 });
+ *
+ * // 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 AngularFirestoreCollection<T = DocumentData> {
+    readonly ref: CollectionReference<T>;
+    private readonly query;
+    private readonly afs;
+    /**
+     * The constructor takes in a CollectionReference and Query to provide wrapper methods
+     * for data operations and data streaming.
+     *
+     * Note: Data operation methods are done on the reference not the query. This means
+     * when you update data it is not updating data to the window of your query unless
+     * the data fits the criteria of the query. See the AssociatedRefence type for details
+     * on this implication.
+     */
+    constructor(ref: CollectionReference<T>, 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>>;
+    /**
+     * Add data to a collection reference.
+     *
+     * Note: Data operation methods are done on the reference not the query. This means
+     * when you update data it is not updating data to the window of your query unless
+     * the data fits the criteria of the query.
+     */
+    add(data: T): Promise<DocumentReference<T>>;
+    /**
+     * Create a reference to a single document in a collection.
+     */
+    doc<T2 = T>(path?: string): AngularFirestoreDocument<T2>;
+}