pain

24 files changed, 2636 insertions, 0 deletions

diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/aggregate.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/aggregate.d.ts
new file mode 100644
index 0000000..39bd4b4
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/aggregate.d.ts
@@ -0,0 +1,77 @@
+/**
+ * @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 { AggregateField, AggregateSpec, DocumentData, Query } from '../api';
+import { AggregateQuerySnapshot } from '../lite-api/aggregate_types';
+export { aggregateQuerySnapshotEqual, count, sum, average, aggregateFieldEqual } from '../lite-api/aggregate';
+/**
+ * Calculates the number of documents in the result set of the given query
+ * without actually downloading the documents.
+ *
+ * Using this function to count the documents is efficient because only the
+ * final count, not the documents' data, is downloaded. This function can
+ * count the documents in cases where the result set is prohibitively large to
+ * download entirely (thousands of documents).
+ *
+ * The result received from the server is presented, unaltered, without
+ * considering any local state. That is, documents in the local cache are not
+ * taken into consideration, neither are local modifications not yet
+ * synchronized with the server. Previously-downloaded results, if any, are not
+ * used. Every invocation of this function necessarily involves a round trip to
+ * the server.
+ *
+ * @param query The query whose result set size is calculated.
+ * @returns A Promise that will be resolved with the count; the count can be
+ * retrieved from `snapshot.data().count`, where `snapshot` is the
+ * `AggregateQuerySnapshot` to which the returned Promise resolves.
+ */
+export declare function getCountFromServer<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>): Promise<AggregateQuerySnapshot<{
+    count: AggregateField<number>;
+}, AppModelType, DbModelType>>;
+/**
+ * Calculates the specified aggregations over the documents in the result
+ * set of the given query without actually downloading the documents.
+ *
+ * Using this function to perform aggregations is efficient because only the
+ * final aggregation values, not the documents' data, are downloaded. This
+ * function can perform aggregations of the documents in cases where the result
+ * set is prohibitively large to download entirely (thousands of documents).
+ *
+ * The result received from the server is presented, unaltered, without
+ * considering any local state. That is, documents in the local cache are not
+ * taken into consideration, neither are local modifications not yet
+ * synchronized with the server. Previously-downloaded results, if any, are not
+ * used. Every invocation of this function necessarily involves a round trip to
+ * the server.
+ *
+ * @param query The query whose result set is aggregated over.
+ * @param aggregateSpec An `AggregateSpec` object that specifies the aggregates
+ * to perform over the result set. The AggregateSpec specifies aliases for each
+ * aggregate, which can be used to retrieve the aggregate result.
+ * @example
+ * ```typescript
+ * const aggregateSnapshot = await getAggregateFromServer(query, {
+ *   countOfDocs: count(),
+ *   totalHours: sum('hours'),
+ *   averageScore: average('score')
+ * });
+ *
+ * const countOfDocs: number = aggregateSnapshot.data().countOfDocs;
+ * const totalHours: number = aggregateSnapshot.data().totalHours;
+ * const averageScore: number | null = aggregateSnapshot.data().averageScore;
+ * ```
+ */
+export declare function getAggregateFromServer<AggregateSpecType extends AggregateSpec, AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>, aggregateSpec: AggregateSpecType): Promise<AggregateQuerySnapshot<AggregateSpecType, AppModelType, DbModelType>>;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bundle.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bundle.d.ts
new file mode 100644
index 0000000..15c33af
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bundle.d.ts
@@ -0,0 +1,94 @@
+/**
+ * @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 { FirestoreError } from '../util/error';
+/**
+ * Represents the state of bundle loading tasks.
+ *
+ * Both 'Error' and 'Success' are sinking state: task will abort or complete and there will
+ * be no more updates after they are reported.
+ */
+export type TaskState = 'Error' | 'Running' | 'Success';
+/**
+ * Represents a progress update or a final state from loading bundles.
+ */
+export interface LoadBundleTaskProgress {
+    /** How many documents have been loaded. */
+    documentsLoaded: number;
+    /** How many documents are in the bundle being loaded. */
+    totalDocuments: number;
+    /** How many bytes have been loaded. */
+    bytesLoaded: number;
+    /** How many bytes are in the bundle being loaded. */
+    totalBytes: number;
+    /** Current task state. */
+    taskState: TaskState;
+}
+/**
+ * Represents the task of loading a Firestore bundle. It provides progress of bundle
+ * loading, as well as task completion and error events.
+ *
+ * The API is compatible with `Promise<LoadBundleTaskProgress>`.
+ */
+export declare class LoadBundleTask implements PromiseLike<LoadBundleTaskProgress> {
+    private _progressObserver;
+    private _taskCompletionResolver;
+    private _lastProgress;
+    /**
+     * Registers functions to listen to bundle loading progress events.
+     * @param next - Called when there is a progress update from bundle loading. Typically `next` calls occur
+     *   each time a Firestore document is loaded from the bundle.
+     * @param error - Called when an error occurs during bundle loading. The task aborts after reporting the
+     *   error, and there should be no more updates after this.
+     * @param complete - Called when the loading task is complete.
+     */
+    onProgress(next?: (progress: LoadBundleTaskProgress) => unknown, error?: (err: Error) => unknown, complete?: () => void): void;
+    /**
+     * Implements the `Promise<LoadBundleTaskProgress>.catch` interface.
+     *
+     * @param onRejected - Called when an error occurs during bundle loading.
+     */
+    catch<R>(onRejected: (a: Error) => R | PromiseLike<R>): Promise<R | LoadBundleTaskProgress>;
+    /**
+     * Implements the `Promise<LoadBundleTaskProgress>.then` interface.
+     *
+     * @param onFulfilled - Called on the completion of the loading task with a final `LoadBundleTaskProgress` update.
+     *   The update will always have its `taskState` set to `"Success"`.
+     * @param onRejected - Called when an error occurs during bundle loading.
+     */
+    then<T, R>(onFulfilled?: (a: LoadBundleTaskProgress) => T | PromiseLike<T>, onRejected?: (a: Error) => R | PromiseLike<R>): Promise<T | R>;
+    /**
+     * Notifies all observers that bundle loading has completed, with a provided
+     * `LoadBundleTaskProgress` object.
+     *
+     * @private
+     */
+    _completeWith(progress: LoadBundleTaskProgress): void;
+    /**
+     * Notifies all observers that bundle loading has failed, with a provided
+     * `Error` as the reason.
+     *
+     * @private
+     */
+    _failWith(error: FirestoreError): void;
+    /**
+     * Notifies a progress update of loading a bundle.
+     * @param progress - The new progress.
+     *
+     * @private
+     */
+    _updateProgress(progress: LoadBundleTaskProgress): void;
+}
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bytes.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bytes.d.ts
new file mode 100644
index 0000000..0c9f5fd
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bytes.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { Bytes } from '../lite-api/bytes';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/cache_config.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/cache_config.d.ts
new file mode 100644
index 0000000..936f21e
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/cache_config.d.ts
@@ -0,0 +1,222 @@
+/**
+ * @license
+ * Copyright 2023 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 { OfflineComponentProviderFactory, OnlineComponentProviderFactory } from '../core/component_provider';
+/**
+ * Provides an in-memory cache to the SDK. This is the default cache unless explicitly
+ * configured otherwise.
+ *
+ * To use, create an instance using the factory function {@link memoryLocalCache()}, then
+ * set the instance to `FirestoreSettings.cache` and call `initializeFirestore` using
+ * the settings object.
+ */
+export type MemoryLocalCache = {
+    kind: 'memory';
+    /**
+     * @internal
+     */
+    _onlineComponentProvider: OnlineComponentProviderFactory;
+    /**
+     * @internal
+     */
+    _offlineComponentProvider: OfflineComponentProviderFactory;
+};
+/**
+ * Provides a persistent cache backed by IndexedDb to the SDK.
+ *
+ * To use, create an instance using the factory function {@link persistentLocalCache()}, then
+ * set the instance to `FirestoreSettings.cache` and call `initializeFirestore` using
+ * the settings object.
+ */
+export type PersistentLocalCache = {
+    kind: 'persistent';
+    /**
+     * @internal
+     */
+    _onlineComponentProvider: OnlineComponentProviderFactory;
+    /**
+     * @internal
+     */
+    _offlineComponentProvider: OfflineComponentProviderFactory;
+};
+/**
+ * Union type from all supported SDK cache layer.
+ */
+export type FirestoreLocalCache = MemoryLocalCache | PersistentLocalCache;
+/**
+ * Union type from all support garbage collectors for memory local cache.
+ */
+export type MemoryGarbageCollector = MemoryEagerGarbageCollector | MemoryLruGarbageCollector;
+/**
+ * A garbage collector deletes documents whenever they are not part of any
+ * active queries, and have no local mutations attached to them.
+ *
+ * This collector tries to ensure lowest memory footprints from the SDK,
+ * at the risk of documents not being cached for offline queries or for
+ * direct queries to the cache.
+ *
+ * Use factory function {@link memoryEagerGarbageCollector()} to create an
+ * instance of this collector.
+ */
+export type MemoryEagerGarbageCollector = {
+    kind: 'memoryEager';
+    /**
+     * @internal
+     */
+    _offlineComponentProvider: OfflineComponentProviderFactory;
+};
+/**
+ * A garbage collector deletes Least-Recently-Used documents in multiple
+ * batches.
+ *
+ * This collector is configured with a target size, and will only perform
+ * collection when the cached documents exceed the target size. It avoids
+ * querying backend repeated for the same query or document, at the risk
+ * of having a larger memory footprint.
+ *
+ * Use factory function {@link memoryLruGarbageCollector()} to create a
+ * instance of this collector.
+ */
+export type MemoryLruGarbageCollector = {
+    kind: 'memoryLru';
+    /**
+     * @internal
+     */
+    _offlineComponentProvider: OfflineComponentProviderFactory;
+};
+/**
+ * Creates an instance of `MemoryEagerGarbageCollector`. This is also the
+ * default garbage collector unless it is explicitly specified otherwise.
+ */
+export declare function memoryEagerGarbageCollector(): MemoryEagerGarbageCollector;
+/**
+ * Creates an instance of `MemoryLruGarbageCollector`.
+ *
+ * A target size can be specified as part of the setting parameter. The
+ * collector will start deleting documents once the cache size exceeds
+ * the given size. The default cache size is 40MB (40 * 1024 * 1024 bytes).
+ */
+export declare function memoryLruGarbageCollector(settings?: {
+    cacheSizeBytes?: number;
+}): MemoryLruGarbageCollector;
+/**
+ * An settings object to configure an `MemoryLocalCache` instance.
+ */
+export type MemoryCacheSettings = {
+    /**
+     * The garbage collector to use, for the memory cache layer.
+     * A `MemoryEagerGarbageCollector` is used when this is undefined.
+     */
+    garbageCollector?: MemoryGarbageCollector;
+};
+/**
+ * Creates an instance of `MemoryLocalCache`. The instance can be set to
+ * `FirestoreSettings.cache` to tell the SDK which cache layer to use.
+ */
+export declare function memoryLocalCache(settings?: MemoryCacheSettings): MemoryLocalCache;
+/**
+ * An settings object to configure an `PersistentLocalCache` instance.
+ *
+ * Persistent cache cannot be used in a Node.js environment.
+ */
+export type PersistentCacheSettings = {
+    /**
+     * An approximate cache size threshold for the on-disk data. If the cache
+     * grows beyond this size, Firestore will start removing data that hasn't been
+     * recently used. The SDK does not guarantee that the cache will stay below
+     * that size, only that if the cache exceeds the given size, cleanup will be
+     * attempted.
+     *
+     * The default value is 40 MB. The threshold must be set to at least 1 MB, and
+     * can be set to `CACHE_SIZE_UNLIMITED` to disable garbage collection.
+     */
+    cacheSizeBytes?: number;
+    /**
+     * Specifies how multiple tabs/windows will be managed by the SDK.
+     */
+    tabManager?: PersistentTabManager;
+};
+/**
+ * Creates an instance of `PersistentLocalCache`. The instance can be set to
+ * `FirestoreSettings.cache` to tell the SDK which cache layer to use.
+ *
+ * Persistent cache cannot be used in a Node.js environment.
+ */
+export declare function persistentLocalCache(settings?: PersistentCacheSettings): PersistentLocalCache;
+/**
+ * A tab manager supporting only one tab, no synchronization will be
+ * performed across tabs.
+ */
+export type PersistentSingleTabManager = {
+    kind: 'persistentSingleTab';
+    /**
+     * @internal
+     */
+    _initialize: (settings: Omit<PersistentCacheSettings, 'tabManager'> | undefined) => void;
+    /**
+     * @internal
+     */
+    _onlineComponentProvider?: OnlineComponentProviderFactory;
+    /**
+     * @internal
+     */
+    _offlineComponentProvider?: OfflineComponentProviderFactory;
+};
+/**
+ * A tab manager supporting multiple tabs. SDK will synchronize queries and
+ * mutations done across all tabs using the SDK.
+ */
+export type PersistentMultipleTabManager = {
+    kind: 'PersistentMultipleTab';
+    /**
+     * @internal
+     */
+    _initialize: (settings: Omit<PersistentCacheSettings, 'tabManager'>) => void;
+    /**
+     * @internal
+     */
+    _onlineComponentProvider?: OnlineComponentProviderFactory;
+    /**
+     * @internal
+     */
+    _offlineComponentProvider?: OfflineComponentProviderFactory;
+};
+/**
+ * A union of all available tab managers.
+ */
+export type PersistentTabManager = PersistentSingleTabManager | PersistentMultipleTabManager;
+/**
+ * Type to configure an `PersistentSingleTabManager` instance.
+ */
+export type PersistentSingleTabManagerSettings = {
+    /**
+     * Whether to force-enable persistent (IndexedDB) cache for the client. This
+     * cannot be used with multi-tab synchronization and is primarily intended for
+     * use with Web Workers. Setting this to `true` will enable IndexedDB, but cause
+     * other tabs using IndexedDB cache to fail.
+     */
+    forceOwnership?: boolean;
+};
+/**
+ * Creates an instance of `PersistentSingleTabManager`.
+ *
+ * @param settings Configures the created tab manager.
+ */
+export declare function persistentSingleTabManager(settings: PersistentSingleTabManagerSettings | undefined): PersistentSingleTabManager;
+/**
+ * Creates an instance of `PersistentMultipleTabManager`.
+ */
+export declare function persistentMultipleTabManager(): PersistentMultipleTabManager;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/credentials.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/credentials.d.ts
new file mode 100644
index 0000000..98ed3c2
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/credentials.d.ts
@@ -0,0 +1,222 @@
+/**
+ * @license
+ * Copyright 2017 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 { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';
+import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
+import { Provider } from '@firebase/component';
+import { User } from '../auth/user';
+import { AsyncQueue } from '../util/async_queue';
+/**
+ * @internal
+ */
+export type AuthTokenFactory = () => string;
+/**
+ * @internal
+ */
+export interface FirstPartyCredentialsSettings {
+    ['type']: 'firstParty';
+    ['sessionIndex']: string;
+    ['iamToken']: string | null;
+    ['authTokenFactory']: AuthTokenFactory | null;
+}
+export interface ProviderCredentialsSettings {
+    ['type']: 'provider';
+    ['client']: CredentialsProvider<User>;
+}
+/** Settings for private credentials */
+export type CredentialsSettings = FirstPartyCredentialsSettings | ProviderCredentialsSettings;
+export type TokenType = 'OAuth' | 'FirstParty' | 'AppCheck';
+export interface Token {
+    /** Type of token. */
+    type: TokenType;
+    /**
+     * The user with which the token is associated (used for persisting user
+     * state on disk, etc.).
+     * This will be null for Tokens of the type 'AppCheck'.
+     */
+    user?: User;
+    /** Header values to set for this token */
+    headers: Map<string, string>;
+}
+export declare class OAuthToken implements Token {
+    user: User;
+    type: TokenType;
+    headers: Map<any, any>;
+    constructor(value: string, user: User);
+}
+/**
+ * A Listener for credential change events. The listener should fetch a new
+ * token and may need to invalidate other state if the current user has also
+ * changed.
+ */
+export type CredentialChangeListener<T> = (credential: T) => Promise<void>;
+/**
+ * Provides methods for getting the uid and token for the current user and
+ * listening for changes.
+ */
+export interface CredentialsProvider<T> {
+    /**
+     * Starts the credentials provider and specifies a listener to be notified of
+     * credential changes (sign-in / sign-out, token changes). It is immediately
+     * called once with the initial user.
+     *
+     * The change listener is invoked on the provided AsyncQueue.
+     */
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<T>): void;
+    /** Requests a token for the current user. */
+    getToken(): Promise<Token | null>;
+    /**
+     * Marks the last retrieved token as invalid, making the next GetToken request
+     * force-refresh the token.
+     */
+    invalidateToken(): void;
+    shutdown(): void;
+}
+/**
+ * A CredentialsProvider that always yields an empty token.
+ * @internal
+ */
+export declare class EmptyAuthCredentialsProvider implements CredentialsProvider<User> {
+    getToken(): Promise<Token | null>;
+    invalidateToken(): void;
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<User>): void;
+    shutdown(): void;
+}
+/**
+ * A CredentialsProvider that always returns a constant token. Used for
+ * emulator token mocking.
+ */
+export declare class EmulatorAuthCredentialsProvider implements CredentialsProvider<User> {
+    private token;
+    constructor(token: Token);
+    /**
+     * Stores the listener registered with setChangeListener()
+     * This isn't actually necessary since the UID never changes, but we use this
+     * to verify the listen contract is adhered to in tests.
+     */
+    private changeListener;
+    getToken(): Promise<Token | null>;
+    invalidateToken(): void;
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<User>): void;
+    shutdown(): void;
+}
+/** Credential provider for the Lite SDK. */
+export declare class LiteAuthCredentialsProvider implements CredentialsProvider<User> {
+    private auth;
+    constructor(authProvider: Provider<FirebaseAuthInternalName>);
+    getToken(): Promise<Token | null>;
+    invalidateToken(): void;
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<User>): void;
+    shutdown(): void;
+}
+export declare class FirebaseAuthCredentialsProvider implements CredentialsProvider<User> {
+    private authProvider;
+    /**
+     * The auth token listener registered with FirebaseApp, retained here so we
+     * can unregister it.
+     */
+    private tokenListener;
+    /** Tracks the current User. */
+    private currentUser;
+    /**
+     * Counter used to detect if the token changed while a getToken request was
+     * outstanding.
+     */
+    private tokenCounter;
+    private forceRefresh;
+    private auth;
+    constructor(authProvider: Provider<FirebaseAuthInternalName>);
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<User>): void;
+    getToken(): Promise<Token | null>;
+    invalidateToken(): void;
+    shutdown(): void;
+    private getUser;
+}
+export declare class FirstPartyToken implements Token {
+    private readonly sessionIndex;
+    private readonly iamToken;
+    private readonly authTokenFactory;
+    type: TokenType;
+    user: User;
+    private _headers;
+    constructor(sessionIndex: string, iamToken: string | null, authTokenFactory: AuthTokenFactory | null);
+    /**
+     * Gets an authorization token, using a provided factory function, or return
+     * null.
+     */
+    private getAuthToken;
+    get headers(): Map<string, string>;
+}
+export declare class FirstPartyAuthCredentialsProvider implements CredentialsProvider<User> {
+    private sessionIndex;
+    private iamToken;
+    private authTokenFactory;
+    constructor(sessionIndex: string, iamToken: string | null, authTokenFactory: AuthTokenFactory | null);
+    getToken(): Promise<Token | null>;
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<User>): void;
+    shutdown(): void;
+    invalidateToken(): void;
+}
+export declare class AppCheckToken implements Token {
+    private value;
+    type: TokenType;
+    headers: Map<any, any>;
+    constructor(value: string);
+}
+export declare class FirebaseAppCheckTokenProvider implements CredentialsProvider<string> {
+    private appCheckProvider;
+    /**
+     * The AppCheck token listener registered with FirebaseApp, retained here so
+     * we can unregister it.
+     */
+    private tokenListener;
+    private forceRefresh;
+    private appCheck;
+    private latestAppCheckToken;
+    private serverAppAppCheckToken;
+    constructor(app: FirebaseApp, appCheckProvider: Provider<AppCheckInternalComponentName>);
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<string>): void;
+    getToken(): Promise<Token | null>;
+    invalidateToken(): void;
+    shutdown(): void;
+}
+/**
+ * An AppCheck token provider that always yields an empty token.
+ * @internal
+ */
+export declare class EmptyAppCheckTokenProvider implements CredentialsProvider<string> {
+    getToken(): Promise<Token | null>;
+    invalidateToken(): void;
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<string>): void;
+    shutdown(): void;
+}
+/** AppCheck token provider for the Lite SDK. */
+export declare class LiteAppCheckTokenProvider implements CredentialsProvider<string> {
+    private appCheckProvider;
+    private appCheck;
+    private serverAppAppCheckToken;
+    constructor(app: FirebaseApp, appCheckProvider: Provider<AppCheckInternalComponentName>);
+    getToken(): Promise<Token | null>;
+    invalidateToken(): void;
+    start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<string>): void;
+    shutdown(): void;
+}
+/**
+ * Builds a CredentialsProvider depending on the type of
+ * the credentials passed in.
+ */
+export declare function makeAuthCredentialsProvider(credentials?: CredentialsSettings): CredentialsProvider<User>;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/database.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/database.d.ts
new file mode 100644
index 0000000..8004dae
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/database.d.ts
@@ -0,0 +1,279 @@
+/**
+ * @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 { FirebaseApp } from '@firebase/app';
+import { User } from '../auth/user';
+import { OfflineComponentProviderFactory, OnlineComponentProviderFactory } from '../core/component_provider';
+import { DatabaseId } from '../core/database_info';
+import { FirestoreClient } from '../core/firestore_client';
+import { Firestore as LiteFirestore } from '../lite-api/database';
+import { Query } from '../lite-api/reference';
+import { AsyncQueue } from '../util/async_queue';
+import { LoadBundleTask } from './bundle';
+import { CredentialsProvider } from './credentials';
+import { FirestoreSettings, PersistenceSettings } from './settings';
+export { connectFirestoreEmulator, EmulatorMockTokenOptions } from '../lite-api/database';
+declare module '@firebase/component' {
+    interface NameServiceMapping {
+        'firestore': Firestore;
+    }
+}
+/**
+ * Constant used to indicate the LRU garbage collection should be disabled.
+ * Set this value as the `cacheSizeBytes` on the settings passed to the
+ * {@link Firestore} instance.
+ */
+export declare const CACHE_SIZE_UNLIMITED = -1;
+/**
+ * The Cloud Firestore service interface.
+ *
+ * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
+ */
+export declare class Firestore extends LiteFirestore {
+    /**
+     * Whether it's a {@link Firestore} or Firestore Lite instance.
+     */
+    type: 'firestore-lite' | 'firestore';
+    _queue: AsyncQueue;
+    readonly _persistenceKey: string;
+    _firestoreClient: FirestoreClient | undefined;
+    _componentsProvider?: {
+        _offline: OfflineComponentProviderFactory;
+        _online: OnlineComponentProviderFactory;
+    };
+    /** @hideconstructor */
+    constructor(authCredentialsProvider: CredentialsProvider<User>, appCheckCredentialsProvider: CredentialsProvider<string>, databaseId: DatabaseId, app?: FirebaseApp);
+    protected _terminate(): Promise<void>;
+}
+/**
+ * Initializes a new instance of {@link Firestore} with the provided settings.
+ * Can only be called before any other function, including
+ * {@link (getFirestore:1)}. If the custom settings are empty, this function is
+ * equivalent to calling {@link (getFirestore:1)}.
+ *
+ * @param app - The {@link @firebase/app#FirebaseApp} with which the {@link Firestore} instance will
+ * be associated.
+ * @param settings - A settings object to configure the {@link Firestore} instance.
+ * @param databaseId - The name of the database.
+ * @returns A newly initialized {@link Firestore} instance.
+ */
+export declare function initializeFirestore(app: FirebaseApp, settings: FirestoreSettings, databaseId?: string): Firestore;
+/**
+ * Returns the existing default {@link Firestore} instance that is associated with the
+ * default {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @returns The default {@link Firestore} instance of the default app.
+ */
+export declare function getFirestore(): Firestore;
+/**
+ * Returns the existing default {@link Firestore} instance that is associated with the
+ * provided {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @param app - The {@link @firebase/app#FirebaseApp} instance that the returned {@link Firestore}
+ * instance is associated with.
+ * @returns The default {@link Firestore} instance of the provided app.
+ */
+export declare function getFirestore(app: FirebaseApp): Firestore;
+/**
+ * Returns the existing named {@link Firestore} instance that is associated with the
+ * default {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @param databaseId - The name of the database.
+ * @returns The named {@link Firestore} instance of the default app.
+ * @beta
+ */
+export declare function getFirestore(databaseId: string): Firestore;
+/**
+ * Returns the existing named {@link Firestore} instance that is associated with the
+ * provided {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new
+ * instance with default settings.
+ *
+ * @param app - The {@link @firebase/app#FirebaseApp} instance that the returned {@link Firestore}
+ * instance is associated with.
+ * @param databaseId - The name of the database.
+ * @returns The named {@link Firestore} instance of the provided app.
+ * @beta
+ */
+export declare function getFirestore(app: FirebaseApp, databaseId: string): Firestore;
+/**
+ * @internal
+ */
+export declare function ensureFirestoreConfigured(firestore: Firestore): FirestoreClient;
+export declare function configureFirestore(firestore: Firestore): void;
+/**
+ * Attempts to enable persistent storage, if possible.
+ *
+ * On failure, `enableIndexedDbPersistence()` will reject the promise or
+ * throw an exception. There are several reasons why this can fail, which can be
+ * identified by the `code` on the error.
+ *
+ *   * failed-precondition: The app is already open in another browser tab.
+ *   * unimplemented: The browser is incompatible with the offline persistence
+ *     implementation.
+ *
+ * Note that even after a failure, the {@link Firestore} instance will remain
+ * usable, however offline persistence will be disabled.
+ *
+ * Note: `enableIndexedDbPersistence()` must be called before any other functions
+ * (other than {@link initializeFirestore}, {@link (getFirestore:1)} or
+ * {@link clearIndexedDbPersistence}.
+ *
+ * Persistence cannot be used in a Node.js environment.
+ *
+ * @param firestore - The {@link Firestore} instance to enable persistence for.
+ * @param persistenceSettings - Optional settings object to configure
+ * persistence.
+ * @returns A `Promise` that represents successfully enabling persistent storage.
+ * @deprecated This function will be removed in a future major release. Instead, set
+ * `FirestoreSettings.localCache` to an instance of `PersistentLocalCache` to
+ * turn on IndexedDb cache. Calling this function when `FirestoreSettings.localCache`
+ * is already specified will throw an exception.
+ */
+export declare function enableIndexedDbPersistence(firestore: Firestore, persistenceSettings?: PersistenceSettings): Promise<void>;
+/**
+ * Attempts to enable multi-tab persistent storage, if possible. If enabled
+ * across all tabs, all operations share access to local persistence, including
+ * shared execution of queries and latency-compensated local document updates
+ * across all connected instances.
+ *
+ * On failure, `enableMultiTabIndexedDbPersistence()` will reject the promise or
+ * throw an exception. There are several reasons why this can fail, which can be
+ * identified by the `code` on the error.
+ *
+ *   * failed-precondition: The app is already open in another browser tab and
+ *     multi-tab is not enabled.
+ *   * unimplemented: The browser is incompatible with the offline persistence
+ *     implementation.
+ *
+ * Note that even after a failure, the {@link Firestore} instance will remain
+ * usable, however offline persistence will be disabled.
+ *
+ * @param firestore - The {@link Firestore} instance to enable persistence for.
+ * @returns A `Promise` that represents successfully enabling persistent
+ * storage.
+ * @deprecated This function will be removed in a future major release. Instead, set
+ * `FirestoreSettings.localCache` to an instance of `PersistentLocalCache` to
+ * turn on indexeddb cache. Calling this function when `FirestoreSettings.localCache`
+ * is already specified will throw an exception.
+ */
+export declare function enableMultiTabIndexedDbPersistence(firestore: Firestore): Promise<void>;
+/**
+ * Clears the persistent storage. This includes pending writes and cached
+ * documents.
+ *
+ * Must be called while the {@link Firestore} instance is not started (after the app is
+ * terminated or when the app is first initialized). On startup, this function
+ * must be called before other functions (other than {@link
+ * initializeFirestore} or {@link (getFirestore:1)})). If the {@link Firestore}
+ * instance is still running, the promise will be rejected with the error code
+ * of `failed-precondition`.
+ *
+ * Note: `clearIndexedDbPersistence()` is primarily intended to help write
+ * reliable tests that use Cloud Firestore. It uses an efficient mechanism for
+ * dropping existing data but does not attempt to securely overwrite or
+ * otherwise make cached data unrecoverable. For applications that are sensitive
+ * to the disclosure of cached data in between user sessions, we strongly
+ * recommend not enabling persistence at all.
+ *
+ * @param firestore - The {@link Firestore} instance to clear persistence for.
+ * @returns A `Promise` that is resolved when the persistent storage is
+ * cleared. Otherwise, the promise is rejected with an error.
+ */
+export declare function clearIndexedDbPersistence(firestore: Firestore): Promise<void>;
+/**
+ * Waits until all currently pending writes for the active user have been
+ * acknowledged by the backend.
+ *
+ * The returned promise resolves immediately if there are no outstanding writes.
+ * Otherwise, the promise waits for all previously issued writes (including
+ * those written in a previous app session), but it does not wait for writes
+ * that were added after the function is called. If you want to wait for
+ * additional writes, call `waitForPendingWrites()` again.
+ *
+ * Any outstanding `waitForPendingWrites()` promises are rejected during user
+ * changes.
+ *
+ * @returns A `Promise` which resolves when all currently pending writes have been
+ * acknowledged by the backend.
+ */
+export declare function waitForPendingWrites(firestore: Firestore): Promise<void>;
+/**
+ * Re-enables use of the network for this {@link Firestore} instance after a prior
+ * call to {@link disableNetwork}.
+ *
+ * @returns A `Promise` that is resolved once the network has been enabled.
+ */
+export declare function enableNetwork(firestore: Firestore): Promise<void>;
+/**
+ * Disables network usage for this instance. It can be re-enabled via {@link
+ * enableNetwork}. While the network is disabled, any snapshot listeners,
+ * `getDoc()` or `getDocs()` calls will return results from cache, and any write
+ * operations will be queued until the network is restored.
+ *
+ * @returns A `Promise` that is resolved once the network has been disabled.
+ */
+export declare function disableNetwork(firestore: Firestore): Promise<void>;
+/**
+ * Terminates the provided {@link Firestore} instance.
+ *
+ * After calling `terminate()` only the `clearIndexedDbPersistence()` function
+ * may be used. Any other function will throw a `FirestoreError`.
+ *
+ * To restart after termination, create a new instance of FirebaseFirestore with
+ * {@link (getFirestore:1)}.
+ *
+ * Termination does not cancel any pending writes, and any promises that are
+ * awaiting a response from the server will not be resolved. If you have
+ * persistence enabled, the next time you start this instance, it will resume
+ * sending these writes to the server.
+ *
+ * Note: Under normal circumstances, calling `terminate()` is not required. This
+ * function is useful only when you want to force this instance to release all
+ * of its resources or in combination with `clearIndexedDbPersistence()` to
+ * ensure that all local state is destroyed between test runs.
+ *
+ * @returns A `Promise` that is resolved when the instance has been successfully
+ * terminated.
+ */
+export declare function terminate(firestore: Firestore): Promise<void>;
+/**
+ * Loads a Firestore bundle into the local cache.
+ *
+ * @param firestore - The {@link Firestore} instance to load bundles for.
+ * @param bundleData - An object representing the bundle to be loaded. Valid
+ * objects are `ArrayBuffer`, `ReadableStream<Uint8Array>` or `string`.
+ *
+ * @returns A `LoadBundleTask` object, which notifies callers with progress
+ * updates, and completion or error events. It can be used as a
+ * `Promise<LoadBundleTaskProgress>`.
+ */
+export declare function loadBundle(firestore: Firestore, bundleData: ReadableStream<Uint8Array> | ArrayBuffer | string): LoadBundleTask;
+/**
+ * Reads a Firestore {@link Query} from local cache, identified by the given
+ * name.
+ *
+ * The named queries are packaged  into bundles on the server side (along
+ * with resulting documents), and loaded to local cache using `loadBundle`. Once
+ * in local cache, use this method to extract a {@link Query} by name.
+ *
+ * @param firestore - The {@link Firestore} instance to read the query from.
+ * @param name - The name of the query.
+ * @returns A `Promise` that is resolved with the Query or `null`.
+ */
+export declare function namedQuery(firestore: Firestore, name: string): Promise<Query | null>;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_path.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_path.d.ts
new file mode 100644
index 0000000..7e463e5
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_path.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { FieldPath, documentId } from '../lite-api/field_path';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value.d.ts
new file mode 100644
index 0000000..eded0bc
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { FieldValue } from '../lite-api/field_value';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value_impl.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value_impl.d.ts
new file mode 100644
index 0000000..aac67c3
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value_impl.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { increment, arrayRemove, arrayUnion, serverTimestamp, deleteField, vector } from '../lite-api/field_value_impl';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/filter.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/filter.d.ts
new file mode 100644
index 0000000..1dee60b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/filter.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { and, endAt, endBefore, startAfter, startAt, limitToLast, limit, or, orderBy, OrderByDirection, where, WhereFilterOp, query, QueryCompositeFilterConstraint, QueryConstraint, QueryConstraintType, QueryFilterConstraint, QueryFieldFilterConstraint, QueryOrderByConstraint, QueryLimitConstraint, QueryStartAtConstraint, QueryEndAtConstraint, QueryNonFilterConstraint } from '../lite-api/query';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/geo_point.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/geo_point.d.ts
new file mode 100644
index 0000000..b14def6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/geo_point.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { GeoPoint } from '../lite-api/geo_point';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/index_configuration.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/index_configuration.d.ts
new file mode 100644
index 0000000..8b10775
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/index_configuration.d.ts
@@ -0,0 +1,139 @@
+/**
+ * @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 { FieldIndex } from '../model/field_index';
+import { Firestore } from './database';
+export { connectFirestoreEmulator, EmulatorMockTokenOptions } from '../lite-api/database';
+/**
+ * A single field element in an index configuration.
+ *
+ * @deprecated Instead of creating cache indexes manually, consider using
+ * `enablePersistentCacheIndexAutoCreation()` to let the SDK decide whether to
+ * create cache indexes for queries running locally.
+ *
+ * @beta
+ */
+export interface IndexField {
+    /** The field path to index. */
+    readonly fieldPath: string;
+    /**
+     * What type of array index to create. Set to `CONTAINS` for `array-contains`
+     * and `array-contains-any` indexes.
+     *
+     * Only one of `arrayConfig` or `order` should be set;
+     */
+    readonly arrayConfig?: 'CONTAINS';
+    /**
+     * What type of array index to create. Set to `ASCENDING` or 'DESCENDING` for
+     * `==`, `!=`, `<=`, `<=`, `in` and `not-in` filters.
+     *
+     * Only one of `arrayConfig` or `order` should be set.
+     */
+    readonly order?: 'ASCENDING' | 'DESCENDING';
+    [key: string]: unknown;
+}
+/**
+ * The SDK definition of a Firestore index.
+ *
+ * @deprecated Instead of creating cache indexes manually, consider using
+ * `enablePersistentCacheIndexAutoCreation()` to let the SDK decide whether to
+ * create cache indexes for queries running locally.
+ *
+ * @beta
+ */
+export interface Index {
+    /** The ID of the collection to index. */
+    readonly collectionGroup: string;
+    /** A list of fields to index. */
+    readonly fields?: IndexField[];
+    [key: string]: unknown;
+}
+/**
+ * A list of Firestore indexes to speed up local query execution.
+ *
+ * See {@link https://firebase.google.com/docs/reference/firestore/indexes/#json_format | JSON Format}
+ * for a description of the format of the index definition.
+ *
+ * @deprecated Instead of creating cache indexes manually, consider using
+ * `enablePersistentCacheIndexAutoCreation()` to let the SDK decide whether to
+ * create cache indexes for queries running locally.
+ *
+ * @beta
+ */
+export interface IndexConfiguration {
+    /** A list of all Firestore indexes. */
+    readonly indexes?: Index[];
+    [key: string]: unknown;
+}
+/**
+ * Configures indexing for local query execution. Any previous index
+ * configuration is overridden. The `Promise` resolves once the index
+ * configuration has been persisted.
+ *
+ * The index entries themselves are created asynchronously. You can continue to
+ * use queries that require indexing even if the indices are not yet available.
+ * Query execution will automatically start using the index once the index
+ * entries have been written.
+ *
+ * Indexes are only supported with IndexedDb persistence. If IndexedDb is not
+ * enabled, any index configuration is ignored.
+ *
+ * @param firestore - The {@link Firestore} instance to configure indexes for.
+ * @param configuration -The index definition.
+ * @throws FirestoreError if the JSON format is invalid.
+ * @returns A `Promise` that resolves once all indices are successfully
+ * configured.
+ *
+ * @deprecated Instead of creating cache indexes manually, consider using
+ * `enablePersistentCacheIndexAutoCreation()` to let the SDK decide whether to
+ * create cache indexes for queries running locally.
+ *
+ * @beta
+ */
+export declare function setIndexConfiguration(firestore: Firestore, configuration: IndexConfiguration): Promise<void>;
+/**
+ * Configures indexing for local query execution. Any previous index
+ * configuration is overridden. The `Promise` resolves once the index
+ * configuration has been persisted.
+ *
+ * The index entries themselves are created asynchronously. You can continue to
+ * use queries that require indexing even if the indices are not yet available.
+ * Query execution will automatically start using the index once the index
+ * entries have been written.
+ *
+ * Indexes are only supported with IndexedDb persistence. Invoke either
+ * `enableIndexedDbPersistence()` or `enableMultiTabIndexedDbPersistence()`
+ * before setting an index configuration. If IndexedDb is not enabled, any
+ * index configuration is ignored.
+ *
+ * The method accepts the JSON format exported by the Firebase CLI (`firebase
+ * firestore:indexes`). If the JSON format is invalid, this method throws an
+ * error.
+ *
+ * @param firestore - The {@link Firestore} instance to configure indexes for.
+ * @param json -The JSON format exported by the Firebase CLI.
+ * @throws FirestoreError if the JSON format is invalid.
+ * @returns A `Promise` that resolves once all indices are successfully
+ * configured.
+ *
+ * @deprecated Instead of creating cache indexes manually, consider using
+ * `enablePersistentCacheIndexAutoCreation()` to let the SDK decide whether to
+ * create cache indexes for queries running locally.
+ *
+ * @beta
+ */
+export declare function setIndexConfiguration(firestore: Firestore, json: string): Promise<void>;
+export declare function parseIndexes(jsonOrConfiguration: string | IndexConfiguration): FieldIndex[];
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/long_polling_options.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/long_polling_options.d.ts
new file mode 100644
index 0000000..0088194
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/long_polling_options.d.ts
@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2023 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.
+ */
+/**
+ * Options that configure the SDK’s underlying network transport (WebChannel)
+ * when long-polling is used.
+ *
+ * Note: This interface is "experimental" and is subject to change.
+ *
+ * See `FirestoreSettings.experimentalAutoDetectLongPolling`,
+ * `FirestoreSettings.experimentalForceLongPolling`, and
+ * `FirestoreSettings.experimentalLongPollingOptions`.
+ */
+export interface ExperimentalLongPollingOptions {
+    /**
+     * The desired maximum timeout interval, in seconds, to complete a
+     * long-polling GET response. Valid values are between 5 and 30, inclusive.
+     * Floating point values are allowed and will be rounded to the nearest
+     * millisecond.
+     *
+     * By default, when long-polling is used the "hanging GET" request sent by
+     * the client times out after 30 seconds. To request a different timeout
+     * from the server, set this setting with the desired timeout.
+     *
+     * Changing the default timeout may be useful, for example, if the buffering
+     * proxy that necessitated enabling long-polling in the first place has a
+     * shorter timeout for hanging GET requests, in which case setting the
+     * long-polling timeout to a shorter value, such as 25 seconds, may fix
+     * prematurely-closed hanging GET requests.
+     * For example, see https://github.com/firebase/firebase-js-sdk/issues/6987.
+     */
+    timeoutSeconds?: number;
+}
+/**
+ * Compares two `ExperimentalLongPollingOptions` objects for equality.
+ */
+export declare function longPollingOptionsEqual(options1: ExperimentalLongPollingOptions, options2: ExperimentalLongPollingOptions): boolean;
+/**
+ * Creates and returns a new `ExperimentalLongPollingOptions` with the same
+ * option values as the given instance.
+ */
+export declare function cloneLongPollingOptions(options: ExperimentalLongPollingOptions): ExperimentalLongPollingOptions;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/observer.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/observer.d.ts
new file mode 100644
index 0000000..1aa4b85
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/observer.d.ts
@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2017 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 { FirestoreError } from '../util/error';
+/**
+ * Observer/Subscribe interfaces.
+ */
+export type NextFn<T> = (value: T) => void;
+export type ErrorFn = (error: FirestoreError) => void;
+export type CompleteFn = () => void;
+export interface PartialObserver<T> {
+    next?: NextFn<T>;
+    error?: ErrorFn;
+    complete?: CompleteFn;
+}
+export declare function isPartialObserver<T>(obj: unknown): obj is PartialObserver<T>;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/parse_context.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/parse_context.d.ts
new file mode 100644
index 0000000..d2b0beb
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/parse_context.d.ts
@@ -0,0 +1,21 @@
+/**
+ * @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 { DatabaseId } from '../core/database_info';
+export interface ParseContext {
+    readonly databaseId: DatabaseId;
+    readonly ignoreUndefinedProperties: boolean;
+}
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/persistent_cache_index_manager.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/persistent_cache_index_manager.d.ts
new file mode 100644
index 0000000..c6e4b46
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/persistent_cache_index_manager.d.ts
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2023 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 { Firestore } from './database';
+/**
+ * A `PersistentCacheIndexManager` for configuring persistent cache indexes used
+ * for local query execution.
+ *
+ * To use, call `getPersistentCacheIndexManager()` to get an instance.
+ */
+export declare class PersistentCacheIndexManager {
+    readonly _firestore: Firestore;
+    /** A type string to uniquely identify instances of this class. */
+    readonly type: 'PersistentCacheIndexManager';
+    /** @hideconstructor */
+    constructor(_firestore: Firestore);
+}
+/**
+ * Returns the PersistentCache Index Manager used by the given `Firestore`
+ * object.
+ *
+ * @return The `PersistentCacheIndexManager` instance, or `null` if local
+ * persistent storage is not in use.
+ */
+export declare function getPersistentCacheIndexManager(firestore: Firestore): PersistentCacheIndexManager | null;
+/**
+ * Enables the SDK to create persistent cache indexes automatically for local
+ * query execution when the SDK believes cache indexes can help improve
+ * performance.
+ *
+ * This feature is disabled by default.
+ */
+export declare function enablePersistentCacheIndexAutoCreation(indexManager: PersistentCacheIndexManager): void;
+/**
+ * Stops creating persistent cache indexes automatically for local query
+ * execution. The indexes which have been created by calling
+ * `enablePersistentCacheIndexAutoCreation()` still take effect.
+ */
+export declare function disablePersistentCacheIndexAutoCreation(indexManager: PersistentCacheIndexManager): void;
+/**
+ * Removes all persistent cache indexes.
+ *
+ * Please note this function will also deletes indexes generated by
+ * `setIndexConfiguration()`, which is deprecated.
+ */
+export declare function deleteAllPersistentCacheIndexes(indexManager: PersistentCacheIndexManager): void;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference.d.ts
new file mode 100644
index 0000000..0e38648
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { DocumentReference, CollectionReference, Query, collection, collectionGroup, doc, queryEqual, SetOptions, DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, refEqual } from '../lite-api/reference';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference_impl.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference_impl.d.ts
new file mode 100644
index 0000000..5dd95e6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference_impl.d.ts
@@ -0,0 +1,536 @@
+/**
+ * @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 { Bytes } from '../lite-api/bytes';
+import { FieldPath } from '../lite-api/field_path';
+import { CollectionReference, DocumentData, DocumentReference, PartialWithFieldValue, Query, SetOptions, UpdateData, WithFieldValue } from '../lite-api/reference';
+import { AbstractUserDataWriter } from '../lite-api/user_data_writer';
+import { Mutation } from '../model/mutation';
+import { ByteString } from '../util/byte_string';
+import { FirestoreError } from '../util/error';
+import { Firestore } from './database';
+import { DocumentSnapshot, FirestoreDataConverter, QuerySnapshot } from './snapshot';
+/**
+ * An options object that can be passed to {@link (onSnapshot:1)} and {@link
+ * QuerySnapshot.docChanges} to control which types of changes to include in the
+ * result set.
+ */
+export interface SnapshotListenOptions {
+    /**
+     * Include a change even if only the metadata of the query or of a document
+     * changed. Default is false.
+     */
+    readonly includeMetadataChanges?: boolean;
+    /**
+     * Set the source the query listens to. Default to "default", which
+     * listens to both cache and server.
+     */
+    readonly source?: ListenSource;
+}
+/**
+ * Describe the source a query listens to.
+ *
+ * Set to `default` to listen to both cache and server changes. Set to `cache`
+ * to listen to changes in cache only.
+ */
+export type ListenSource = 'default' | 'cache';
+/**
+ * Reads the document referred to by this `DocumentReference`.
+ *
+ * Note: `getDoc()` attempts to provide up-to-date data when possible by waiting
+ * for data from the server, but it may return cached data or fail if you are
+ * offline and the server cannot be reached. To specify this behavior, invoke
+ * {@link getDocFromCache} or {@link getDocFromServer}.
+ *
+ * @param reference - The reference of the document to fetch.
+ * @returns A Promise resolved with a `DocumentSnapshot` containing the
+ * current document contents.
+ */
+export declare function getDoc<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>): Promise<DocumentSnapshot<AppModelType, DbModelType>>;
+export declare class ExpUserDataWriter extends AbstractUserDataWriter {
+    protected firestore: Firestore;
+    constructor(firestore: Firestore);
+    protected convertBytes(bytes: ByteString): Bytes;
+    protected convertReference(name: string): DocumentReference;
+}
+/**
+ * Reads the document referred to by this `DocumentReference` from cache.
+ * Returns an error if the document is not currently cached.
+ *
+ * @returns A `Promise` resolved with a `DocumentSnapshot` containing the
+ * current document contents.
+ */
+export declare function getDocFromCache<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>): Promise<DocumentSnapshot<AppModelType, DbModelType>>;
+/**
+ * Reads the document referred to by this `DocumentReference` from the server.
+ * Returns an error if the network is not available.
+ *
+ * @returns A `Promise` resolved with a `DocumentSnapshot` containing the
+ * current document contents.
+ */
+export declare function getDocFromServer<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>): Promise<DocumentSnapshot<AppModelType, DbModelType>>;
+/**
+ * Executes the query and returns the results as a `QuerySnapshot`.
+ *
+ * Note: `getDocs()` attempts to provide up-to-date data when possible by
+ * waiting for data from the server, but it may return cached data or fail if
+ * you are offline and the server cannot be reached. To specify this behavior,
+ * invoke {@link getDocsFromCache} or {@link getDocsFromServer}.
+ *
+ * @returns A `Promise` that will be resolved with the results of the query.
+ */
+export declare function getDocs<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>): Promise<QuerySnapshot<AppModelType, DbModelType>>;
+/**
+ * Executes the query and returns the results as a `QuerySnapshot` from cache.
+ * Returns an empty result set if no documents matching the query are currently
+ * cached.
+ *
+ * @returns A `Promise` that will be resolved with the results of the query.
+ */
+export declare function getDocsFromCache<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>): Promise<QuerySnapshot<AppModelType, DbModelType>>;
+/**
+ * Executes the query and returns the results as a `QuerySnapshot` from the
+ * server. Returns an error if the network is not available.
+ *
+ * @returns A `Promise` that will be resolved with the results of the query.
+ */
+export declare function getDocsFromServer<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>): Promise<QuerySnapshot<AppModelType, DbModelType>>;
+/**
+ * Writes to the document referred to by this `DocumentReference`. If the
+ * document does not yet exist, it will be created.
+ *
+ * @param reference - A reference to the document to write.
+ * @param data - A map of the fields and values for the document.
+ * @returns A `Promise` resolved once the data has been successfully written
+ * to the backend (note that it won't resolve while you're offline).
+ */
+export declare function setDoc<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>): Promise<void>;
+/**
+ * Writes to the document referred to by the specified `DocumentReference`. If
+ * the document does not yet exist, it will be created. If you provide `merge`
+ * or `mergeFields`, the provided data can be merged into an existing document.
+ *
+ * @param reference - A reference to the document to write.
+ * @param data - A map of the fields and values for the document.
+ * @param options - An object to configure the set behavior.
+ * @returns A Promise resolved once the data has been successfully written
+ * to the backend (note that it won't resolve while you're offline).
+ */
+export declare function setDoc<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, data: PartialWithFieldValue<AppModelType>, options: SetOptions): Promise<void>;
+/**
+ * Updates fields in the document referred to by the specified
+ * `DocumentReference`. The update will fail if applied to a document that does
+ * not exist.
+ *
+ * @param reference - A reference to the document to update.
+ * @param data - An object containing the fields and values with which to
+ * update the document. Fields can contain dots to reference nested fields
+ * within the document.
+ * @returns A `Promise` resolved once the data has been successfully written
+ * to the backend (note that it won't resolve while you're offline).
+ */
+export declare function updateDoc<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, data: UpdateData<DbModelType>): Promise<void>;
+/**
+ * Updates fields in the document referred to by the specified
+ * `DocumentReference` The update will fail if applied to a document that does
+ * not exist.
+ *
+ * Nested fields can be updated by providing dot-separated field path
+ * strings or by providing `FieldPath` objects.
+ *
+ * @param reference - A reference to the document to update.
+ * @param field - The first field to update.
+ * @param value - The first value.
+ * @param moreFieldsAndValues - Additional key value pairs.
+ * @returns A `Promise` resolved once the data has been successfully written
+ * to the backend (note that it won't resolve while you're offline).
+ */
+export declare function updateDoc<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, field: string | FieldPath, value: unknown, ...moreFieldsAndValues: unknown[]): Promise<void>;
+/**
+ * Deletes the document referred to by the specified `DocumentReference`.
+ *
+ * @param reference - A reference to the document to delete.
+ * @returns A Promise resolved once the document has been successfully
+ * deleted from the backend (note that it won't resolve while you're offline).
+ */
+export declare function deleteDoc<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>): Promise<void>;
+/**
+ * Add a new document to specified `CollectionReference` with the given data,
+ * assigning it a document ID automatically.
+ *
+ * @param reference - A reference to the collection to add this document to.
+ * @param data - An Object containing the data for the new document.
+ * @returns A `Promise` resolved with a `DocumentReference` pointing to the
+ * newly created document after it has been written to the backend (Note that it
+ * won't resolve while you're offline).
+ */
+export declare function addDoc<AppModelType, DbModelType extends DocumentData>(reference: CollectionReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>): Promise<DocumentReference<AppModelType, DbModelType>>;
+/**
+ * A function returned by `onSnapshot()` that removes the listener when invoked.
+ */
+export interface Unsubscribe {
+    /** Removes the listener when invoked. */
+    (): void;
+}
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, observer: {
+    next?: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, options: SnapshotListenOptions, observer: {
+    next?: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param onNext - A callback to be called every time a new `DocumentSnapshot` is available.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are never ending.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, onNext: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param reference - A reference to the document to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param onNext - A callback to be called every time a new `DocumentSnapshot` is available.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are never ending.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(reference: DocumentReference<AppModelType, DbModelType>, options: SnapshotListenOptions, onNext: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks. The
+ * listener can be cancelled by calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>, observer: {
+    next?: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks. The
+ * listener can be cancelled by calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>, options: SnapshotListenOptions, observer: {
+    next?: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks. The
+ * listener can be cancelled by calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param onNext - A callback to be called every time a new `QuerySnapshot` is available.
+ * @param onCompletion - Can be provided, but will not be called since streams are never ending.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>, onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events. You may either pass individual `onNext` and
+ * `onError` callbacks or pass a single observer object with `next` and `error` callbacks. The
+ * listener can be cancelled by calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param query - The query to listen to.
+ * @param options - Options controlling the listen behavior.
+ * @param onNext - A callback to be called every time a new `QuerySnapshot` is available.
+ * @param onCompletion - Can be provided, but will not be called since streams are never ending.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshot<AppModelType, DbModelType extends DocumentData>(query: Query<AppModelType, DbModelType>, options: SnapshotListenOptions, onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events based on data generated by invoking
+ * {@link QuerySnapshot.toJSON} You may either pass individual `onNext` and `onError` callbacks or
+ * pass a single observer object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link QuerySnapshot.toJSON}.
+ * @param onNext - A callback to be called every time a new `QuerySnapshot` is available.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are never ending.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events based on data generated by invoking
+ * {@link DocumentSnapshot.toJSON}. You may either pass individual `onNext` and `onError` callbacks or
+ * pass a single observer object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link DocumentSnapshot.toJSON}.
+ * @param onNext - A callback to be called every time a new `DocumentSnapshot` is available.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are
+ * never ending.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, onNext: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events based on data generated by invoking
+ * {@link QuerySnapshot.toJSON}. You may either pass individual `onNext` and `onError` callbacks or
+ * pass a single observer object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link QuerySnapshot.toJSON}.
+ * @param options - Options controlling the listen behavior.
+ * @param onNext - A callback to be called every time a new `QuerySnapshot` is available.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are never ending.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, options: SnapshotListenOptions, onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events based on data generated by invoking
+ * {@link DocumentSnapshot.toJSON}. You may either pass individual `onNext` and `onError` callbacks
+ * or pass a single observer object with `next` and `error` callbacks. The listener can be cancelled
+ * by calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link DocumentSnapshot.toJSON}.
+ * @param options - Options controlling the listen behavior.
+ * @param onNext - A callback to be called every time a new `DocumentSnapshot` is available.
+ * @param onError - A callback to be called if the listen fails or is cancelled. No further
+ * callbacks will occur.
+ * @param onCompletion - Can be provided, but will not be called since streams are never ending.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, options: SnapshotListenOptions, onNext: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: FirestoreError) => void, onCompletion?: () => void, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events based on QuerySnapshot data generated by invoking
+ * {@link QuerySnapshot.toJSON}. You may either pass individual `onNext` and `onError` callbacks or
+ * pass a single observer object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link QuerySnapshot.toJSON}.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, observer: {
+    next: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events based on data generated by invoking
+ * {@link DocumentSnapshot.toJSON} You may either pass individual `onNext` and `onError` callbacks
+ * or pass a single observer object with `next` and `error` callbacks. The listener can be cancelled
+ * by calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link DocumentSnapshot.toJSON}.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, observer: {
+    next: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for `QuerySnapshot` events based on QuerySnapshot data generated by invoking
+ * {@link QuerySnapshot.toJSON} You may either pass individual `onNext` and `onError` callbacks or
+ * pass a single observer object with `next` and `error` callbacks. The listener can be cancelled by
+ * calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link QuerySnapshot.toJSON}.
+ * @param options - Options controlling the listen behavior.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel
+ * the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, options: SnapshotListenOptions, observer: {
+    next: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for `DocumentSnapshot` events based on QuerySnapshot data generated by
+ * invoking {@link DocumentSnapshot.toJSON} You may either pass individual `onNext` and `onError`
+ * callbacks or pass a single observer object with `next` and `error` callbacks. The listener can be
+ * cancelled by calling the function that is returned when `onSnapshot` is called.
+ *
+ * NOTE: Although an `onCompletion` callback can be provided, it will never be called because the
+ * snapshot stream is never-ending.
+ *
+ * @param firestore - The {@link Firestore} instance to enable the listener for.
+ * @param snapshotJson - A JSON object generated by invoking {@link DocumentSnapshot.toJSON}.
+ * @param options - Options controlling the listen behavior.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @param converter - An optional object that converts objects from Firestore before the onNext
+ * listener is invoked.
+ * @returns An unsubscribe function that can be called to cancel the snapshot listener.
+ */
+export declare function onSnapshotResume<AppModelType, DbModelType extends DocumentData>(firestore: Firestore, snapshotJson: object, options: SnapshotListenOptions, observer: {
+    next: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}, converter?: FirestoreDataConverter<DbModelType>): Unsubscribe;
+/**
+ * Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync
+ * event indicates that all listeners affected by a given change have fired,
+ * even if a single server-generated change affects multiple listeners.
+ *
+ * NOTE: The snapshots-in-sync event only indicates that listeners are in sync
+ * with each other, but does not relate to whether those snapshots are in sync
+ * with the server. Use SnapshotMetadata in the individual listeners to
+ * determine if a snapshot is from the cache or the server.
+ *
+ * @param firestore - The instance of Firestore for synchronizing snapshots.
+ * @param observer - A single object containing `next` and `error` callbacks.
+ * @returns An unsubscribe function that can be called to cancel the snapshot
+ * listener.
+ */
+export declare function onSnapshotsInSync(firestore: Firestore, observer: {
+    next?: (value: void) => void;
+    error?: (error: FirestoreError) => void;
+    complete?: () => void;
+}): Unsubscribe;
+/**
+ * Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync
+ * event indicates that all listeners affected by a given change have fired,
+ * even if a single server-generated change affects multiple listeners.
+ *
+ * NOTE: The snapshots-in-sync event only indicates that listeners are in sync
+ * with each other, but does not relate to whether those snapshots are in sync
+ * with the server. Use `SnapshotMetadata` in the individual listeners to
+ * determine if a snapshot is from the cache or the server.
+ *
+ * @param firestore - The `Firestore` instance for synchronizing snapshots.
+ * @param onSync - A callback to be called every time all snapshot listeners are
+ * in sync with each other.
+ * @returns An unsubscribe function that can be called to cancel the snapshot
+ * listener.
+ */
+export declare function onSnapshotsInSync(firestore: Firestore, onSync: () => void): Unsubscribe;
+/**
+ * Locally writes `mutations` on the async queue.
+ * @internal
+ */
+export declare function executeWrite(firestore: Firestore, mutations: Mutation[]): Promise<void>;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/settings.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/settings.d.ts
new file mode 100644
index 0000000..8565811
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/settings.d.ts
@@ -0,0 +1,108 @@
+/**
+ * @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 { FirestoreSettings as LiteSettings } from '../lite-api/settings';
+import { FirestoreLocalCache } from './cache_config';
+import { ExperimentalLongPollingOptions } from './long_polling_options';
+export { DEFAULT_HOST } from '../lite-api/settings';
+/**
+ * Settings that can be passed to `enableIndexedDbPersistence()` to configure
+ * Firestore persistence.
+ *
+ * Persistence cannot be used in a Node.js environment.
+ */
+export interface PersistenceSettings {
+    /**
+     * Whether to force enable persistence for the client. This cannot be used
+     * with multi-tab synchronization and is primarily intended for use with Web
+     * Workers. Setting this to `true` will enable persistence, but cause other
+     * tabs using persistence to fail.
+     */
+    forceOwnership?: boolean;
+}
+/**
+ * Specifies custom configurations for your Cloud Firestore instance.
+ * You must set these before invoking any other methods.
+ */
+export interface FirestoreSettings extends LiteSettings {
+    /**
+     * NOTE: This field will be deprecated in a future major release. Use `cache` field
+     * instead to specify cache size, and other cache configurations.
+     *
+     * An approximate cache size threshold for the on-disk data. If the cache
+     * grows beyond this size, Firestore will start removing data that hasn't been
+     * recently used. The size is not a guarantee that the cache will stay below
+     * that size, only that if the cache exceeds the given size, cleanup will be
+     * attempted.
+     *
+     * The default value is 40 MB. The threshold must be set to at least 1 MB, and
+     * can be set to `CACHE_SIZE_UNLIMITED` to disable garbage collection.
+     */
+    cacheSizeBytes?: number;
+    /**
+     * Specifies the cache used by the SDK. Available options are `MemoryLocalCache`
+     * and `PersistentLocalCache`, each with different configuration options.
+     *
+     * When unspecified, `MemoryLocalCache` will be used by default.
+     *
+     * NOTE: setting this field and `cacheSizeBytes` at the same time will throw
+     * exception during SDK initialization. Instead, using the configuration in
+     * the `FirestoreLocalCache` object to specify the cache size.
+     */
+    localCache?: FirestoreLocalCache;
+    /**
+     * Forces the SDK’s underlying network transport (WebChannel) to use
+     * long-polling. Each response from the backend will be closed immediately
+     * after the backend sends data (by default responses are kept open in
+     * case the backend has more data to send). This avoids incompatibility
+     * issues with certain proxies, antivirus software, etc. that incorrectly
+     * buffer traffic indefinitely. Use of this option will cause some
+     * performance degradation though.
+     *
+     * This setting cannot be used with `experimentalAutoDetectLongPolling` and
+     * may be removed in a future release. If you find yourself using it to
+     * work around a specific network reliability issue, please tell us about
+     * it in https://github.com/firebase/firebase-js-sdk/issues/1674.
+     *
+     * This setting cannot be used in a Node.js environment.
+     */
+    experimentalForceLongPolling?: boolean;
+    /**
+     * Configures the SDK's underlying transport (WebChannel) to automatically
+     * detect if long-polling should be used. This is very similar to
+     * `experimentalForceLongPolling`, but only uses long-polling if required.
+     *
+     * After having had a default value of `false` since its inception in 2019,
+     * the default value of this setting was changed in May 2023 to `true` in
+     * v9.22.0 of the Firebase JavaScript SDK. That is, auto-detection of long
+     * polling is now enabled by default. To disable it, set this setting to
+     * `false`, and please open a GitHub issue to share the problems that
+     * motivated you disabling long-polling auto-detection.
+     *
+     * This setting cannot be used in a Node.js environment.
+     */
+    experimentalAutoDetectLongPolling?: boolean;
+    /**
+     * Options that configure the SDK’s underlying network transport (WebChannel)
+     * when long-polling is used.
+     *
+     * These options are only used if `experimentalForceLongPolling` is true or if
+     * `experimentalAutoDetectLongPolling` is true and the auto-detection
+     * determined that long-polling was needed. Otherwise, these options have no
+     * effect.
+     */
+    experimentalLongPollingOptions?: ExperimentalLongPollingOptions;
+}
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/snapshot.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/snapshot.d.ts
new file mode 100644
index 0000000..24d863e
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/snapshot.d.ts
@@ -0,0 +1,550 @@
+/**
+ * @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 { ChangeType, ViewSnapshot } from '../core/view_snapshot';
+import { FieldPath } from '../lite-api/field_path';
+import { DocumentData, PartialWithFieldValue, Query, SetOptions, WithFieldValue } from '../lite-api/reference';
+import { DocumentSnapshot as LiteDocumentSnapshot, FirestoreDataConverter as LiteFirestoreDataConverter } from '../lite-api/snapshot';
+import { UntypedFirestoreDataConverter } from '../lite-api/user_data_reader';
+import { AbstractUserDataWriter } from '../lite-api/user_data_writer';
+import { Document } from '../model/document';
+import { DocumentKey } from '../model/document_key';
+import { Property } from '../util/json_validation';
+import { Firestore } from './database';
+import { SnapshotListenOptions } from './reference_impl';
+/**
+ * Converter used by `withConverter()` to transform user objects of type
+ * `AppModelType` into Firestore data of type `DbModelType`.
+ *
+ * Using the converter allows you to specify generic type arguments when
+ * storing and retrieving objects from Firestore.
+ *
+ * In this context, an "AppModel" is a class that is used in an application to
+ * package together related information and functionality. Such a class could,
+ * for example, have properties with complex, nested data types, properties used
+ * for memoization, properties of types not supported by Firestore (such as
+ * `symbol` and `bigint`), and helper functions that perform compound
+ * operations. Such classes are not suitable and/or possible to store into a
+ * Firestore database. Instead, instances of such classes need to be converted
+ * to "plain old JavaScript objects" (POJOs) with exclusively primitive
+ * properties, potentially nested inside other POJOs or arrays of POJOs. In this
+ * context, this type is referred to as the "DbModel" and would be an object
+ * suitable for persisting into Firestore. For convenience, applications can
+ * implement `FirestoreDataConverter` and register the converter with Firestore
+ * objects, such as `DocumentReference` or `Query`, to automatically convert
+ * `AppModel` to `DbModel` when storing into Firestore, and convert `DbModel`
+ * to `AppModel` when retrieving from Firestore.
+ *
+ * @example
+ *
+ * Simple Example
+ *
+ * ```typescript
+ * const numberConverter = {
+ *     toFirestore(value: WithFieldValue<number>) {
+ *         return { value };
+ *     },
+ *     fromFirestore(snapshot: QueryDocumentSnapshot, options: SnapshotOptions) {
+ *         return snapshot.data(options).value as number;
+ *     }
+ * };
+ *
+ * async function simpleDemo(db: Firestore): Promise<void> {
+ *     const documentRef = doc(db, 'values/value123').withConverter(numberConverter);
+ *
+ *     // converters are used with `setDoc`, `addDoc`, and `getDoc`
+ *     await setDoc(documentRef, 42);
+ *     const snapshot1 = await getDoc(documentRef);
+ *     assertEqual(snapshot1.data(), 42);
+ *
+ *     // converters are not used when writing data with `updateDoc`
+ *     await updateDoc(documentRef, { value: 999 });
+ *     const snapshot2 = await getDoc(documentRef);
+ *     assertEqual(snapshot2.data(), 999);
+ * }
+ * ```
+ *
+ * Advanced Example
+ *
+ * ```typescript
+ * // The Post class is a model that is used by our application.
+ * // This class may have properties and methods that are specific
+ * // to our application execution, which do not need to be persisted
+ * // to Firestore.
+ * class Post {
+ *     constructor(
+ *         readonly title: string,
+ *         readonly author: string,
+ *         readonly lastUpdatedMillis: number
+ *     ) {}
+ *     toString(): string {
+ *         return `${this.title} by ${this.author}`;
+ *     }
+ * }
+ *
+ * // The PostDbModel represents how we want our posts to be stored
+ * // in Firestore. This DbModel has different properties (`ttl`,
+ * // `aut`, and `lut`) from the Post class we use in our application.
+ * interface PostDbModel {
+ *     ttl: string;
+ *     aut: { firstName: string; lastName: string };
+ *     lut: Timestamp;
+ * }
+ *
+ * // The `PostConverter` implements `FirestoreDataConverter` and specifies
+ * // how the Firestore SDK can convert `Post` objects to `PostDbModel`
+ * // objects and vice versa.
+ * class PostConverter implements FirestoreDataConverter<Post, PostDbModel> {
+ *     toFirestore(post: WithFieldValue<Post>): WithFieldValue<PostDbModel> {
+ *         return {
+ *             ttl: post.title,
+ *             aut: this._autFromAuthor(post.author),
+ *             lut: this._lutFromLastUpdatedMillis(post.lastUpdatedMillis)
+ *         };
+ *     }
+ *
+ *     fromFirestore(snapshot: QueryDocumentSnapshot, options: SnapshotOptions): Post {
+ *         const data = snapshot.data(options) as PostDbModel;
+ *         const author = `${data.aut.firstName} ${data.aut.lastName}`;
+ *         return new Post(data.ttl, author, data.lut.toMillis());
+ *     }
+ *
+ *     _autFromAuthor(
+ *         author: string | FieldValue
+ *     ): { firstName: string; lastName: string } | FieldValue {
+ *         if (typeof author !== 'string') {
+ *             // `author` is a FieldValue, so just return it.
+ *             return author;
+ *         }
+ *         const [firstName, lastName] = author.split(' ');
+ *         return {firstName, lastName};
+ *     }
+ *
+ *     _lutFromLastUpdatedMillis(
+ *         lastUpdatedMillis: number | FieldValue
+ *     ): Timestamp | FieldValue {
+ *         if (typeof lastUpdatedMillis !== 'number') {
+ *             // `lastUpdatedMillis` must be a FieldValue, so just return it.
+ *             return lastUpdatedMillis;
+ *         }
+ *         return Timestamp.fromMillis(lastUpdatedMillis);
+ *     }
+ * }
+ *
+ * async function advancedDemo(db: Firestore): Promise<void> {
+ *     // Create a `DocumentReference` with a `FirestoreDataConverter`.
+ *     const documentRef = doc(db, 'posts/post123').withConverter(new PostConverter());
+ *
+ *     // The `data` argument specified to `setDoc()` is type checked by the
+ *     // TypeScript compiler to be compatible with `Post`. Since the `data`
+ *     // argument is typed as `WithFieldValue<Post>` rather than just `Post`,
+ *     // this allows properties of the `data` argument to also be special
+ *     // Firestore values that perform server-side mutations, such as
+ *     // `arrayRemove()`, `deleteField()`, and `serverTimestamp()`.
+ *     await setDoc(documentRef, {
+ *         title: 'My Life',
+ *         author: 'Foo Bar',
+ *         lastUpdatedMillis: serverTimestamp()
+ *     });
+ *
+ *     // The TypeScript compiler will fail to compile if the `data` argument to
+ *     // `setDoc()` is _not_ compatible with `WithFieldValue<Post>`. This
+ *     // type checking prevents the caller from specifying objects with incorrect
+ *     // properties or property values.
+ *     // @ts-expect-error "Argument of type { ttl: string; } is not assignable
+ *     // to parameter of type WithFieldValue<Post>"
+ *     await setDoc(documentRef, { ttl: 'The Title' });
+ *
+ *     // When retrieving a document with `getDoc()` the `DocumentSnapshot`
+ *     // object's `data()` method returns a `Post`, rather than a generic object,
+ *     // which would have been returned if the `DocumentReference` did _not_ have a
+ *     // `FirestoreDataConverter` attached to it.
+ *     const snapshot1: DocumentSnapshot<Post> = await getDoc(documentRef);
+ *     const post1: Post = snapshot1.data()!;
+ *     if (post1) {
+ *         assertEqual(post1.title, 'My Life');
+ *         assertEqual(post1.author, 'Foo Bar');
+ *     }
+ *
+ *     // The `data` argument specified to `updateDoc()` is type checked by the
+ *     // TypeScript compiler to be compatible with `PostDbModel`. Note that
+ *     // unlike `setDoc()`, whose `data` argument must be compatible with `Post`,
+ *     // the `data` argument to `updateDoc()` must be compatible with
+ *     // `PostDbModel`. Similar to `setDoc()`, since the `data` argument is typed
+ *     // as `WithFieldValue<PostDbModel>` rather than just `PostDbModel`, this
+ *     // allows properties of the `data` argument to also be those special
+ *     // Firestore values, like `arrayRemove()`, `deleteField()`, and
+ *     // `serverTimestamp()`.
+ *     await updateDoc(documentRef, {
+ *         'aut.firstName': 'NewFirstName',
+ *         lut: serverTimestamp()
+ *     });
+ *
+ *     // The TypeScript compiler will fail to compile if the `data` argument to
+ *     // `updateDoc()` is _not_ compatible with `WithFieldValue<PostDbModel>`.
+ *     // This type checking prevents the caller from specifying objects with
+ *     // incorrect properties or property values.
+ *     // @ts-expect-error "Argument of type { title: string; } is not assignable
+ *     // to parameter of type WithFieldValue<PostDbModel>"
+ *     await updateDoc(documentRef, { title: 'New Title' });
+ *     const snapshot2: DocumentSnapshot<Post> = await getDoc(documentRef);
+ *     const post2: Post = snapshot2.data()!;
+ *     if (post2) {
+ *         assertEqual(post2.title, 'My Life');
+ *         assertEqual(post2.author, 'NewFirstName Bar');
+ *     }
+ * }
+ * ```
+ */
+export interface FirestoreDataConverter<AppModelType, DbModelType extends DocumentData = DocumentData> extends LiteFirestoreDataConverter<AppModelType, DbModelType> {
+    /**
+     * Called by the Firestore SDK to convert a custom model object of type
+     * `AppModelType` into a plain JavaScript object (suitable for writing
+     * directly to the Firestore database) of type `DbModelType`. To use `set()`
+     * with `merge` and `mergeFields`, `toFirestore()` must be defined with
+     * `PartialWithFieldValue<AppModelType>`.
+     *
+     * The `WithFieldValue<T>` type extends `T` to also allow FieldValues such as
+     * {@link (deleteField:1)} to be used as property values.
+     */
+    toFirestore(modelObject: WithFieldValue<AppModelType>): WithFieldValue<DbModelType>;
+    /**
+     * Called by the Firestore SDK to convert a custom model object of type
+     * `AppModelType` into a plain JavaScript object (suitable for writing
+     * directly to the Firestore database) of type `DbModelType`. Used with
+     * {@link (setDoc:1)}, {@link (WriteBatch.set:1)} and
+     * {@link (Transaction.set:1)} with `merge:true` or `mergeFields`.
+     *
+     * The `PartialWithFieldValue<T>` type extends `Partial<T>` to allow
+     * FieldValues such as {@link (arrayUnion:1)} to be used as property values.
+     * It also supports nested `Partial` by allowing nested fields to be
+     * omitted.
+     */
+    toFirestore(modelObject: PartialWithFieldValue<AppModelType>, options: SetOptions): PartialWithFieldValue<DbModelType>;
+    /**
+     * Called by the Firestore SDK to convert Firestore data into an object of
+     * type `AppModelType`. You can access your data by calling:
+     * `snapshot.data(options)`.
+     *
+     * Generally, the data returned from `snapshot.data()` can be cast to
+     * `DbModelType`; however, this is not guaranteed because Firestore does not
+     * enforce a schema on the database. For example, writes from a previous
+     * version of the application or writes from another client that did not use a
+     * type converter could have written data with different properties and/or
+     * property types. The implementation will need to choose whether to
+     * gracefully recover from non-conforming data or throw an error.
+     *
+     * To override this method, see {@link (FirestoreDataConverter.fromFirestore:1)}.
+     *
+     * @param snapshot - A `QueryDocumentSnapshot` containing your data and metadata.
+     * @param options - The `SnapshotOptions` from the initial call to `data()`.
+     */
+    fromFirestore(snapshot: QueryDocumentSnapshot<DocumentData, DocumentData>, options?: SnapshotOptions): AppModelType;
+}
+/**
+ * Options that configure how data is retrieved from a `DocumentSnapshot` (for
+ * example the desired behavior for server timestamps that have not yet been set
+ * to their final value).
+ */
+export interface SnapshotOptions {
+    /**
+     * If set, controls the return value for server timestamps that have not yet
+     * been set to their final value.
+     *
+     * By specifying 'estimate', pending server timestamps return an estimate
+     * based on the local clock. This estimate will differ from the final value
+     * and cause these values to change once the server result becomes available.
+     *
+     * By specifying 'previous', pending timestamps will be ignored and return
+     * their previous value instead.
+     *
+     * If omitted or set to 'none', `null` will be returned by default until the
+     * server value becomes available.
+     */
+    readonly serverTimestamps?: 'estimate' | 'previous' | 'none';
+}
+/**
+ * Metadata about a snapshot, describing the state of the snapshot.
+ */
+export declare class SnapshotMetadata {
+    /**
+     * True if the snapshot contains the result of local writes (for example
+     * `set()` or `update()` calls) that have not yet been committed to the
+     * backend. If your listener has opted into metadata updates (via
+     * `SnapshotListenOptions`) you will receive another snapshot with
+     * `hasPendingWrites` equal to false once the writes have been committed to
+     * the backend.
+     */
+    readonly hasPendingWrites: boolean;
+    /**
+     * True if the snapshot was created from cached data rather than guaranteed
+     * up-to-date server data. If your listener has opted into metadata updates
+     * (via `SnapshotListenOptions`) you will receive another snapshot with
+     * `fromCache` set to false once the client has received up-to-date data from
+     * the backend.
+     */
+    readonly fromCache: boolean;
+    /** @hideconstructor */
+    constructor(hasPendingWrites: boolean, fromCache: boolean);
+    /**
+     * Returns true if this `SnapshotMetadata` is equal to the provided one.
+     *
+     * @param other - The `SnapshotMetadata` to compare against.
+     * @returns true if this `SnapshotMetadata` is equal to the provided one.
+     */
+    isEqual(other: SnapshotMetadata): boolean;
+}
+/**
+ * The type of a `DocumentChange` may be 'added', 'removed', or 'modified'.
+ */
+export type DocumentChangeType = 'added' | 'removed' | 'modified';
+/**
+ * A `DocumentChange` represents a change to the documents matching a query.
+ * It contains the document affected and the type of change that occurred.
+ */
+export interface DocumentChange<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
+    /** The type of change ('added', 'modified', or 'removed'). */
+    readonly type: DocumentChangeType;
+    /** The document affected by this change. */
+    readonly doc: QueryDocumentSnapshot<AppModelType, DbModelType>;
+    /**
+     * The index of the changed document in the result set immediately prior to
+     * this `DocumentChange` (i.e. supposing that all prior `DocumentChange` objects
+     * have been applied). Is `-1` for 'added' events.
+     */
+    readonly oldIndex: number;
+    /**
+     * The index of the changed document in the result set immediately after
+     * this `DocumentChange` (i.e. supposing that all prior `DocumentChange`
+     * objects and the current `DocumentChange` object have been applied).
+     * Is -1 for 'removed' events.
+     */
+    readonly newIndex: number;
+}
+/**
+ * A `DocumentSnapshot` contains data read from a document in your Firestore
+ * database. The data can be extracted with `.data()` or `.get(<field>)` to
+ * get a specific field.
+ *
+ * For a `DocumentSnapshot` that points to a non-existing document, any data
+ * access will return 'undefined'. You can use the `exists()` method to
+ * explicitly verify a document's existence.
+ */
+export declare class DocumentSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> extends LiteDocumentSnapshot<AppModelType, DbModelType> {
+    readonly _firestore: Firestore;
+    private readonly _firestoreImpl;
+    /**
+     *  Metadata about the `DocumentSnapshot`, including information about its
+     *  source and local modifications.
+     */
+    readonly metadata: SnapshotMetadata;
+    /** @hideconstructor protected */
+    constructor(_firestore: Firestore, userDataWriter: AbstractUserDataWriter, key: DocumentKey, document: Document | null, metadata: SnapshotMetadata, converter: UntypedFirestoreDataConverter<AppModelType, DbModelType> | null);
+    /**
+     * Returns whether or not the data exists. True if the document exists.
+     */
+    exists(): this is QueryDocumentSnapshot<AppModelType, DbModelType>;
+    /**
+     * Retrieves all fields in the document as an `Object`. Returns `undefined` if
+     * the document doesn't exist.
+     *
+     * By default, `serverTimestamp()` values that have not yet been
+     * set to their final value will be returned as `null`. You can override
+     * this by passing an options object.
+     *
+     * @param options - An options object to configure how data is retrieved from
+     * the snapshot (for example the desired behavior for server timestamps that
+     * have not yet been set to their final value).
+     * @returns An `Object` containing all fields in the document or `undefined` if
+     * the document doesn't exist.
+     */
+    data(options?: SnapshotOptions): AppModelType | undefined;
+    /**
+     * Retrieves the field specified by `fieldPath`. Returns `undefined` if the
+     * document or field doesn't exist.
+     *
+     * By default, a `serverTimestamp()` that has not yet been set to
+     * its final value will be returned as `null`. You can override this by
+     * passing an options object.
+     *
+     * @param fieldPath - The path (for example 'foo' or 'foo.bar') to a specific
+     * field.
+     * @param options - An options object to configure how the field is retrieved
+     * from the snapshot (for example the desired behavior for server timestamps
+     * that have not yet been set to their final value).
+     * @returns The data at the specified field location or undefined if no such
+     * field exists in the document.
+     */
+    get(fieldPath: string | FieldPath, options?: SnapshotOptions): any;
+    static _jsonSchemaVersion: string;
+    static _jsonSchema: {
+        type: Property<"string">;
+        bundleSource: Property<"string">;
+        bundleName: Property<"string">;
+        bundle: Property<"string">;
+    };
+    /**
+     * Returns a JSON-serializable representation of this `DocumentSnapshot` instance.
+     *
+     * @returns a JSON representation of this object.  Throws a {@link FirestoreError} if this
+     * `DocumentSnapshot` has pending writes.
+     */
+    toJSON(): object;
+}
+/**
+ * Builds a `DocumentSnapshot` instance from a JSON object created by
+ * {@link DocumentSnapshot.toJSON}.
+ *
+ * @param firestore - The {@link Firestore} instance the snapshot should be loaded for.
+ * @param json - a JSON object represention of a `DocumentSnapshot` instance.
+ * @returns an instance of {@link DocumentSnapshot} if the JSON object could be
+ * parsed. Throws a {@link FirestoreError} if an error occurs.
+ */
+export declare function documentSnapshotFromJSON(db: Firestore, json: object): DocumentSnapshot;
+/**
+ * Builds a `DocumentSnapshot` instance from a JSON object created by
+ * {@link DocumentSnapshot.toJSON}.
+ *
+ * @param firestore - The {@link Firestore} instance the snapshot should be loaded for.
+ * @param json - a JSON object represention of a `DocumentSnapshot` instance.
+ * @param converter - Converts objects to and from Firestore.
+ * @returns an instance of {@link DocumentSnapshot} if the JSON object could be
+ * parsed. Throws a {@link FirestoreError} if an error occurs.
+ */
+export declare function documentSnapshotFromJSON<AppModelType, DbModelType extends DocumentData = DocumentData>(db: Firestore, json: object, converter: FirestoreDataConverter<AppModelType, DbModelType>): DocumentSnapshot<AppModelType, DbModelType>;
+/**
+ * A `QueryDocumentSnapshot` contains data read from a document in your
+ * Firestore database as part of a query. The document is guaranteed to exist
+ * and its data can be extracted with `.data()` or `.get(<field>)` to get a
+ * specific field.
+ *
+ * A `QueryDocumentSnapshot` offers the same API surface as a
+ * `DocumentSnapshot`. Since query results contain only existing documents, the
+ * `exists` property will always be true and `data()` will never return
+ * 'undefined'.
+ */
+export declare class QueryDocumentSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> extends DocumentSnapshot<AppModelType, DbModelType> {
+    /**
+     * Retrieves all fields in the document as an `Object`.
+     *
+     * By default, `serverTimestamp()` values that have not yet been
+     * set to their final value will be returned as `null`. You can override
+     * this by passing an options object.
+     *
+     * @override
+     * @param options - An options object to configure how data is retrieved from
+     * the snapshot (for example the desired behavior for server timestamps that
+     * have not yet been set to their final value).
+     * @returns An `Object` containing all fields in the document.
+     */
+    data(options?: SnapshotOptions): AppModelType;
+}
+/**
+ * A `QuerySnapshot` contains zero or more `DocumentSnapshot` objects
+ * representing the results of a query. The documents can be accessed as an
+ * array via the `docs` property or enumerated using the `forEach` method. The
+ * number of documents can be determined via the `empty` and `size`
+ * properties.
+ */
+export declare class QuerySnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> {
+    readonly _firestore: Firestore;
+    readonly _userDataWriter: AbstractUserDataWriter;
+    readonly _snapshot: ViewSnapshot;
+    /**
+     * Metadata about this snapshot, concerning its source and if it has local
+     * modifications.
+     */
+    readonly metadata: SnapshotMetadata;
+    /**
+     * The query on which you called `get` or `onSnapshot` in order to get this
+     * `QuerySnapshot`.
+     */
+    readonly query: Query<AppModelType, DbModelType>;
+    private _cachedChanges?;
+    private _cachedChangesIncludeMetadataChanges?;
+    /** @hideconstructor */
+    constructor(_firestore: Firestore, _userDataWriter: AbstractUserDataWriter, query: Query<AppModelType, DbModelType>, _snapshot: ViewSnapshot);
+    /** An array of all the documents in the `QuerySnapshot`. */
+    get docs(): Array<QueryDocumentSnapshot<AppModelType, DbModelType>>;
+    /** The number of documents in the `QuerySnapshot`. */
+    get size(): number;
+    /** True if there are no documents in the `QuerySnapshot`. */
+    get empty(): boolean;
+    /**
+     * Enumerates all of the documents in the `QuerySnapshot`.
+     *
+     * @param callback - A callback to be called with a `QueryDocumentSnapshot` for
+     * each document in the snapshot.
+     * @param thisArg - The `this` binding for the callback.
+     */
+    forEach(callback: (result: QueryDocumentSnapshot<AppModelType, DbModelType>) => void, thisArg?: unknown): void;
+    /**
+     * Returns an array of the documents changes since the last snapshot. If this
+     * is the first snapshot, all documents will be in the list as 'added'
+     * changes.
+     *
+     * @param options - `SnapshotListenOptions` that control whether metadata-only
+     * changes (i.e. only `DocumentSnapshot.metadata` changed) should trigger
+     * snapshot events.
+     */
+    docChanges(options?: SnapshotListenOptions): Array<DocumentChange<AppModelType, DbModelType>>;
+    static _jsonSchemaVersion: string;
+    static _jsonSchema: {
+        type: Property<"string">;
+        bundleSource: Property<"string">;
+        bundleName: Property<"string">;
+        bundle: Property<"string">;
+    };
+    /**
+     * Returns a JSON-serializable representation of this `QuerySnapshot` instance.
+     *
+     * @returns a JSON representation of this object. Throws a {@link FirestoreError} if this
+     * `QuerySnapshot` has pending writes.
+     */
+    toJSON(): object;
+}
+/**
+ * Builds a `QuerySnapshot` instance from a JSON object created by
+ * {@link QuerySnapshot.toJSON}.
+ *
+ * @param firestore - The {@link Firestore} instance the snapshot should be loaded for.
+ * @param json - a JSON object represention of a `QuerySnapshot` instance.
+ * @returns an instance of {@link QuerySnapshot} if the JSON object could be
+ * parsed. Throws a {@link FirestoreError} if an error occurs.
+ */
+export declare function querySnapshotFromJSON(db: Firestore, json: object): QuerySnapshot;
+/**
+ * Builds a `QuerySnapshot` instance from a JSON object created by
+ * {@link QuerySnapshot.toJSON}.
+ *
+ * @param firestore - The {@link Firestore} instance the snapshot should be loaded for.
+ * @param json - a JSON object represention of a `QuerySnapshot` instance.
+ * @param converter - Converts objects to and from Firestore.
+ * @returns an instance of {@link QuerySnapshot} if the JSON object could be
+ * parsed. Throws a {@link FirestoreError} if an error occurs.
+ */
+export declare function querySnapshotFromJSON<AppModelType, DbModelType extends DocumentData = DocumentData>(db: Firestore, json: object, converter: FirestoreDataConverter<AppModelType, DbModelType>): QuerySnapshot<AppModelType, DbModelType>;
+/** Calculates the array of `DocumentChange`s for a given `ViewSnapshot`. */
+export declare function changesFromSnapshot<AppModelType, DbModelType extends DocumentData>(querySnapshot: QuerySnapshot<AppModelType, DbModelType>, includeMetadataChanges: boolean): Array<DocumentChange<AppModelType, DbModelType>>;
+export declare function resultChangeType(type: ChangeType): DocumentChangeType;
+/**
+ * Returns true if the provided snapshots are equal.
+ *
+ * @param left - A snapshot to compare.
+ * @param right - A snapshot to compare.
+ * @returns true if the snapshots are equal.
+ */
+export declare function snapshotEqual<AppModelType, DbModelType extends DocumentData>(left: DocumentSnapshot<AppModelType, DbModelType> | QuerySnapshot<AppModelType, DbModelType>, right: DocumentSnapshot<AppModelType, DbModelType> | QuerySnapshot<AppModelType, DbModelType>): boolean;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/timestamp.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/timestamp.d.ts
new file mode 100644
index 0000000..35969cd
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/timestamp.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export { Timestamp } from '../lite-api/timestamp';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction.d.ts
new file mode 100644
index 0000000..eccd1fb
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction.d.ts
@@ -0,0 +1,61 @@
+/**
+ * @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 { Transaction as InternalTransaction } from '../core/transaction';
+import { DocumentData, DocumentReference } from '../lite-api/reference';
+import { Transaction as LiteTransaction } from '../lite-api/transaction';
+import { Firestore } from './database';
+import { DocumentSnapshot } from './snapshot';
+import { TransactionOptions } from './transaction_options';
+/**
+ * A reference to a transaction.
+ *
+ * The `Transaction` object passed to a transaction's `updateFunction` provides
+ * the methods to read and write data within the transaction context. See
+ * {@link runTransaction}.
+ */
+export declare class Transaction extends LiteTransaction {
+    protected readonly _firestore: Firestore;
+    /** @hideconstructor */
+    constructor(_firestore: Firestore, _transaction: InternalTransaction);
+    /**
+     * Reads the document referenced by the provided {@link DocumentReference}.
+     *
+     * @param documentRef - A reference to the document to be read.
+     * @returns A `DocumentSnapshot` with the read data.
+     */
+    get<AppModelType, DbModelType extends DocumentData>(documentRef: DocumentReference<AppModelType, DbModelType>): Promise<DocumentSnapshot<AppModelType, DbModelType>>;
+}
+/**
+ * Executes the given `updateFunction` and then attempts to commit the changes
+ * applied within the transaction. If any document read within the transaction
+ * has changed, Cloud Firestore retries the `updateFunction`. If it fails to
+ * commit after 5 attempts, the transaction fails.
+ *
+ * The maximum number of writes allowed in a single transaction is 500.
+ *
+ * @param firestore - A reference to the Firestore database to run this
+ * transaction against.
+ * @param updateFunction - The function to execute within the transaction
+ * context.
+ * @param options - An options object to configure maximum number of attempts to
+ * commit.
+ * @returns If the transaction completed successfully or was explicitly aborted
+ * (the `updateFunction` returned a failed promise), the promise returned by the
+ * `updateFunction `is returned here. Otherwise, if the transaction failed, a
+ * rejected promise with the corresponding failure error is returned.
+ */
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction_options.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction_options.d.ts
new file mode 100644
index 0000000..578e4f4
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction_options.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 { TransactionOptions } from '../lite-api/transaction_options';
diff --git a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/write_batch.d.ts b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/write_batch.d.ts
new file mode 100644
index 0000000..13b31d8
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/write_batch.d.ts
@@ -0,0 +1,31 @@
+/**
+ * @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 { WriteBatch } from '../lite-api/write_batch';
+import { Firestore } from './database';
+export { WriteBatch };
+/**
+ * Creates a write batch, used for performing multiple writes as a single
+ * atomic operation. The maximum number of writes allowed in a single {@link WriteBatch}
+ * is 500.
+ *
+ * Unlike transactions, write batches are persisted offline and therefore are
+ * preferable when you don't need to condition your writes on read data.
+ *
+ * @returns A {@link WriteBatch} that can be used to atomically execute multiple
+ * writes.
+ */
+export declare function writeBatch(firestore: Firestore): WriteBatch;