sdk, del

24 files changed, 0 insertions, 2636 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
deleted file mode 100644
index 39bd4b4..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/aggregate.d.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 15c33af..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bundle.d.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 0c9f5fd..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/bytes.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 936f21e..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/cache_config.d.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 98ed3c2..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/credentials.d.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 8004dae..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/database.d.ts
+++ /dev/null
@@ -1,279 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 7e463e5..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_path.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index eded0bc..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index aac67c3..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/field_value_impl.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 1dee60b..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/filter.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index b14def6..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/geo_point.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 8b10775..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/index_configuration.d.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 0088194..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/long_polling_options.d.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 1aa4b85..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/observer.d.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * @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
deleted file mode 100644
index d2b0beb..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/parse_context.d.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- * @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
deleted file mode 100644
index c6e4b46..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/persistent_cache_index_manager.d.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 0e38648..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 5dd95e6..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/reference_impl.d.ts
+++ /dev/null
@@ -1,536 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 8565811..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/settings.d.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 24d863e..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/snapshot.d.ts
+++ /dev/null
@@ -1,550 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 35969cd..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/timestamp.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index eccd1fb..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction.d.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 578e4f4..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/transaction_options.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- * @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
deleted file mode 100644
index 13b31d8..0000000
--- a/frontend-old/node_modules/@firebase/firestore/dist/firestore/src/api/write_batch.d.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * @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;