pain

137 files changed, 8908 insertions, 0 deletions

diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/account.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/account.d.ts
new file mode 100644
index 0000000..f106e93
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/account.d.ts
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { MfaEnrollment } from './mfa';
+import { Auth } from '../../model/public_types';
+export interface DeleteAccountRequest {
+    idToken: string;
+}
+export declare function deleteAccount(auth: Auth, request: DeleteAccountRequest): Promise<void>;
+export interface ProviderUserInfo {
+    providerId: string;
+    rawId?: string;
+    email?: string;
+    displayName?: string;
+    photoUrl?: string;
+    phoneNumber?: string;
+}
+export interface DeleteLinkedAccountsRequest {
+    idToken: string;
+    deleteProvider: string[];
+}
+export interface DeleteLinkedAccountsResponse {
+    providerUserInfo: ProviderUserInfo[];
+}
+export declare function deleteLinkedAccounts(auth: Auth, request: DeleteLinkedAccountsRequest): Promise<DeleteLinkedAccountsResponse>;
+export interface APIUserInfo {
+    localId?: string;
+    displayName?: string;
+    photoUrl?: string;
+    email?: string;
+    emailVerified?: boolean;
+    phoneNumber?: string;
+    lastLoginAt?: number;
+    createdAt?: number;
+    tenantId?: string;
+    passwordHash?: string;
+    providerUserInfo?: ProviderUserInfo[];
+    mfaInfo?: MfaEnrollment[];
+}
+export interface GetAccountInfoRequest {
+    idToken: string;
+}
+export interface GetAccountInfoResponse {
+    users: APIUserInfo[];
+}
+export declare function getAccountInfo(auth: Auth, request: GetAccountInfoRequest): Promise<GetAccountInfoResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/email_and_password.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/email_and_password.d.ts
new file mode 100644
index 0000000..5a3bb06
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/email_and_password.d.ts
@@ -0,0 +1,49 @@
+/**
+ * @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 { ActionCodeOperation, Auth } from '../../model/public_types';
+import { IdTokenResponse } from '../../model/id_token';
+import { MfaEnrollment } from './mfa';
+import { SignUpRequest, SignUpResponse } from '../authentication/sign_up';
+export interface ResetPasswordRequest {
+    oobCode: string;
+    newPassword?: string;
+    tenantId?: string;
+}
+export interface ResetPasswordResponse {
+    email: string;
+    newEmail?: string;
+    requestType?: ActionCodeOperation;
+    mfaInfo?: MfaEnrollment;
+}
+export declare function resetPassword(auth: Auth, request: ResetPasswordRequest): Promise<ResetPasswordResponse>;
+export interface UpdateEmailPasswordRequest {
+    idToken: string;
+    returnSecureToken?: boolean;
+    email?: string;
+    password?: string;
+}
+export interface UpdateEmailPasswordResponse extends IdTokenResponse {
+}
+export declare function updateEmailPassword(auth: Auth, request: UpdateEmailPasswordRequest): Promise<UpdateEmailPasswordResponse>;
+export declare function linkEmailPassword(auth: Auth, request: SignUpRequest): Promise<SignUpResponse>;
+export interface ApplyActionCodeRequest {
+    oobCode: string;
+    tenantId?: string;
+}
+export interface ApplyActionCodeResponse {
+}
+export declare function applyActionCode(auth: Auth, request: ApplyActionCodeRequest): Promise<ApplyActionCodeResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/mfa.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/mfa.d.ts
new file mode 100644
index 0000000..8db0c0d
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/mfa.d.ts
@@ -0,0 +1,107 @@
+/**
+ * @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 { RecaptchaClientType, RecaptchaVersion } from '../index';
+import { SignInWithPhoneNumberRequest } from '../authentication/sms';
+import { FinalizeMfaResponse } from '../authentication/mfa';
+import { AuthInternal } from '../../model/auth';
+/**
+ * MFA Info as returned by the API.
+ */
+interface BaseMfaEnrollment {
+    mfaEnrollmentId: string;
+    enrolledAt: number;
+    displayName?: string;
+}
+/**
+ * An MFA provided by SMS verification.
+ */
+export interface PhoneMfaEnrollment extends BaseMfaEnrollment {
+    phoneInfo: string;
+}
+/**
+ * An MFA provided by TOTP (Time-based One Time Password).
+ */
+export interface TotpMfaEnrollment extends BaseMfaEnrollment {
+}
+/**
+ * MfaEnrollment can be any subtype of BaseMfaEnrollment, currently only PhoneMfaEnrollment and TotpMfaEnrollment are supported.
+ */
+export type MfaEnrollment = PhoneMfaEnrollment | TotpMfaEnrollment;
+export interface StartPhoneMfaEnrollmentRequest {
+    idToken: string;
+    phoneEnrollmentInfo: {
+        phoneNumber: string;
+        recaptchaToken?: string;
+        captchaResponse?: string;
+        clientType?: RecaptchaClientType;
+        recaptchaVersion?: RecaptchaVersion;
+    };
+    tenantId?: string;
+}
+export interface StartPhoneMfaEnrollmentResponse {
+    phoneSessionInfo: {
+        sessionInfo: string;
+    };
+}
+export declare function startEnrollPhoneMfa(auth: AuthInternal, request: StartPhoneMfaEnrollmentRequest): Promise<StartPhoneMfaEnrollmentResponse>;
+export interface FinalizePhoneMfaEnrollmentRequest {
+    idToken: string;
+    phoneVerificationInfo: SignInWithPhoneNumberRequest;
+    displayName?: string | null;
+    tenantId?: string;
+}
+export interface FinalizePhoneMfaEnrollmentResponse extends FinalizeMfaResponse {
+}
+export declare function finalizeEnrollPhoneMfa(auth: AuthInternal, request: FinalizePhoneMfaEnrollmentRequest): Promise<FinalizePhoneMfaEnrollmentResponse>;
+export interface StartTotpMfaEnrollmentRequest {
+    idToken: string;
+    totpEnrollmentInfo: {};
+    tenantId?: string;
+}
+export interface StartTotpMfaEnrollmentResponse {
+    totpSessionInfo: {
+        sharedSecretKey: string;
+        verificationCodeLength: number;
+        hashingAlgorithm: string;
+        periodSec: number;
+        sessionInfo: string;
+        finalizeEnrollmentTime: number;
+    };
+}
+export declare function startEnrollTotpMfa(auth: AuthInternal, request: StartTotpMfaEnrollmentRequest): Promise<StartTotpMfaEnrollmentResponse>;
+export interface TotpVerificationInfo {
+    sessionInfo: string;
+    verificationCode: string;
+}
+export interface FinalizeTotpMfaEnrollmentRequest {
+    idToken: string;
+    totpVerificationInfo: TotpVerificationInfo;
+    displayName?: string | null;
+    tenantId?: string;
+}
+export interface FinalizeTotpMfaEnrollmentResponse extends FinalizeMfaResponse {
+}
+export declare function finalizeEnrollTotpMfa(auth: AuthInternal, request: FinalizeTotpMfaEnrollmentRequest): Promise<FinalizeTotpMfaEnrollmentResponse>;
+export interface WithdrawMfaRequest {
+    idToken: string;
+    mfaEnrollmentId: string;
+    tenantId?: string;
+}
+export interface WithdrawMfaResponse extends FinalizeMfaResponse {
+}
+export declare function withdrawMfa(auth: AuthInternal, request: WithdrawMfaRequest): Promise<WithdrawMfaResponse>;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/profile.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/profile.d.ts
new file mode 100644
index 0000000..9b1d591
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/account_management/profile.d.ts
@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { IdTokenResponse } from '../../model/id_token';
+import { Auth } from '../../model/public_types';
+export interface UpdateProfileRequest {
+    idToken: string;
+    displayName?: string | null;
+    photoUrl?: string | null;
+    returnSecureToken: boolean;
+}
+export interface UpdateProfileResponse extends IdTokenResponse {
+    displayName?: string | null;
+    photoUrl?: string | null;
+}
+export declare function updateProfile(auth: Auth, request: UpdateProfileRequest): Promise<UpdateProfileResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/create_auth_uri.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/create_auth_uri.d.ts
new file mode 100644
index 0000000..8c2db00
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/create_auth_uri.d.ts
@@ -0,0 +1,26 @@
+/**
+ * @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 { Auth } from '../../model/public_types';
+export interface CreateAuthUriRequest {
+    identifier: string;
+    continueUri: string;
+    tenantId?: string;
+}
+export interface CreateAuthUriResponse {
+    signinMethods: string[];
+}
+export declare function createAuthUri(auth: Auth, request: CreateAuthUriRequest): Promise<CreateAuthUriResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/custom_token.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/custom_token.d.ts
new file mode 100644
index 0000000..ad776c7
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/custom_token.d.ts
@@ -0,0 +1,26 @@
+/**
+ * @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 { IdTokenResponse } from '../../model/id_token';
+import { Auth } from '../../model/public_types';
+export interface SignInWithCustomTokenRequest {
+    token: string;
+    returnSecureToken: boolean;
+    tenantId?: string;
+}
+export interface SignInWithCustomTokenResponse extends IdTokenResponse {
+}
+export declare function signInWithCustomToken(auth: Auth, request: SignInWithCustomTokenRequest): Promise<SignInWithCustomTokenResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/email_and_password.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/email_and_password.d.ts
new file mode 100644
index 0000000..90028bd
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/email_and_password.d.ts
@@ -0,0 +1,86 @@
+/**
+ * @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 { ActionCodeOperation, Auth } from '../../model/public_types';
+import { RecaptchaClientType, RecaptchaVersion } from '../index';
+import { IdToken, IdTokenResponse } from '../../model/id_token';
+export interface SignInWithPasswordRequest {
+    returnSecureToken?: boolean;
+    email: string;
+    password: string;
+    tenantId?: string;
+    captchaResponse?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
+}
+export interface SignInWithPasswordResponse extends IdTokenResponse {
+    email: string;
+    displayName: string;
+}
+export declare function signInWithPassword(auth: Auth, request: SignInWithPasswordRequest): Promise<SignInWithPasswordResponse>;
+export interface GetOobCodeRequest {
+    email?: string;
+    continueUrl?: string;
+    iOSBundleId?: string;
+    iosAppStoreId?: string;
+    androidPackageName?: string;
+    androidInstallApp?: boolean;
+    androidMinimumVersionCode?: string;
+    canHandleCodeInApp?: boolean;
+    dynamicLinkDomain?: string;
+    tenantId?: string;
+    targetProjectid?: string;
+    linkDomain?: string;
+}
+export interface VerifyEmailRequest extends GetOobCodeRequest {
+    requestType: ActionCodeOperation.VERIFY_EMAIL;
+    idToken: IdToken;
+}
+export interface PasswordResetRequest extends GetOobCodeRequest {
+    requestType: ActionCodeOperation.PASSWORD_RESET;
+    email: string;
+    captchaResp?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
+}
+export interface EmailSignInRequest extends GetOobCodeRequest {
+    requestType: ActionCodeOperation.EMAIL_SIGNIN;
+    email: string;
+    captchaResp?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
+}
+export interface VerifyAndChangeEmailRequest extends GetOobCodeRequest {
+    requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;
+    idToken: IdToken;
+    newEmail: string;
+}
+interface GetOobCodeResponse {
+    email: string;
+}
+export interface VerifyEmailResponse extends GetOobCodeResponse {
+}
+export interface PasswordResetResponse extends GetOobCodeResponse {
+}
+export interface EmailSignInResponse extends GetOobCodeResponse {
+}
+export interface VerifyAndChangeEmailResponse extends GetOobCodeRequest {
+}
+export declare function sendEmailVerification(auth: Auth, request: VerifyEmailRequest): Promise<VerifyEmailResponse>;
+export declare function sendPasswordResetEmail(auth: Auth, request: PasswordResetRequest): Promise<PasswordResetResponse>;
+export declare function sendSignInLinkToEmail(auth: Auth, request: EmailSignInRequest): Promise<EmailSignInResponse>;
+export declare function verifyAndChangeEmail(auth: Auth, request: VerifyAndChangeEmailRequest): Promise<VerifyAndChangeEmailResponse>;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/email_link.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/email_link.d.ts
new file mode 100644
index 0000000..eef24a5
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/email_link.d.ts
@@ -0,0 +1,32 @@
+/**
+ * @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 { IdTokenResponse } from '../../model/id_token';
+import { Auth } from '../../model/public_types';
+export interface SignInWithEmailLinkRequest {
+    email: string;
+    oobCode: string;
+    tenantId?: string;
+}
+export interface SignInWithEmailLinkResponse extends IdTokenResponse {
+    email: string;
+    isNewUser: boolean;
+}
+export declare function signInWithEmailLink(auth: Auth, request: SignInWithEmailLinkRequest): Promise<SignInWithEmailLinkResponse>;
+export interface SignInWithEmailLinkForLinkingRequest extends SignInWithEmailLinkRequest {
+    idToken: string;
+}
+export declare function signInWithEmailLinkForLinking(auth: Auth, request: SignInWithEmailLinkForLinkingRequest): Promise<SignInWithEmailLinkResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/idp.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/idp.d.ts
new file mode 100644
index 0000000..dd75832
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/idp.d.ts
@@ -0,0 +1,40 @@
+/**
+ * @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 { IdToken, IdTokenResponse } from '../../model/id_token';
+import { Auth } from '../../model/public_types';
+export interface SignInWithIdpRequest {
+    requestUri: string;
+    postBody?: string;
+    sessionId?: string;
+    tenantId?: string;
+    returnSecureToken: boolean;
+    returnIdpCredential?: boolean;
+    idToken?: IdToken;
+    autoCreate?: boolean;
+    pendingToken?: string;
+}
+/**
+ * @internal
+ */
+export interface SignInWithIdpResponse extends IdTokenResponse {
+    oauthAccessToken?: string;
+    oauthTokenSecret?: string;
+    nonce?: string;
+    oauthIdToken?: string;
+    pendingToken?: string;
+}
+export declare function signInWithIdp(auth: Auth, request: SignInWithIdpRequest): Promise<SignInWithIdpResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/mfa.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/mfa.d.ts
new file mode 100644
index 0000000..0d2abed
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/mfa.d.ts
@@ -0,0 +1,73 @@
+/**
+ * @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 { RecaptchaClientType, RecaptchaVersion } from '../index';
+import { Auth } from '../../model/public_types';
+import { IdTokenResponse } from '../../model/id_token';
+import { MfaEnrollment } from '../account_management/mfa';
+import { SignInWithIdpResponse } from './idp';
+import { SignInWithPhoneNumberRequest, SignInWithPhoneNumberResponse } from './sms';
+export interface FinalizeMfaResponse {
+    idToken: string;
+    refreshToken: string;
+}
+/**
+ * @internal
+ */
+export interface IdTokenMfaResponse extends IdTokenResponse {
+    mfaPendingCredential?: string;
+    mfaInfo?: MfaEnrollment[];
+}
+export interface StartPhoneMfaSignInRequest {
+    mfaPendingCredential: string;
+    mfaEnrollmentId: string;
+    phoneSignInInfo: {
+        recaptchaToken?: string;
+        captchaResponse?: string;
+        clientType?: RecaptchaClientType;
+        recaptchaVersion?: RecaptchaVersion;
+    };
+    tenantId?: string;
+}
+export interface StartPhoneMfaSignInResponse {
+    phoneResponseInfo: {
+        sessionInfo: string;
+    };
+}
+export declare function startSignInPhoneMfa(auth: Auth, request: StartPhoneMfaSignInRequest): Promise<StartPhoneMfaSignInResponse>;
+export interface FinalizePhoneMfaSignInRequest {
+    mfaPendingCredential: string;
+    phoneVerificationInfo: SignInWithPhoneNumberRequest;
+    tenantId?: string;
+}
+export interface FinalizeTotpMfaSignInRequest {
+    mfaPendingCredential: string;
+    totpVerificationInfo: {
+        verificationCode: string;
+    };
+    tenantId?: string;
+    mfaEnrollmentId: string;
+}
+export interface FinalizePhoneMfaSignInResponse extends FinalizeMfaResponse {
+}
+export interface FinalizeTotpMfaSignInResponse extends FinalizeMfaResponse {
+}
+export declare function finalizeSignInPhoneMfa(auth: Auth, request: FinalizePhoneMfaSignInRequest): Promise<FinalizePhoneMfaSignInResponse>;
+export declare function finalizeSignInTotpMfa(auth: Auth, request: FinalizeTotpMfaSignInRequest): Promise<FinalizeTotpMfaSignInResponse>;
+/**
+ * @internal
+ */
+export type PhoneOrOauthTokenResponse = SignInWithPhoneNumberResponse | SignInWithIdpResponse | IdTokenResponse;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/recaptcha.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/recaptcha.d.ts
new file mode 100644
index 0000000..e324d6d
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/recaptcha.d.ts
@@ -0,0 +1,34 @@
+/**
+ * @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 { RecaptchaClientType, RecaptchaVersion } from '../index';
+import { Auth } from '../../model/public_types';
+export declare function getRecaptchaParams(auth: Auth): Promise<string>;
+interface GetRecaptchaConfigRequest {
+    tenantId?: string;
+    clientType?: RecaptchaClientType;
+    version?: RecaptchaVersion;
+}
+export interface RecaptchaEnforcementProviderState {
+    provider: string;
+    enforcementState: string;
+}
+export interface GetRecaptchaConfigResponse {
+    recaptchaKey: string;
+    recaptchaEnforcementState: RecaptchaEnforcementProviderState[];
+}
+export declare function getRecaptchaConfig(auth: Auth, request: GetRecaptchaConfigRequest): Promise<GetRecaptchaConfigResponse>;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/sign_up.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/sign_up.d.ts
new file mode 100644
index 0000000..78f0838
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/sign_up.d.ts
@@ -0,0 +1,34 @@
+/**
+ * @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 { RecaptchaClientType, RecaptchaVersion } from '../index';
+import { IdTokenResponse } from '../../model/id_token';
+import { Auth } from '../../model/public_types';
+export interface SignUpRequest {
+    idToken?: string;
+    returnSecureToken?: boolean;
+    email?: string;
+    password?: string;
+    tenantId?: string;
+    captchaResponse?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
+}
+export interface SignUpResponse extends IdTokenResponse {
+    displayName?: string;
+    email?: string;
+}
+export declare function signUp(auth: Auth, request: SignUpRequest): Promise<SignUpResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/sms.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/sms.d.ts
new file mode 100644
index 0000000..617aa64
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/sms.d.ts
@@ -0,0 +1,54 @@
+/**
+ * @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 { RecaptchaClientType, RecaptchaVersion } from '../index';
+import { IdTokenResponse } from '../../model/id_token';
+import { Auth } from '../../model/public_types';
+export interface SendPhoneVerificationCodeRequest {
+    phoneNumber: string;
+    recaptchaToken?: string;
+    tenantId?: string;
+    captchaResponse?: string;
+    clientType?: RecaptchaClientType;
+    recaptchaVersion?: RecaptchaVersion;
+}
+export interface SendPhoneVerificationCodeResponse {
+    sessionInfo: string;
+}
+export declare function sendPhoneVerificationCode(auth: Auth, request: SendPhoneVerificationCodeRequest): Promise<SendPhoneVerificationCodeResponse>;
+/**
+ * @internal
+ */
+export interface SignInWithPhoneNumberRequest {
+    temporaryProof?: string;
+    phoneNumber?: string;
+    sessionInfo?: string;
+    code?: string;
+    tenantId?: string;
+}
+export interface LinkWithPhoneNumberRequest extends SignInWithPhoneNumberRequest {
+    idToken: string;
+}
+/**
+ * @internal
+ */
+export interface SignInWithPhoneNumberResponse extends IdTokenResponse {
+    temporaryProof?: string;
+    phoneNumber?: string;
+}
+export declare function signInWithPhoneNumber(auth: Auth, request: SignInWithPhoneNumberRequest): Promise<SignInWithPhoneNumberResponse>;
+export declare function linkWithPhoneNumber(auth: Auth, request: LinkWithPhoneNumberRequest): Promise<SignInWithPhoneNumberResponse>;
+export declare function verifyPhoneNumberForExisting(auth: Auth, request: SignInWithPhoneNumberRequest): Promise<SignInWithPhoneNumberResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/token.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/token.d.ts
new file mode 100644
index 0000000..1433eae
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/authentication/token.d.ts
@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Auth } from '../../model/public_types';
+export declare const enum TokenType {
+    REFRESH_TOKEN = "REFRESH_TOKEN",
+    ACCESS_TOKEN = "ACCESS_TOKEN"
+}
+export interface RequestStsTokenResponse {
+    accessToken: string;
+    expiresIn: string;
+    refreshToken: string;
+}
+export interface RevokeTokenRequest {
+    providerId: string;
+    tokenType: TokenType;
+    token: string;
+    idToken: string;
+    tenantId?: string;
+}
+export interface RevokeTokenResponse {
+}
+export declare function requestStsToken(auth: Auth, refreshToken: string): Promise<RequestStsTokenResponse>;
+export declare function revokeToken(auth: Auth, request: RevokeTokenRequest): Promise<RevokeTokenResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/errors.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/errors.d.ts
new file mode 100644
index 0000000..208e19d
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/errors.d.ts
@@ -0,0 +1,129 @@
+/**
+ * @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 { AuthErrorCode } from '../core/errors';
+/**
+ * Errors that can be returned by the backend
+ */
+export declare const enum ServerError {
+    ADMIN_ONLY_OPERATION = "ADMIN_ONLY_OPERATION",
+    BLOCKING_FUNCTION_ERROR_RESPONSE = "BLOCKING_FUNCTION_ERROR_RESPONSE",
+    CAPTCHA_CHECK_FAILED = "CAPTCHA_CHECK_FAILED",
+    CORS_UNSUPPORTED = "CORS_UNSUPPORTED",
+    CREDENTIAL_MISMATCH = "CREDENTIAL_MISMATCH",
+    CREDENTIAL_TOO_OLD_LOGIN_AGAIN = "CREDENTIAL_TOO_OLD_LOGIN_AGAIN",
+    DYNAMIC_LINK_NOT_ACTIVATED = "DYNAMIC_LINK_NOT_ACTIVATED",
+    EMAIL_CHANGE_NEEDS_VERIFICATION = "EMAIL_CHANGE_NEEDS_VERIFICATION",
+    EMAIL_EXISTS = "EMAIL_EXISTS",
+    EMAIL_NOT_FOUND = "EMAIL_NOT_FOUND",
+    EXPIRED_OOB_CODE = "EXPIRED_OOB_CODE",
+    FEDERATED_USER_ID_ALREADY_LINKED = "FEDERATED_USER_ID_ALREADY_LINKED",
+    INVALID_APP_CREDENTIAL = "INVALID_APP_CREDENTIAL",
+    INVALID_APP_ID = "INVALID_APP_ID",
+    INVALID_CERT_HASH = "INVALID_CERT_HASH",
+    INVALID_CODE = "INVALID_CODE",
+    INVALID_CONTINUE_URI = "INVALID_CONTINUE_URI",
+    INVALID_CUSTOM_TOKEN = "INVALID_CUSTOM_TOKEN",
+    INVALID_DYNAMIC_LINK_DOMAIN = "INVALID_DYNAMIC_LINK_DOMAIN",
+    INVALID_EMAIL = "INVALID_EMAIL",
+    INVALID_ID_TOKEN = "INVALID_ID_TOKEN",
+    INVALID_IDP_RESPONSE = "INVALID_IDP_RESPONSE",
+    INVALID_IDENTIFIER = "INVALID_IDENTIFIER",
+    INVALID_LOGIN_CREDENTIALS = "INVALID_LOGIN_CREDENTIALS",
+    INVALID_MESSAGE_PAYLOAD = "INVALID_MESSAGE_PAYLOAD",
+    INVALID_MFA_PENDING_CREDENTIAL = "INVALID_MFA_PENDING_CREDENTIAL",
+    INVALID_OAUTH_CLIENT_ID = "INVALID_OAUTH_CLIENT_ID",
+    INVALID_OOB_CODE = "INVALID_OOB_CODE",
+    INVALID_PASSWORD = "INVALID_PASSWORD",
+    INVALID_PENDING_TOKEN = "INVALID_PENDING_TOKEN",
+    INVALID_PHONE_NUMBER = "INVALID_PHONE_NUMBER",
+    INVALID_PROVIDER_ID = "INVALID_PROVIDER_ID",
+    INVALID_RECIPIENT_EMAIL = "INVALID_RECIPIENT_EMAIL",
+    INVALID_SENDER = "INVALID_SENDER",
+    INVALID_SESSION_INFO = "INVALID_SESSION_INFO",
+    INVALID_TEMPORARY_PROOF = "INVALID_TEMPORARY_PROOF",
+    INVALID_TENANT_ID = "INVALID_TENANT_ID",
+    MFA_ENROLLMENT_NOT_FOUND = "MFA_ENROLLMENT_NOT_FOUND",
+    MISSING_ANDROID_PACKAGE_NAME = "MISSING_ANDROID_PACKAGE_NAME",
+    MISSING_APP_CREDENTIAL = "MISSING_APP_CREDENTIAL",
+    MISSING_CODE = "MISSING_CODE",
+    MISSING_CONTINUE_URI = "MISSING_CONTINUE_URI",
+    MISSING_CUSTOM_TOKEN = "MISSING_CUSTOM_TOKEN",
+    MISSING_IOS_BUNDLE_ID = "MISSING_IOS_BUNDLE_ID",
+    MISSING_MFA_ENROLLMENT_ID = "MISSING_MFA_ENROLLMENT_ID",
+    MISSING_MFA_PENDING_CREDENTIAL = "MISSING_MFA_PENDING_CREDENTIAL",
+    MISSING_OOB_CODE = "MISSING_OOB_CODE",
+    MISSING_OR_INVALID_NONCE = "MISSING_OR_INVALID_NONCE",
+    MISSING_PASSWORD = "MISSING_PASSWORD",
+    MISSING_REQ_TYPE = "MISSING_REQ_TYPE",
+    MISSING_PHONE_NUMBER = "MISSING_PHONE_NUMBER",
+    MISSING_SESSION_INFO = "MISSING_SESSION_INFO",
+    OPERATION_NOT_ALLOWED = "OPERATION_NOT_ALLOWED",
+    PASSWORD_LOGIN_DISABLED = "PASSWORD_LOGIN_DISABLED",
+    QUOTA_EXCEEDED = "QUOTA_EXCEEDED",
+    RESET_PASSWORD_EXCEED_LIMIT = "RESET_PASSWORD_EXCEED_LIMIT",
+    REJECTED_CREDENTIAL = "REJECTED_CREDENTIAL",
+    SECOND_FACTOR_EXISTS = "SECOND_FACTOR_EXISTS",
+    SECOND_FACTOR_LIMIT_EXCEEDED = "SECOND_FACTOR_LIMIT_EXCEEDED",
+    SESSION_EXPIRED = "SESSION_EXPIRED",
+    TENANT_ID_MISMATCH = "TENANT_ID_MISMATCH",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    TOO_MANY_ATTEMPTS_TRY_LATER = "TOO_MANY_ATTEMPTS_TRY_LATER",
+    UNSUPPORTED_FIRST_FACTOR = "UNSUPPORTED_FIRST_FACTOR",
+    UNSUPPORTED_TENANT_OPERATION = "UNSUPPORTED_TENANT_OPERATION",
+    UNAUTHORIZED_DOMAIN = "UNAUTHORIZED_DOMAIN",
+    UNVERIFIED_EMAIL = "UNVERIFIED_EMAIL",
+    USER_CANCELLED = "USER_CANCELLED",
+    USER_DISABLED = "USER_DISABLED",
+    USER_NOT_FOUND = "USER_NOT_FOUND",
+    WEAK_PASSWORD = "WEAK_PASSWORD",
+    RECAPTCHA_NOT_ENABLED = "RECAPTCHA_NOT_ENABLED",
+    MISSING_RECAPTCHA_TOKEN = "MISSING_RECAPTCHA_TOKEN",
+    INVALID_RECAPTCHA_TOKEN = "INVALID_RECAPTCHA_TOKEN",
+    INVALID_RECAPTCHA_ACTION = "INVALID_RECAPTCHA_ACTION",
+    MISSING_CLIENT_TYPE = "MISSING_CLIENT_TYPE",
+    MISSING_RECAPTCHA_VERSION = "MISSING_RECAPTCHA_VERSION",
+    INVALID_RECAPTCHA_VERSION = "INVALID_RECAPTCHA_VERSION",
+    INVALID_REQ_TYPE = "INVALID_REQ_TYPE",
+    PASSWORD_DOES_NOT_MEET_REQUIREMENTS = "PASSWORD_DOES_NOT_MEET_REQUIREMENTS",
+    INVALID_HOSTING_LINK_DOMAIN = "INVALID_HOSTING_LINK_DOMAIN"
+}
+/**
+ * API Response in the event of an error
+ */
+export interface JsonError {
+    error: {
+        code: number;
+        message: string;
+        errors?: [
+            {
+                message: ServerError;
+                domain: string;
+                reason: string;
+            }
+        ];
+    };
+}
+/**
+ * Type definition for a map from server errors to developer visible errors
+ */
+export declare type ServerErrorMap<ApiError extends string> = {
+    readonly [K in ApiError]: AuthErrorCode;
+};
+/**
+ * Map from errors returned by the server to errors to developer visible errors
+ */
+export declare const SERVER_ERROR_MAP: Partial<ServerErrorMap<ServerError>>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/index.d.ts
new file mode 100644
index 0000000..1df9f79
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/index.d.ts
@@ -0,0 +1,101 @@
+/**
+ * @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 { FirebaseError } from '@firebase/util';
+import { AuthErrorCode } from '../core/errors';
+import { Delay } from '../core/util/delay';
+import { Auth } from '../model/public_types';
+import { IdTokenResponse } from '../model/id_token';
+import { ServerError, ServerErrorMap } from './errors';
+export declare const enum HttpMethod {
+    POST = "POST",
+    GET = "GET"
+}
+export declare const enum HttpHeader {
+    CONTENT_TYPE = "Content-Type",
+    X_FIREBASE_LOCALE = "X-Firebase-Locale",
+    X_CLIENT_VERSION = "X-Client-Version",
+    X_FIREBASE_GMPID = "X-Firebase-gmpid",
+    X_FIREBASE_CLIENT = "X-Firebase-Client",
+    X_FIREBASE_APP_CHECK = "X-Firebase-AppCheck"
+}
+export declare const enum Endpoint {
+    CREATE_AUTH_URI = "/v1/accounts:createAuthUri",
+    DELETE_ACCOUNT = "/v1/accounts:delete",
+    RESET_PASSWORD = "/v1/accounts:resetPassword",
+    SIGN_UP = "/v1/accounts:signUp",
+    SIGN_IN_WITH_CUSTOM_TOKEN = "/v1/accounts:signInWithCustomToken",
+    SIGN_IN_WITH_EMAIL_LINK = "/v1/accounts:signInWithEmailLink",
+    SIGN_IN_WITH_IDP = "/v1/accounts:signInWithIdp",
+    SIGN_IN_WITH_PASSWORD = "/v1/accounts:signInWithPassword",
+    SIGN_IN_WITH_PHONE_NUMBER = "/v1/accounts:signInWithPhoneNumber",
+    SEND_VERIFICATION_CODE = "/v1/accounts:sendVerificationCode",
+    SEND_OOB_CODE = "/v1/accounts:sendOobCode",
+    SET_ACCOUNT_INFO = "/v1/accounts:update",
+    GET_ACCOUNT_INFO = "/v1/accounts:lookup",
+    GET_RECAPTCHA_PARAM = "/v1/recaptchaParams",
+    START_MFA_ENROLLMENT = "/v2/accounts/mfaEnrollment:start",
+    FINALIZE_MFA_ENROLLMENT = "/v2/accounts/mfaEnrollment:finalize",
+    START_MFA_SIGN_IN = "/v2/accounts/mfaSignIn:start",
+    FINALIZE_MFA_SIGN_IN = "/v2/accounts/mfaSignIn:finalize",
+    WITHDRAW_MFA = "/v2/accounts/mfaEnrollment:withdraw",
+    GET_PROJECT_CONFIG = "/v1/projects",
+    GET_RECAPTCHA_CONFIG = "/v2/recaptchaConfig",
+    GET_PASSWORD_POLICY = "/v2/passwordPolicy",
+    TOKEN = "/v1/token",
+    REVOKE_TOKEN = "/v2/accounts:revokeToken"
+}
+export declare const enum RecaptchaClientType {
+    WEB = "CLIENT_TYPE_WEB",
+    ANDROID = "CLIENT_TYPE_ANDROID",
+    IOS = "CLIENT_TYPE_IOS"
+}
+export declare const enum RecaptchaVersion {
+    ENTERPRISE = "RECAPTCHA_ENTERPRISE"
+}
+export declare const enum RecaptchaActionName {
+    SIGN_IN_WITH_PASSWORD = "signInWithPassword",
+    GET_OOB_CODE = "getOobCode",
+    SIGN_UP_PASSWORD = "signUpPassword",
+    SEND_VERIFICATION_CODE = "sendVerificationCode",
+    MFA_SMS_ENROLLMENT = "mfaSmsEnrollment",
+    MFA_SMS_SIGNIN = "mfaSmsSignIn"
+}
+export declare const enum EnforcementState {
+    ENFORCE = "ENFORCE",
+    AUDIT = "AUDIT",
+    OFF = "OFF",
+    ENFORCEMENT_STATE_UNSPECIFIED = "ENFORCEMENT_STATE_UNSPECIFIED"
+}
+export declare const enum RecaptchaAuthProvider {
+    EMAIL_PASSWORD_PROVIDER = "EMAIL_PASSWORD_PROVIDER",
+    PHONE_PROVIDER = "PHONE_PROVIDER"
+}
+export declare const DEFAULT_API_TIMEOUT_MS: Delay;
+export declare function _addTidIfNecessary<T extends {
+    tenantId?: string;
+}>(auth: Auth, request: T): T;
+export declare function _performApiRequest<T, V>(auth: Auth, method: HttpMethod, path: Endpoint, request?: T, customErrorMap?: Partial<ServerErrorMap<ServerError>>): Promise<V>;
+export declare function _performFetchWithErrorHandling<V>(auth: Auth, customErrorMap: Partial<ServerErrorMap<ServerError>>, fetchFn: () => Promise<Response>): Promise<V>;
+export declare function _performSignInRequest<T, V extends IdTokenResponse>(auth: Auth, method: HttpMethod, path: Endpoint, request?: T, customErrorMap?: Partial<ServerErrorMap<ServerError>>): Promise<V>;
+export declare function _getFinalTarget(auth: Auth, host: string, path: string, query: string): Promise<string>;
+export declare function _parseEnforcementState(enforcementStateStr: string): EnforcementState;
+interface PotentialResponse extends IdTokenResponse {
+    email?: string;
+    phoneNumber?: string;
+}
+export declare function _makeTaggedError(auth: Auth, code: AuthErrorCode, response: PotentialResponse): FirebaseError;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/password_policy/get_password_policy.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/password_policy/get_password_policy.d.ts
new file mode 100644
index 0000000..f8a90e9
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/password_policy/get_password_policy.d.ts
@@ -0,0 +1,48 @@
+/**
+ * @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 { Auth } from '../../model/public_types';
+/**
+ * Request object for fetching the password policy.
+ */
+export interface GetPasswordPolicyRequest {
+    tenantId?: string;
+}
+/**
+ * Response object for fetching the password policy.
+ */
+export interface GetPasswordPolicyResponse {
+    customStrengthOptions: {
+        minPasswordLength?: number;
+        maxPasswordLength?: number;
+        containsLowercaseCharacter?: boolean;
+        containsUppercaseCharacter?: boolean;
+        containsNumericCharacter?: boolean;
+        containsNonAlphanumericCharacter?: boolean;
+    };
+    allowedNonAlphanumericCharacters?: string[];
+    enforcementState: string;
+    forceUpgradeOnSignin?: boolean;
+    schemaVersion: number;
+}
+/**
+ * Fetches the password policy for the currently set tenant or the project if no tenant is set.
+ *
+ * @param auth Auth object.
+ * @param request Password policy request.
+ * @returns Password policy response.
+ */
+export declare function _getPasswordPolicy(auth: Auth, request?: GetPasswordPolicyRequest): Promise<GetPasswordPolicyResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/api/project_config/get_project_config.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/api/project_config/get_project_config.d.ts
new file mode 100644
index 0000000..c7a881a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/api/project_config/get_project_config.d.ts
@@ -0,0 +1,25 @@
+/**
+ * @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 { Auth } from '../../model/public_types';
+export interface GetProjectConfigRequest {
+    androidPackageName?: string;
+    iosBundleId?: string;
+}
+export interface GetProjectConfigResponse {
+    authorizedDomains: string[];
+}
+export declare function _getProjectConfig(auth: Auth, request?: GetProjectConfigRequest): Promise<GetProjectConfigResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/action_code_url.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/action_code_url.d.ts
new file mode 100644
index 0000000..39f14b6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/action_code_url.d.ts
@@ -0,0 +1,73 @@
+/**
+ * @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.
+ */
+/**
+ * A utility class to parse email action URLs such as password reset, email verification,
+ * email link sign in, etc.
+ *
+ * @public
+ */
+export declare class ActionCodeURL {
+    /**
+     * The API key of the email action link.
+     */
+    readonly apiKey: string;
+    /**
+     * The action code of the email action link.
+     */
+    readonly code: string;
+    /**
+     * The continue URL of the email action link. Null if not provided.
+     */
+    readonly continueUrl: string | null;
+    /**
+     * The language code of the email action link. Null if not provided.
+     */
+    readonly languageCode: string | null;
+    /**
+     * The action performed by the email action link. It returns from one of the types from
+     * {@link ActionCodeInfo}
+     */
+    readonly operation: string;
+    /**
+     * The tenant ID of the email action link. Null if the email action is from the parent project.
+     */
+    readonly tenantId: string | null;
+    /**
+     * @param actionLink - The link from which to extract the URL.
+     * @returns The {@link ActionCodeURL} object, or null if the link is invalid.
+     *
+     * @internal
+     */
+    constructor(actionLink: string);
+    /**
+     * Parses the email action link string and returns an {@link ActionCodeURL} if the link is valid,
+     * otherwise returns null.
+     *
+     * @param link  - The email action link string.
+     * @returns The {@link ActionCodeURL} object, or null if the link is invalid.
+     *
+     * @public
+     */
+    static parseLink(link: string): ActionCodeURL | null;
+}
+/**
+ * Parses the email action link string and returns an {@link ActionCodeURL} if
+ * the link is valid, otherwise returns null.
+ *
+ * @public
+ */
+export declare function parseActionCodeURL(link: string): ActionCodeURL | null;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/auth_event_manager.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/auth_event_manager.d.ts
new file mode 100644
index 0000000..42edbc6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/auth_event_manager.d.ts
@@ -0,0 +1,34 @@
+/**
+ * @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 { AuthEvent, AuthEventConsumer, EventManager } from '../../model/popup_redirect';
+import { AuthInternal } from '../../model/auth';
+export declare class AuthEventManager implements EventManager {
+    private readonly auth;
+    private readonly cachedEventUids;
+    private readonly consumers;
+    protected queuedRedirectEvent: AuthEvent | null;
+    protected hasHandledPotentialRedirect: boolean;
+    private lastProcessedEventTime;
+    constructor(auth: AuthInternal);
+    registerConsumer(authEventConsumer: AuthEventConsumer): void;
+    unregisterConsumer(authEventConsumer: AuthEventConsumer): void;
+    onEvent(event: AuthEvent): boolean;
+    private sendToConsumer;
+    private isEventForConsumer;
+    private hasEventBeenHandled;
+    private saveEventToCache;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/auth_impl.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/auth_impl.d.ts
new file mode 100644
index 0000000..87aab60
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/auth_impl.d.ts
@@ -0,0 +1,133 @@
+/**
+ * @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 { _FirebaseService, FirebaseApp } from '@firebase/app';
+import { Provider } from '@firebase/component';
+import { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';
+import { Auth, AuthErrorMap, AuthSettings, EmulatorConfig, NextOrObserver, Persistence, PopupRedirectResolver, User, CompleteFn, ErrorFn, Unsubscribe, PasswordValidationStatus } from '../../model/public_types';
+import { ErrorFactory } from '@firebase/util';
+import { AuthInternal, ConfigInternal } from '../../model/auth';
+import { PopupRedirectResolverInternal } from '../../model/popup_redirect';
+import { UserInternal } from '../../model/user';
+import { AuthErrorCode, AuthErrorParams } from '../errors';
+import { PersistenceInternal } from '../persistence';
+import { RecaptchaConfig } from '../../platform_browser/recaptcha/recaptcha';
+import { PasswordPolicyInternal } from '../../model/password_policy';
+export declare const enum DefaultConfig {
+    TOKEN_API_HOST = "securetoken.googleapis.com",
+    API_HOST = "identitytoolkit.googleapis.com",
+    API_SCHEME = "https"
+}
+export declare class AuthImpl implements AuthInternal, _FirebaseService {
+    readonly app: FirebaseApp;
+    private readonly heartbeatServiceProvider;
+    private readonly appCheckServiceProvider;
+    readonly config: ConfigInternal;
+    currentUser: User | null;
+    emulatorConfig: EmulatorConfig | null;
+    private operations;
+    private persistenceManager?;
+    private redirectPersistenceManager?;
+    private authStateSubscription;
+    private idTokenSubscription;
+    private readonly beforeStateQueue;
+    private redirectUser;
+    private isProactiveRefreshEnabled;
+    private readonly EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION;
+    _canInitEmulator: boolean;
+    _isInitialized: boolean;
+    _deleted: boolean;
+    _initializationPromise: Promise<void> | null;
+    _popupRedirectResolver: PopupRedirectResolverInternal | null;
+    _errorFactory: ErrorFactory<AuthErrorCode, AuthErrorParams>;
+    _agentRecaptchaConfig: RecaptchaConfig | null;
+    _tenantRecaptchaConfigs: Record<string, RecaptchaConfig>;
+    _projectPasswordPolicy: PasswordPolicyInternal | null;
+    _tenantPasswordPolicies: Record<string, PasswordPolicyInternal>;
+    _resolvePersistenceManagerAvailable: ((value: void | PromiseLike<void>) => void) | undefined;
+    _persistenceManagerAvailable: Promise<void>;
+    readonly name: string;
+    private lastNotifiedUid;
+    languageCode: string | null;
+    tenantId: string | null;
+    settings: AuthSettings;
+    constructor(app: FirebaseApp, heartbeatServiceProvider: Provider<'heartbeat'>, appCheckServiceProvider: Provider<AppCheckInternalComponentName>, config: ConfigInternal);
+    _initializeWithPersistence(persistenceHierarchy: PersistenceInternal[], popupRedirectResolver?: PopupRedirectResolver): Promise<void>;
+    /**
+     * If the persistence is changed in another window, the user manager will let us know
+     */
+    _onStorageEvent(): Promise<void>;
+    private initializeCurrentUserFromIdToken;
+    private initializeCurrentUser;
+    private tryRedirectSignIn;
+    private reloadAndSetCurrentUserOrClear;
+    useDeviceLanguage(): void;
+    _delete(): Promise<void>;
+    updateCurrentUser(userExtern: User | null): Promise<void>;
+    _updateCurrentUser(user: User | null, skipBeforeStateCallbacks?: boolean): Promise<void>;
+    signOut(): Promise<void>;
+    setPersistence(persistence: Persistence): Promise<void>;
+    _getRecaptchaConfig(): RecaptchaConfig | null;
+    validatePassword(password: string): Promise<PasswordValidationStatus>;
+    _getPasswordPolicyInternal(): PasswordPolicyInternal | null;
+    _updatePasswordPolicy(): Promise<void>;
+    _getPersistenceType(): string;
+    _getPersistence(): PersistenceInternal;
+    _updateErrorMap(errorMap: AuthErrorMap): void;
+    onAuthStateChanged(nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+    beforeAuthStateChanged(callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
+    onIdTokenChanged(nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+    authStateReady(): Promise<void>;
+    /**
+     * Revokes the given access token. Currently only supports Apple OAuth access tokens.
+     */
+    revokeAccessToken(token: string): Promise<void>;
+    toJSON(): object;
+    _setRedirectUser(user: UserInternal | null, popupRedirectResolver?: PopupRedirectResolver): Promise<void>;
+    private getOrInitRedirectPersistenceManager;
+    _redirectUserForId(id: string): Promise<UserInternal | null>;
+    _persistUserIfCurrent(user: UserInternal): Promise<void>;
+    /** Notifies listeners only if the user is current */
+    _notifyListenersIfCurrent(user: UserInternal): void;
+    _key(): string;
+    _startProactiveRefresh(): void;
+    _stopProactiveRefresh(): void;
+    /** Returns the current user cast as the internal type */
+    get _currentUser(): UserInternal;
+    private notifyAuthListeners;
+    private registerStateListener;
+    /**
+     * Unprotected (from race conditions) method to set the current user. This
+     * should only be called from within a queued callback. This is necessary
+     * because the queue shouldn't rely on another queued callback.
+     */
+    private directlySetCurrentUser;
+    private queue;
+    private get assertedPersistence();
+    private frameworks;
+    private clientVersion;
+    _logFramework(framework: string): void;
+    _getFrameworks(): readonly string[];
+    _getAdditionalHeaders(): Promise<Record<string, string>>;
+    _getAppCheckToken(): Promise<string | undefined>;
+}
+/**
+ * Method to be used to cast down to our private implementation of Auth.
+ * It will also handle unwrapping from the compat type if necessary
+ *
+ * @param auth Auth object passed in from developer
+ */
+export declare function _castAuth(auth: Auth): AuthInternal;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/emulator.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/emulator.d.ts
new file mode 100644
index 0000000..56dd81c
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/emulator.d.ts
@@ -0,0 +1,42 @@
+/**
+ * @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 { Auth } from '../../model/public_types';
+/**
+ * Changes the {@link Auth} instance to communicate with the Firebase Auth Emulator, instead of production
+ * Firebase Auth services.
+ *
+ * @remarks
+ * This must be called synchronously immediately following the first call to
+ * {@link initializeAuth}.  Do not use with production credentials as emulator
+ * traffic is not encrypted.
+ *
+ *
+ * @example
+ * ```javascript
+ * connectAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param url - The URL at which the emulator is running (eg, 'http://localhost:9099').
+ * @param options - Optional. `options.disableWarnings` defaults to `false`. Set it to
+ * `true` to disable the warning banner attached to the DOM.
+ *
+ * @public
+ */
+export declare function connectAuthEmulator(auth: Auth, url: string, options?: {
+    disableWarnings: boolean;
+}): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/firebase_internal.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/firebase_internal.d.ts
new file mode 100644
index 0000000..9a68c98
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/firebase_internal.d.ts
@@ -0,0 +1,35 @@
+/**
+ * @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 { FirebaseAuthInternal } from '@firebase/auth-interop-types';
+import { AuthInternal } from '../../model/auth';
+interface TokenListener {
+    (tok: string | null): unknown;
+}
+export declare class AuthInterop implements FirebaseAuthInternal {
+    private readonly auth;
+    private readonly internalListeners;
+    constructor(auth: AuthInternal);
+    getUid(): string | null;
+    getToken(forceRefresh?: boolean): Promise<{
+        accessToken: string;
+    } | null>;
+    addAuthTokenListener(listener: TokenListener): void;
+    removeAuthTokenListener(listener: TokenListener): void;
+    private assertAuthConfigured;
+    private updateProactiveRefresh;
+}
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/initialize.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/initialize.d.ts
new file mode 100644
index 0000000..3dd0e1e
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/initialize.d.ts
@@ -0,0 +1,46 @@
+/**
+ * @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 { Auth, Dependencies } from '../../model/public_types';
+import { AuthImpl } from './auth_impl';
+/**
+ * Initializes an {@link Auth} instance with fine-grained control over
+ * {@link Dependencies}.
+ *
+ * @remarks
+ *
+ * This function allows more control over the {@link Auth} instance than
+ * {@link getAuth}. `getAuth` uses platform-specific defaults to supply
+ * the {@link Dependencies}. In general, `getAuth` is the easiest way to
+ * initialize Auth and works for most use cases. Use `initializeAuth` if you
+ * need control over which persistence layer is used, or to minimize bundle
+ * size if you're not using either `signInWithPopup` or `signInWithRedirect`.
+ *
+ * For example, if your app only uses anonymous accounts and you only want
+ * accounts saved for the current session, initialize `Auth` with:
+ *
+ * ```js
+ * const auth = initializeAuth(app, {
+ *   persistence: browserSessionPersistence,
+ *   popupRedirectResolver: undefined,
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare function initializeAuth(app: FirebaseApp, deps?: Dependencies): Auth;
+export declare function _initializeAuthInstance(auth: AuthImpl, deps?: Dependencies): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/middleware.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/middleware.d.ts
new file mode 100644
index 0000000..74c4183
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/middleware.d.ts
@@ -0,0 +1,25 @@
+/**
+ * @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 { AuthInternal } from '../../model/auth';
+import { Unsubscribe, User } from '../../model/public_types';
+export declare class AuthMiddlewareQueue {
+    private readonly auth;
+    private readonly queue;
+    constructor(auth: AuthInternal);
+    pushCallback(callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
+    runMiddleware(nextUser: User | null): Promise<void>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/password_policy_impl.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/password_policy_impl.d.ts
new file mode 100644
index 0000000..45a8127
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/password_policy_impl.d.ts
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { GetPasswordPolicyResponse } from '../../api/password_policy/get_password_policy';
+import { PasswordPolicyCustomStrengthOptions, PasswordPolicyInternal } from '../../model/password_policy';
+import { PasswordValidationStatus } from '../../model/public_types';
+/**
+ * Stores password policy requirements and provides password validation against the policy.
+ *
+ * @internal
+ */
+export declare class PasswordPolicyImpl implements PasswordPolicyInternal {
+    readonly customStrengthOptions: PasswordPolicyCustomStrengthOptions;
+    readonly allowedNonAlphanumericCharacters: string;
+    readonly enforcementState: string;
+    readonly forceUpgradeOnSignin: boolean;
+    readonly schemaVersion: number;
+    constructor(response: GetPasswordPolicyResponse);
+    validatePassword(password: string): PasswordValidationStatus;
+    /**
+     * Validates that the password meets the length options for the policy.
+     *
+     * @param password Password to validate.
+     * @param status Validation status.
+     */
+    private validatePasswordLengthOptions;
+    /**
+     * Validates that the password meets the character options for the policy.
+     *
+     * @param password Password to validate.
+     * @param status Validation status.
+     */
+    private validatePasswordCharacterOptions;
+    /**
+     * Updates the running validation status with the statuses for the character options.
+     * Expected to be called each time a character is processed to update each option status
+     * based on the current character.
+     *
+     * @param status Validation status.
+     * @param containsLowercaseCharacter Whether the character is a lowercase letter.
+     * @param containsUppercaseCharacter Whether the character is an uppercase letter.
+     * @param containsNumericCharacter Whether the character is a numeric character.
+     * @param containsNonAlphanumericCharacter Whether the character is a non-alphanumeric character.
+     */
+    private updatePasswordCharacterOptionsStatuses;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/register.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/register.d.ts
new file mode 100644
index 0000000..260c739
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/auth/register.d.ts
@@ -0,0 +1,23 @@
+/**
+ * @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 { ClientPlatform } from '../util/version';
+export declare const enum _ComponentName {
+    AUTH = "auth",
+    AUTH_INTERNAL = "auth-internal"
+}
+/** @internal */
+export declare function registerAuth(clientPlatform: ClientPlatform): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/auth_credential.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/auth_credential.d.ts
new file mode 100644
index 0000000..1287582
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/auth_credential.d.ts
@@ -0,0 +1,75 @@
+/**
+ * @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 { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';
+import { AuthInternal } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+/**
+ * Interface that represents the credentials returned by an {@link AuthProvider}.
+ *
+ * @remarks
+ * Implementations specify the details about each auth provider's credential requirements.
+ *
+ * @public
+ */
+export declare class AuthCredential {
+    /**
+     * The authentication provider ID for the credential.
+     *
+     * @remarks
+     * For example, 'facebook.com', or 'google.com'.
+     */
+    readonly providerId: string;
+    /**
+     * The authentication sign in method for the credential.
+     *
+     * @remarks
+     * For example, {@link SignInMethod}.EMAIL_PASSWORD, or
+     * {@link SignInMethod}.EMAIL_LINK. This corresponds to the sign-in method
+     * identifier as returned in {@link fetchSignInMethodsForEmail}.
+     */
+    readonly signInMethod: string;
+    /** @internal */
+    protected constructor(
+    /**
+     * The authentication provider ID for the credential.
+     *
+     * @remarks
+     * For example, 'facebook.com', or 'google.com'.
+     */
+    providerId: string, 
+    /**
+     * The authentication sign in method for the credential.
+     *
+     * @remarks
+     * For example, {@link SignInMethod}.EMAIL_PASSWORD, or
+     * {@link SignInMethod}.EMAIL_LINK. This corresponds to the sign-in method
+     * identifier as returned in {@link fetchSignInMethodsForEmail}.
+     */
+    signInMethod: string);
+    /**
+     * Returns a JSON-serializable representation of this object.
+     *
+     * @returns a JSON-serializable representation of this object.
+     */
+    toJSON(): object;
+    /** @internal */
+    _getIdTokenResponse(_auth: AuthInternal): Promise<PhoneOrOauthTokenResponse>;
+    /** @internal */
+    _linkToIdToken(_auth: AuthInternal, _idToken: string): Promise<IdTokenResponse>;
+    /** @internal */
+    _getReauthenticationResolver(_auth: AuthInternal): Promise<IdTokenResponse>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/email.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/email.d.ts
new file mode 100644
index 0000000..0f44811
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/email.d.ts
@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+import { AuthCredential } from './auth_credential';
+/**
+ * Interface that represents the credentials returned by {@link EmailAuthProvider} for
+ * {@link ProviderId}.PASSWORD
+ *
+ * @remarks
+ * Covers both {@link SignInMethod}.EMAIL_PASSWORD and
+ * {@link SignInMethod}.EMAIL_LINK.
+ *
+ * @public
+ */
+export declare class EmailAuthCredential extends AuthCredential {
+    /** @internal */
+    readonly _email: string;
+    /** @internal */
+    readonly _password: string;
+    /** @internal */
+    readonly _tenantId: string | null;
+    /** @internal */
+    private constructor();
+    /** @internal */
+    static _fromEmailAndPassword(email: string, password: string): EmailAuthCredential;
+    /** @internal */
+    static _fromEmailAndCode(email: string, oobCode: string, tenantId?: string | null): EmailAuthCredential;
+    /** {@inheritdoc AuthCredential.toJSON} */
+    toJSON(): object;
+    /**
+     * Static method to deserialize a JSON representation of an object into an {@link  AuthCredential}.
+     *
+     * @param json - Either `object` or the stringified representation of the object. When string is
+     * provided, `JSON.parse` would be called first.
+     *
+     * @returns If the JSON input does not represent an {@link AuthCredential}, null is returned.
+     */
+    static fromJSON(json: object | string): EmailAuthCredential | null;
+    /** @internal */
+    _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse>;
+    /** @internal */
+    _linkToIdToken(auth: AuthInternal, idToken: string): Promise<IdTokenResponse>;
+    /** @internal */
+    _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/index.d.ts
new file mode 100644
index 0000000..475dee6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/index.d.ts
@@ -0,0 +1,23 @@
+/**
+ * @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.
+ */
+/**
+ * This file is required due to the circular dependency from the parent class to its children
+ */
+export { AuthCredential } from './auth_credential';
+export { EmailAuthCredential } from './email';
+export { OAuthCredential } from './oauth';
+export { PhoneAuthCredential as PhoneAuthCredential } from './phone';
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/oauth.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/oauth.d.ts
new file mode 100644
index 0000000..96a1928
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/oauth.d.ts
@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+import { AuthCredential } from './auth_credential';
+export interface OAuthCredentialParams {
+    idToken?: string | null;
+    accessToken?: string | null;
+    oauthToken?: string;
+    secret?: string;
+    oauthTokenSecret?: string;
+    nonce?: string;
+    pendingToken?: string;
+    providerId: string;
+    signInMethod: string;
+}
+/**
+ * Represents the OAuth credentials returned by an {@link OAuthProvider}.
+ *
+ * @remarks
+ * Implementations specify the details about each auth provider's credential requirements.
+ *
+ * @public
+ */
+export declare class OAuthCredential extends AuthCredential {
+    /**
+     * The OAuth ID token associated with the credential if it belongs to an OIDC provider,
+     * such as `google.com`.
+     * @readonly
+     */
+    idToken?: string;
+    /**
+     * The OAuth access token associated with the credential if it belongs to an
+     * {@link OAuthProvider}, such as `facebook.com`, `twitter.com`, etc.
+     * @readonly
+     */
+    accessToken?: string;
+    /**
+     * The OAuth access token secret associated with the credential if it belongs to an OAuth 1.0
+     * provider, such as `twitter.com`.
+     * @readonly
+     */
+    secret?: string;
+    private nonce?;
+    private pendingToken;
+    /** @internal */
+    static _fromParams(params: OAuthCredentialParams): OAuthCredential;
+    /** {@inheritdoc AuthCredential.toJSON}  */
+    toJSON(): object;
+    /**
+     * Static method to deserialize a JSON representation of an object into an
+     * {@link  AuthCredential}.
+     *
+     * @param json - Input can be either Object or the stringified representation of the object.
+     * When string is provided, JSON.parse would be called first.
+     *
+     * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.
+     */
+    static fromJSON(json: string | object): OAuthCredential | null;
+    /** @internal */
+    _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse>;
+    /** @internal */
+    _linkToIdToken(auth: AuthInternal, idToken: string): Promise<IdTokenResponse>;
+    /** @internal */
+    _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse>;
+    private buildRequest;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/phone.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/phone.d.ts
new file mode 100644
index 0000000..1924744
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/phone.d.ts
@@ -0,0 +1,52 @@
+/**
+ * @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 { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';
+import { SignInWithPhoneNumberRequest } from '../../api/authentication/sms';
+import { AuthInternal } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+import { AuthCredential } from './auth_credential';
+export interface PhoneAuthCredentialParameters {
+    verificationId?: string;
+    verificationCode?: string;
+    phoneNumber?: string;
+    temporaryProof?: string;
+}
+/**
+ * Represents the credentials returned by {@link PhoneAuthProvider}.
+ *
+ * @public
+ */
+export declare class PhoneAuthCredential extends AuthCredential {
+    private readonly params;
+    private constructor();
+    /** @internal */
+    static _fromVerification(verificationId: string, verificationCode: string): PhoneAuthCredential;
+    /** @internal */
+    static _fromTokenResponse(phoneNumber: string, temporaryProof: string): PhoneAuthCredential;
+    /** @internal */
+    _getIdTokenResponse(auth: AuthInternal): Promise<PhoneOrOauthTokenResponse>;
+    /** @internal */
+    _linkToIdToken(auth: AuthInternal, idToken: string): Promise<IdTokenResponse>;
+    /** @internal */
+    _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse>;
+    /** @internal */
+    _makeVerificationRequest(): SignInWithPhoneNumberRequest;
+    /** {@inheritdoc AuthCredential.toJSON} */
+    toJSON(): object;
+    /** Generates a phone credential based on a plain object or a JSON string. */
+    static fromJSON(json: object | string): PhoneAuthCredential | null;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/saml.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/saml.d.ts
new file mode 100644
index 0000000..54fea84
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/credentials/saml.d.ts
@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+import { AuthCredential } from './auth_credential';
+/**
+ * @public
+ */
+export declare class SAMLAuthCredential extends AuthCredential {
+    private readonly pendingToken;
+    /** @internal */
+    private constructor();
+    /** @internal */
+    _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse>;
+    /** @internal */
+    _linkToIdToken(auth: AuthInternal, idToken: string): Promise<IdTokenResponse>;
+    /** @internal */
+    _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse>;
+    /** {@inheritdoc AuthCredential.toJSON}  */
+    toJSON(): object;
+    /**
+     * Static method to deserialize a JSON representation of an object into an
+     * {@link  AuthCredential}.
+     *
+     * @param json - Input can be either Object or the stringified representation of the object.
+     * When string is provided, JSON.parse would be called first.
+     *
+     * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.
+     */
+    static fromJSON(json: string | object): SAMLAuthCredential | null;
+    /**
+     * Helper static method to avoid exposing the constructor to end users.
+     *
+     * @internal
+     */
+    static _create(providerId: string, pendingToken: string): SAMLAuthCredential;
+    private buildRequest;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/errors.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/errors.d.ts
new file mode 100644
index 0000000..3d81b3a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/errors.d.ts
@@ -0,0 +1,328 @@
+/**
+ * @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 { AuthErrorMap, User } from '../model/public_types';
+import { ErrorFactory, ErrorMap } from '@firebase/util';
+import { IdTokenMfaResponse } from '../api/authentication/mfa';
+import { AppName } from '../model/auth';
+import { AuthCredential } from './credentials';
+/**
+ * Enumeration of Firebase Auth error codes.
+ *
+ * @internal
+ */
+export declare const enum AuthErrorCode {
+    ADMIN_ONLY_OPERATION = "admin-restricted-operation",
+    ARGUMENT_ERROR = "argument-error",
+    APP_NOT_AUTHORIZED = "app-not-authorized",
+    APP_NOT_INSTALLED = "app-not-installed",
+    CAPTCHA_CHECK_FAILED = "captcha-check-failed",
+    CODE_EXPIRED = "code-expired",
+    CORDOVA_NOT_READY = "cordova-not-ready",
+    CORS_UNSUPPORTED = "cors-unsupported",
+    CREDENTIAL_ALREADY_IN_USE = "credential-already-in-use",
+    CREDENTIAL_MISMATCH = "custom-token-mismatch",
+    CREDENTIAL_TOO_OLD_LOGIN_AGAIN = "requires-recent-login",
+    DEPENDENT_SDK_INIT_BEFORE_AUTH = "dependent-sdk-initialized-before-auth",
+    DYNAMIC_LINK_NOT_ACTIVATED = "dynamic-link-not-activated",
+    EMAIL_CHANGE_NEEDS_VERIFICATION = "email-change-needs-verification",
+    EMAIL_EXISTS = "email-already-in-use",
+    EMULATOR_CONFIG_FAILED = "emulator-config-failed",
+    EXPIRED_OOB_CODE = "expired-action-code",
+    EXPIRED_POPUP_REQUEST = "cancelled-popup-request",
+    INTERNAL_ERROR = "internal-error",
+    INVALID_API_KEY = "invalid-api-key",
+    INVALID_APP_CREDENTIAL = "invalid-app-credential",
+    INVALID_APP_ID = "invalid-app-id",
+    INVALID_AUTH = "invalid-user-token",
+    INVALID_AUTH_EVENT = "invalid-auth-event",
+    INVALID_CERT_HASH = "invalid-cert-hash",
+    INVALID_CODE = "invalid-verification-code",
+    INVALID_CONTINUE_URI = "invalid-continue-uri",
+    INVALID_CORDOVA_CONFIGURATION = "invalid-cordova-configuration",
+    INVALID_CUSTOM_TOKEN = "invalid-custom-token",
+    INVALID_DYNAMIC_LINK_DOMAIN = "invalid-dynamic-link-domain",
+    INVALID_EMAIL = "invalid-email",
+    INVALID_EMULATOR_SCHEME = "invalid-emulator-scheme",
+    INVALID_CREDENTIAL = "invalid-credential",
+    INVALID_MESSAGE_PAYLOAD = "invalid-message-payload",
+    INVALID_MFA_SESSION = "invalid-multi-factor-session",
+    INVALID_OAUTH_CLIENT_ID = "invalid-oauth-client-id",
+    INVALID_OAUTH_PROVIDER = "invalid-oauth-provider",
+    INVALID_OOB_CODE = "invalid-action-code",
+    INVALID_ORIGIN = "unauthorized-domain",
+    INVALID_PASSWORD = "wrong-password",
+    INVALID_PERSISTENCE = "invalid-persistence-type",
+    INVALID_PHONE_NUMBER = "invalid-phone-number",
+    INVALID_PROVIDER_ID = "invalid-provider-id",
+    INVALID_RECIPIENT_EMAIL = "invalid-recipient-email",
+    INVALID_SENDER = "invalid-sender",
+    INVALID_SESSION_INFO = "invalid-verification-id",
+    INVALID_TENANT_ID = "invalid-tenant-id",
+    LOGIN_BLOCKED = "login-blocked",
+    MFA_INFO_NOT_FOUND = "multi-factor-info-not-found",
+    MFA_REQUIRED = "multi-factor-auth-required",
+    MISSING_ANDROID_PACKAGE_NAME = "missing-android-pkg-name",
+    MISSING_APP_CREDENTIAL = "missing-app-credential",
+    MISSING_AUTH_DOMAIN = "auth-domain-config-required",
+    MISSING_CODE = "missing-verification-code",
+    MISSING_CONTINUE_URI = "missing-continue-uri",
+    MISSING_IFRAME_START = "missing-iframe-start",
+    MISSING_IOS_BUNDLE_ID = "missing-ios-bundle-id",
+    MISSING_OR_INVALID_NONCE = "missing-or-invalid-nonce",
+    MISSING_MFA_INFO = "missing-multi-factor-info",
+    MISSING_MFA_SESSION = "missing-multi-factor-session",
+    MISSING_PHONE_NUMBER = "missing-phone-number",
+    MISSING_PASSWORD = "missing-password",
+    MISSING_SESSION_INFO = "missing-verification-id",
+    MODULE_DESTROYED = "app-deleted",
+    NEED_CONFIRMATION = "account-exists-with-different-credential",
+    NETWORK_REQUEST_FAILED = "network-request-failed",
+    NULL_USER = "null-user",
+    NO_AUTH_EVENT = "no-auth-event",
+    NO_SUCH_PROVIDER = "no-such-provider",
+    OPERATION_NOT_ALLOWED = "operation-not-allowed",
+    OPERATION_NOT_SUPPORTED = "operation-not-supported-in-this-environment",
+    POPUP_BLOCKED = "popup-blocked",
+    POPUP_CLOSED_BY_USER = "popup-closed-by-user",
+    PROVIDER_ALREADY_LINKED = "provider-already-linked",
+    QUOTA_EXCEEDED = "quota-exceeded",
+    REDIRECT_CANCELLED_BY_USER = "redirect-cancelled-by-user",
+    REDIRECT_OPERATION_PENDING = "redirect-operation-pending",
+    REJECTED_CREDENTIAL = "rejected-credential",
+    SECOND_FACTOR_ALREADY_ENROLLED = "second-factor-already-in-use",
+    SECOND_FACTOR_LIMIT_EXCEEDED = "maximum-second-factor-count-exceeded",
+    TENANT_ID_MISMATCH = "tenant-id-mismatch",
+    TIMEOUT = "timeout",
+    TOKEN_EXPIRED = "user-token-expired",
+    TOO_MANY_ATTEMPTS_TRY_LATER = "too-many-requests",
+    UNAUTHORIZED_DOMAIN = "unauthorized-continue-uri",
+    UNSUPPORTED_FIRST_FACTOR = "unsupported-first-factor",
+    UNSUPPORTED_PERSISTENCE = "unsupported-persistence-type",
+    UNSUPPORTED_TENANT_OPERATION = "unsupported-tenant-operation",
+    UNVERIFIED_EMAIL = "unverified-email",
+    USER_CANCELLED = "user-cancelled",
+    USER_DELETED = "user-not-found",
+    USER_DISABLED = "user-disabled",
+    USER_MISMATCH = "user-mismatch",
+    USER_SIGNED_OUT = "user-signed-out",
+    WEAK_PASSWORD = "weak-password",
+    WEB_STORAGE_UNSUPPORTED = "web-storage-unsupported",
+    ALREADY_INITIALIZED = "already-initialized",
+    RECAPTCHA_NOT_ENABLED = "recaptcha-not-enabled",
+    MISSING_RECAPTCHA_TOKEN = "missing-recaptcha-token",
+    INVALID_RECAPTCHA_TOKEN = "invalid-recaptcha-token",
+    INVALID_RECAPTCHA_ACTION = "invalid-recaptcha-action",
+    MISSING_CLIENT_TYPE = "missing-client-type",
+    MISSING_RECAPTCHA_VERSION = "missing-recaptcha-version",
+    INVALID_RECAPTCHA_VERSION = "invalid-recaptcha-version",
+    INVALID_REQ_TYPE = "invalid-req-type",
+    UNSUPPORTED_PASSWORD_POLICY_SCHEMA_VERSION = "unsupported-password-policy-schema-version",
+    PASSWORD_DOES_NOT_MEET_REQUIREMENTS = "password-does-not-meet-requirements",
+    INVALID_HOSTING_LINK_DOMAIN = "invalid-hosting-link-domain"
+}
+export interface ErrorMapRetriever extends AuthErrorMap {
+    (): ErrorMap<AuthErrorCode>;
+}
+/**
+ * A verbose error map with detailed descriptions for most error codes.
+ *
+ * See discussion at {@link AuthErrorMap}
+ *
+ * @public
+ */
+export declare const debugErrorMap: AuthErrorMap;
+/**
+ * A minimal error map with all verbose error messages stripped.
+ *
+ * See discussion at {@link AuthErrorMap}
+ *
+ * @public
+ */
+export declare const prodErrorMap: AuthErrorMap;
+export interface NamedErrorParams {
+    appName: AppName;
+    credential?: AuthCredential;
+    email?: string;
+    phoneNumber?: string;
+    tenantId?: string;
+    user?: User;
+    _serverResponse?: object;
+}
+/**
+ * @internal
+ */
+type GenericAuthErrorParams = {
+    [key in Exclude<AuthErrorCode, AuthErrorCode.ARGUMENT_ERROR | AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH | AuthErrorCode.INTERNAL_ERROR | AuthErrorCode.MFA_REQUIRED | AuthErrorCode.NO_AUTH_EVENT | AuthErrorCode.OPERATION_NOT_SUPPORTED>]: {
+        appName?: AppName;
+        email?: string;
+        phoneNumber?: string;
+        message?: string;
+    };
+};
+/**
+ * @internal
+ */
+export interface AuthErrorParams extends GenericAuthErrorParams {
+    [AuthErrorCode.ARGUMENT_ERROR]: {
+        appName?: AppName;
+    };
+    [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]: {
+        appName?: AppName;
+    };
+    [AuthErrorCode.INTERNAL_ERROR]: {
+        appName?: AppName;
+    };
+    [AuthErrorCode.LOGIN_BLOCKED]: {
+        appName?: AppName;
+        originalMessage?: string;
+    };
+    [AuthErrorCode.OPERATION_NOT_SUPPORTED]: {
+        appName?: AppName;
+    };
+    [AuthErrorCode.NO_AUTH_EVENT]: {
+        appName?: AppName;
+    };
+    [AuthErrorCode.MFA_REQUIRED]: {
+        appName: AppName;
+        _serverResponse: IdTokenMfaResponse;
+    };
+    [AuthErrorCode.INVALID_CORDOVA_CONFIGURATION]: {
+        appName: AppName;
+        missingPlugin?: string;
+    };
+}
+export declare const _DEFAULT_AUTH_ERROR_FACTORY: ErrorFactory<AuthErrorCode, AuthErrorParams>;
+/**
+ * A map of potential `Auth` error codes, for easier comparison with errors
+ * thrown by the SDK.
+ *
+ * @remarks
+ * Note that you can't tree-shake individual keys
+ * in the map, so by using the map you might substantially increase your
+ * bundle size.
+ *
+ * @public
+ */
+export declare const AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY: {
+    readonly ADMIN_ONLY_OPERATION: "auth/admin-restricted-operation";
+    readonly ARGUMENT_ERROR: "auth/argument-error";
+    readonly APP_NOT_AUTHORIZED: "auth/app-not-authorized";
+    readonly APP_NOT_INSTALLED: "auth/app-not-installed";
+    readonly CAPTCHA_CHECK_FAILED: "auth/captcha-check-failed";
+    readonly CODE_EXPIRED: "auth/code-expired";
+    readonly CORDOVA_NOT_READY: "auth/cordova-not-ready";
+    readonly CORS_UNSUPPORTED: "auth/cors-unsupported";
+    readonly CREDENTIAL_ALREADY_IN_USE: "auth/credential-already-in-use";
+    readonly CREDENTIAL_MISMATCH: "auth/custom-token-mismatch";
+    readonly CREDENTIAL_TOO_OLD_LOGIN_AGAIN: "auth/requires-recent-login";
+    readonly DEPENDENT_SDK_INIT_BEFORE_AUTH: "auth/dependent-sdk-initialized-before-auth";
+    readonly DYNAMIC_LINK_NOT_ACTIVATED: "auth/dynamic-link-not-activated";
+    readonly EMAIL_CHANGE_NEEDS_VERIFICATION: "auth/email-change-needs-verification";
+    readonly EMAIL_EXISTS: "auth/email-already-in-use";
+    readonly EMULATOR_CONFIG_FAILED: "auth/emulator-config-failed";
+    readonly EXPIRED_OOB_CODE: "auth/expired-action-code";
+    readonly EXPIRED_POPUP_REQUEST: "auth/cancelled-popup-request";
+    readonly INTERNAL_ERROR: "auth/internal-error";
+    readonly INVALID_API_KEY: "auth/invalid-api-key";
+    readonly INVALID_APP_CREDENTIAL: "auth/invalid-app-credential";
+    readonly INVALID_APP_ID: "auth/invalid-app-id";
+    readonly INVALID_AUTH: "auth/invalid-user-token";
+    readonly INVALID_AUTH_EVENT: "auth/invalid-auth-event";
+    readonly INVALID_CERT_HASH: "auth/invalid-cert-hash";
+    readonly INVALID_CODE: "auth/invalid-verification-code";
+    readonly INVALID_CONTINUE_URI: "auth/invalid-continue-uri";
+    readonly INVALID_CORDOVA_CONFIGURATION: "auth/invalid-cordova-configuration";
+    readonly INVALID_CUSTOM_TOKEN: "auth/invalid-custom-token";
+    readonly INVALID_DYNAMIC_LINK_DOMAIN: "auth/invalid-dynamic-link-domain";
+    readonly INVALID_EMAIL: "auth/invalid-email";
+    readonly INVALID_EMULATOR_SCHEME: "auth/invalid-emulator-scheme";
+    readonly INVALID_IDP_RESPONSE: "auth/invalid-credential";
+    readonly INVALID_LOGIN_CREDENTIALS: "auth/invalid-credential";
+    readonly INVALID_MESSAGE_PAYLOAD: "auth/invalid-message-payload";
+    readonly INVALID_MFA_SESSION: "auth/invalid-multi-factor-session";
+    readonly INVALID_OAUTH_CLIENT_ID: "auth/invalid-oauth-client-id";
+    readonly INVALID_OAUTH_PROVIDER: "auth/invalid-oauth-provider";
+    readonly INVALID_OOB_CODE: "auth/invalid-action-code";
+    readonly INVALID_ORIGIN: "auth/unauthorized-domain";
+    readonly INVALID_PASSWORD: "auth/wrong-password";
+    readonly INVALID_PERSISTENCE: "auth/invalid-persistence-type";
+    readonly INVALID_PHONE_NUMBER: "auth/invalid-phone-number";
+    readonly INVALID_PROVIDER_ID: "auth/invalid-provider-id";
+    readonly INVALID_RECIPIENT_EMAIL: "auth/invalid-recipient-email";
+    readonly INVALID_SENDER: "auth/invalid-sender";
+    readonly INVALID_SESSION_INFO: "auth/invalid-verification-id";
+    readonly INVALID_TENANT_ID: "auth/invalid-tenant-id";
+    readonly MFA_INFO_NOT_FOUND: "auth/multi-factor-info-not-found";
+    readonly MFA_REQUIRED: "auth/multi-factor-auth-required";
+    readonly MISSING_ANDROID_PACKAGE_NAME: "auth/missing-android-pkg-name";
+    readonly MISSING_APP_CREDENTIAL: "auth/missing-app-credential";
+    readonly MISSING_AUTH_DOMAIN: "auth/auth-domain-config-required";
+    readonly MISSING_CODE: "auth/missing-verification-code";
+    readonly MISSING_CONTINUE_URI: "auth/missing-continue-uri";
+    readonly MISSING_IFRAME_START: "auth/missing-iframe-start";
+    readonly MISSING_IOS_BUNDLE_ID: "auth/missing-ios-bundle-id";
+    readonly MISSING_OR_INVALID_NONCE: "auth/missing-or-invalid-nonce";
+    readonly MISSING_MFA_INFO: "auth/missing-multi-factor-info";
+    readonly MISSING_MFA_SESSION: "auth/missing-multi-factor-session";
+    readonly MISSING_PHONE_NUMBER: "auth/missing-phone-number";
+    readonly MISSING_PASSWORD: "auth/missing-password";
+    readonly MISSING_SESSION_INFO: "auth/missing-verification-id";
+    readonly MODULE_DESTROYED: "auth/app-deleted";
+    readonly NEED_CONFIRMATION: "auth/account-exists-with-different-credential";
+    readonly NETWORK_REQUEST_FAILED: "auth/network-request-failed";
+    readonly NULL_USER: "auth/null-user";
+    readonly NO_AUTH_EVENT: "auth/no-auth-event";
+    readonly NO_SUCH_PROVIDER: "auth/no-such-provider";
+    readonly OPERATION_NOT_ALLOWED: "auth/operation-not-allowed";
+    readonly OPERATION_NOT_SUPPORTED: "auth/operation-not-supported-in-this-environment";
+    readonly POPUP_BLOCKED: "auth/popup-blocked";
+    readonly POPUP_CLOSED_BY_USER: "auth/popup-closed-by-user";
+    readonly PROVIDER_ALREADY_LINKED: "auth/provider-already-linked";
+    readonly QUOTA_EXCEEDED: "auth/quota-exceeded";
+    readonly REDIRECT_CANCELLED_BY_USER: "auth/redirect-cancelled-by-user";
+    readonly REDIRECT_OPERATION_PENDING: "auth/redirect-operation-pending";
+    readonly REJECTED_CREDENTIAL: "auth/rejected-credential";
+    readonly SECOND_FACTOR_ALREADY_ENROLLED: "auth/second-factor-already-in-use";
+    readonly SECOND_FACTOR_LIMIT_EXCEEDED: "auth/maximum-second-factor-count-exceeded";
+    readonly TENANT_ID_MISMATCH: "auth/tenant-id-mismatch";
+    readonly TIMEOUT: "auth/timeout";
+    readonly TOKEN_EXPIRED: "auth/user-token-expired";
+    readonly TOO_MANY_ATTEMPTS_TRY_LATER: "auth/too-many-requests";
+    readonly UNAUTHORIZED_DOMAIN: "auth/unauthorized-continue-uri";
+    readonly UNSUPPORTED_FIRST_FACTOR: "auth/unsupported-first-factor";
+    readonly UNSUPPORTED_PERSISTENCE: "auth/unsupported-persistence-type";
+    readonly UNSUPPORTED_TENANT_OPERATION: "auth/unsupported-tenant-operation";
+    readonly UNVERIFIED_EMAIL: "auth/unverified-email";
+    readonly USER_CANCELLED: "auth/user-cancelled";
+    readonly USER_DELETED: "auth/user-not-found";
+    readonly USER_DISABLED: "auth/user-disabled";
+    readonly USER_MISMATCH: "auth/user-mismatch";
+    readonly USER_SIGNED_OUT: "auth/user-signed-out";
+    readonly WEAK_PASSWORD: "auth/weak-password";
+    readonly WEB_STORAGE_UNSUPPORTED: "auth/web-storage-unsupported";
+    readonly ALREADY_INITIALIZED: "auth/already-initialized";
+    readonly RECAPTCHA_NOT_ENABLED: "auth/recaptcha-not-enabled";
+    readonly MISSING_RECAPTCHA_TOKEN: "auth/missing-recaptcha-token";
+    readonly INVALID_RECAPTCHA_TOKEN: "auth/invalid-recaptcha-token";
+    readonly INVALID_RECAPTCHA_ACTION: "auth/invalid-recaptcha-action";
+    readonly MISSING_CLIENT_TYPE: "auth/missing-client-type";
+    readonly MISSING_RECAPTCHA_VERSION: "auth/missing-recaptcha-version";
+    readonly INVALID_RECAPTCHA_VERSION: "auth/invalid-recaptcha-version";
+    readonly INVALID_REQ_TYPE: "auth/invalid-req-type";
+    readonly INVALID_HOSTING_LINK_DOMAIN: "auth/invalid-hosting-link-domain";
+};
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/index.d.ts
new file mode 100644
index 0000000..8829292
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/index.d.ts
@@ -0,0 +1,230 @@
+/**
+ * @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 { Auth, NextOrObserver, Persistence, User, CompleteFn, ErrorFn, Unsubscribe, PasswordValidationStatus } from '../model/public_types';
+export { debugErrorMap, prodErrorMap, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as AuthErrorCodes } from './errors';
+/**
+ * Changes the type of persistence on the {@link Auth} instance for the currently saved
+ * `Auth` session and applies this type of persistence for future sign-in requests, including
+ * sign-in with redirect requests.
+ *
+ * @remarks
+ * This makes it easy for a user signing in to specify whether their session should be
+ * remembered or not. It also makes it easier to never persist the `Auth` state for applications
+ * that are shared by other users or have sensitive data.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * setPersistence(auth, browserSessionPersistence);
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param persistence - The {@link Persistence} to use.
+ * @returns A `Promise` that resolves once the persistence change has completed
+ *
+ * @public
+ */
+export declare function setPersistence(auth: Auth, persistence: Persistence): Promise<void>;
+/**
+ * Loads the reCAPTCHA configuration into the `Auth` instance.
+ *
+ * @remarks
+ * This will load the reCAPTCHA config, which indicates whether the reCAPTCHA
+ * verification flow should be triggered for each auth provider, into the
+ * current Auth session.
+ *
+ * If initializeRecaptchaConfig() is not invoked, the auth flow will always start
+ * without reCAPTCHA verification. If the provider is configured to require reCAPTCHA
+ * verification, the SDK will transparently load the reCAPTCHA config and restart the
+ * auth flows.
+ *
+ * Thus, by calling this optional method, you will reduce the latency of future auth flows.
+ * Loading the reCAPTCHA config early will also enhance the signal collected by reCAPTCHA.
+ *
+ * This method does not work in a Node.js environment.
+ *
+ * @example
+ * ```javascript
+ * initializeRecaptchaConfig(auth);
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ *
+ * @public
+ */
+export declare function initializeRecaptchaConfig(auth: Auth): Promise<void>;
+/**
+ * Validates the password against the password policy configured for the project or tenant.
+ *
+ * @remarks
+ * If no tenant ID is set on the `Auth` instance, then this method will use the password
+ * policy configured for the project. Otherwise, this method will use the policy configured
+ * for the tenant. If a password policy has not been configured, then the default policy
+ * configured for all projects will be used.
+ *
+ * If an auth flow fails because a submitted password does not meet the password policy
+ * requirements and this method has previously been called, then this method will use the
+ * most recent policy available when called again.
+ *
+ * @example
+ * ```javascript
+ * validatePassword(auth, 'some-password');
+ * ```
+ *
+ * @param auth The {@link Auth} instance.
+ * @param password The password to validate.
+ *
+ * @public
+ */
+export declare function validatePassword(auth: Auth, password: string): Promise<PasswordValidationStatus>;
+/**
+ * Adds an observer for changes to the signed-in user's ID token.
+ *
+ * @remarks
+ * This includes sign-in, sign-out, and token refresh events.
+ * This will not be triggered automatically upon ID token expiration. Use {@link User.getIdToken} to refresh the ID token.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param nextOrObserver - callback triggered on change.
+ * @param error - Deprecated. This callback is never triggered. Errors
+ * on signing in/out can be caught in promises returned from
+ * sign-in/sign-out functions.
+ * @param completed - Deprecated. This callback is never triggered.
+ *
+ * @public
+ */
+export declare function onIdTokenChanged(auth: Auth, nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+/**
+ * Adds a blocking callback that runs before an auth state change
+ * sets a new user.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param callback - callback triggered before new user value is set.
+ *   If this throws, it blocks the user from being set.
+ * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`
+ *   callback throws, allowing you to undo any side effects.
+ */
+export declare function beforeAuthStateChanged(auth: Auth, callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
+/**
+ * Adds an observer for changes to the user's sign-in state.
+ *
+ * @remarks
+ * To keep the old behavior, see {@link onIdTokenChanged}.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param nextOrObserver - callback triggered on change.
+ * @param error - Deprecated. This callback is never triggered. Errors
+ * on signing in/out can be caught in promises returned from
+ * sign-in/sign-out functions.
+ * @param completed - Deprecated. This callback is never triggered.
+ *
+ * @public
+ */
+export declare function onAuthStateChanged(auth: Auth, nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+/**
+ * Sets the current language to the default device/browser preference.
+ *
+ * @param auth - The {@link Auth} instance.
+ *
+ * @public
+ */
+export declare function useDeviceLanguage(auth: Auth): void;
+/**
+ * Asynchronously sets the provided user as {@link Auth.currentUser} on the
+ * {@link Auth} instance.
+ *
+ * @remarks
+ * A new instance copy of the user provided will be made and set as currentUser.
+ *
+ * This will trigger {@link onAuthStateChanged} and {@link onIdTokenChanged} listeners
+ * like other sign in methods.
+ *
+ * The operation fails with an error if the user to be updated belongs to a different Firebase
+ * project.
+ *
+ * This method is not supported by {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param user - The new {@link User}.
+ *
+ * @public
+ */
+export declare function updateCurrentUser(auth: Auth, user: User | null): Promise<void>;
+/**
+ * Signs out the current user.
+ *
+ * @remarks
+ * This method is not supported by {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @param auth - The {@link Auth} instance.
+ *
+ * @public
+ */
+export declare function signOut(auth: Auth): Promise<void>;
+/**
+ * Revokes the given access token. Currently only supports Apple OAuth access tokens.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param token - The Apple OAuth access token.
+ *
+ * @public
+ */
+export declare function revokeAccessToken(auth: Auth, token: string): Promise<void>;
+export { initializeAuth } from './auth/initialize';
+export { connectAuthEmulator } from './auth/emulator';
+export { AuthCredential } from './credentials';
+export { EmailAuthCredential } from './credentials/email';
+export { OAuthCredential } from './credentials/oauth';
+export { PhoneAuthCredential } from './credentials/phone';
+export { inMemoryPersistence } from './persistence/in_memory';
+export { EmailAuthProvider } from './providers/email';
+export { FacebookAuthProvider } from './providers/facebook';
+export { CustomParameters } from './providers/federated';
+export { GoogleAuthProvider } from './providers/google';
+export { GithubAuthProvider } from './providers/github';
+export { OAuthProvider, OAuthCredentialOptions } from './providers/oauth';
+export { SAMLAuthProvider } from './providers/saml';
+export { TwitterAuthProvider } from './providers/twitter';
+export { signInAnonymously } from './strategies/anonymous';
+export { signInWithCredential, linkWithCredential, reauthenticateWithCredential } from './strategies/credential';
+export { signInWithCustomToken } from './strategies/custom_token';
+export { sendPasswordResetEmail, confirmPasswordReset, applyActionCode, checkActionCode, verifyPasswordResetCode, createUserWithEmailAndPassword, signInWithEmailAndPassword } from './strategies/email_and_password';
+export { sendSignInLinkToEmail, isSignInWithEmailLink, signInWithEmailLink } from './strategies/email_link';
+export { fetchSignInMethodsForEmail, sendEmailVerification, verifyBeforeUpdateEmail } from './strategies/email';
+export { ActionCodeURL, parseActionCodeURL } from './action_code_url';
+export { updateProfile, updateEmail, updatePassword } from './user/account_info';
+export { getIdToken, getIdTokenResult } from './user/id_token_result';
+export { unlink } from './user/link_unlink';
+export { getAdditionalUserInfo } from './user/additional_user_info';
+export { reload } from './user/reload';
+/**
+ * Deletes and signs out the user.
+ *
+ * @remarks
+ * Important: this is a security-sensitive operation that requires the user to have recently
+ * signed in. If this requirement isn't met, ask the user to authenticate again and then call
+ * {@link reauthenticateWithCredential}.
+ *
+ * @param user - The user.
+ *
+ * @public
+ */
+export declare function deleteUser(user: User): Promise<void>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/in_memory.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/in_memory.d.ts
new file mode 100644
index 0000000..60278cd
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/in_memory.d.ts
@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Persistence } from '../../model/public_types';
+import { PersistenceInternal, PersistenceType, PersistenceValue, StorageEventListener } from '../persistence';
+export declare class InMemoryPersistence implements PersistenceInternal {
+    static type: 'NONE';
+    readonly type = PersistenceType.NONE;
+    storage: Record<string, PersistenceValue>;
+    _isAvailable(): Promise<boolean>;
+    _set(key: string, value: PersistenceValue): Promise<void>;
+    _get<T extends PersistenceValue>(key: string): Promise<T | null>;
+    _remove(key: string): Promise<void>;
+    _addListener(_key: string, _listener: StorageEventListener): void;
+    _removeListener(_key: string, _listener: StorageEventListener): void;
+}
+/**
+ * An implementation of {@link Persistence} of type 'NONE'.
+ *
+ * @public
+ */
+export declare const inMemoryPersistence: Persistence;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/index.d.ts
new file mode 100644
index 0000000..4460f02
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/index.d.ts
@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Persistence } from '../../model/public_types';
+export declare const enum PersistenceType {
+    SESSION = "SESSION",
+    LOCAL = "LOCAL",
+    NONE = "NONE",
+    COOKIE = "COOKIE"
+}
+export type PersistedBlob = Record<string, unknown>;
+export interface Instantiator<T> {
+    (blob: PersistedBlob): T;
+}
+export type PersistenceValue = PersistedBlob | string;
+export declare const STORAGE_AVAILABLE_KEY = "__sak";
+export interface StorageEventListener {
+    (value: PersistenceValue | null): void;
+}
+export interface PersistenceInternal extends Persistence {
+    type: PersistenceType;
+    _isAvailable(): Promise<boolean>;
+    _set(key: string, value: PersistenceValue): Promise<void>;
+    _get<T extends PersistenceValue>(key: string): Promise<T | null>;
+    _remove(key: string): Promise<void>;
+    _addListener(key: string, listener: StorageEventListener): void;
+    _removeListener(key: string, listener: StorageEventListener): void;
+    _shouldAllowMigration?: boolean;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/persistence_user_manager.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/persistence_user_manager.d.ts
new file mode 100644
index 0000000..7aca0d8
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/persistence/persistence_user_manager.d.ts
@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ApiKey, AppName, AuthInternal } from '../../model/auth';
+import { UserInternal } from '../../model/user';
+import { PersistenceInternal } from '../persistence';
+export declare const enum KeyName {
+    AUTH_USER = "authUser",
+    AUTH_EVENT = "authEvent",
+    REDIRECT_USER = "redirectUser",
+    PERSISTENCE_USER = "persistence"
+}
+export declare const enum Namespace {
+    PERSISTENCE = "firebase"
+}
+export declare function _persistenceKeyName(key: string, apiKey: ApiKey, appName: AppName): string;
+export declare class PersistenceUserManager {
+    persistence: PersistenceInternal;
+    private readonly auth;
+    private readonly userKey;
+    private readonly fullUserKey;
+    private readonly fullPersistenceKey;
+    private readonly boundEventHandler;
+    private constructor();
+    setCurrentUser(user: UserInternal): Promise<void>;
+    getCurrentUser(): Promise<UserInternal | null>;
+    removeCurrentUser(): Promise<void>;
+    savePersistenceForRedirect(): Promise<void>;
+    setPersistence(newPersistence: PersistenceInternal): Promise<void>;
+    delete(): void;
+    static create(auth: AuthInternal, persistenceHierarchy: PersistenceInternal[], userKey?: KeyName): Promise<PersistenceUserManager>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/email.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/email.d.ts
new file mode 100644
index 0000000..be276ad
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/email.d.ts
@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthProvider } from '../../model/public_types';
+import { EmailAuthCredential } from '../credentials/email';
+/**
+ * Provider for generating {@link EmailAuthCredential}.
+ *
+ * @public
+ */
+export declare class EmailAuthProvider implements AuthProvider {
+    /**
+     * Always set to {@link ProviderId}.PASSWORD, even for email link.
+     */
+    static readonly PROVIDER_ID: 'password';
+    /**
+     * Always set to {@link SignInMethod}.EMAIL_PASSWORD.
+     */
+    static readonly EMAIL_PASSWORD_SIGN_IN_METHOD: 'password';
+    /**
+     * Always set to {@link SignInMethod}.EMAIL_LINK.
+     */
+    static readonly EMAIL_LINK_SIGN_IN_METHOD: 'emailLink';
+    /**
+     * Always set to {@link ProviderId}.PASSWORD, even for email link.
+     */
+    readonly providerId: "password";
+    /**
+     * Initialize an {@link AuthCredential} using an email and password.
+     *
+     * @example
+     * ```javascript
+     * const authCredential = EmailAuthProvider.credential(email, password);
+     * const userCredential = await signInWithCredential(auth, authCredential);
+     * ```
+     *
+     * @example
+     * ```javascript
+     * const userCredential = await signInWithEmailAndPassword(auth, email, password);
+     * ```
+     *
+     * @param email - Email address.
+     * @param password - User account password.
+     * @returns The auth provider credential.
+     */
+    static credential(email: string, password: string): EmailAuthCredential;
+    /**
+     * Initialize an {@link AuthCredential} using an email and an email link after a sign in with
+     * email link operation.
+     *
+     * @example
+     * ```javascript
+     * const authCredential = EmailAuthProvider.credentialWithLink(auth, email, emailLink);
+     * const userCredential = await signInWithCredential(auth, authCredential);
+     * ```
+     *
+     * @example
+     * ```javascript
+     * await sendSignInLinkToEmail(auth, email);
+     * // Obtain emailLink from user.
+     * const userCredential = await signInWithEmailLink(auth, email, emailLink);
+     * ```
+     *
+     * @param auth - The {@link Auth} instance used to verify the link.
+     * @param email - Email address.
+     * @param emailLink - Sign-in email link.
+     * @returns - The auth provider credential.
+     */
+    static credentialWithLink(email: string, emailLink: string): EmailAuthCredential;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/facebook.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/facebook.d.ts
new file mode 100644
index 0000000..cd8feca
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/facebook.d.ts
@@ -0,0 +1,93 @@
+/**
+ * @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 { UserCredential } from '../../model/public_types';
+import { FirebaseError } from '@firebase/util';
+import { OAuthCredential } from '../credentials/oauth';
+import { BaseOAuthProvider } from './oauth';
+/**
+ * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.FACEBOOK.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * // Start a sign in process for an unauthenticated user.
+ * provider.addScope('user_birthday');
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ *   // This is the signed-in user
+ *   const user = result.user;
+ *   // This gives you a Facebook Access Token.
+ *   const credential = FacebookAuthProvider.credentialFromResult(result);
+ *   const token = credential.accessToken;
+ * }
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new FacebookAuthProvider();
+ * provider.addScope('user_birthday');
+ * const result = await signInWithPopup(auth, provider);
+ *
+ * // The signed-in user info.
+ * const user = result.user;
+ * // This gives you a Facebook Access Token.
+ * const credential = FacebookAuthProvider.credentialFromResult(result);
+ * const token = credential.accessToken;
+ * ```
+ *
+ * @public
+ */
+export declare class FacebookAuthProvider extends BaseOAuthProvider {
+    /** Always set to {@link SignInMethod}.FACEBOOK. */
+    static readonly FACEBOOK_SIGN_IN_METHOD: 'facebook.com';
+    /** Always set to {@link ProviderId}.FACEBOOK. */
+    static readonly PROVIDER_ID: 'facebook.com';
+    constructor();
+    /**
+     * Creates a credential for Facebook.
+     *
+     * @example
+     * ```javascript
+     * // `event` from the Facebook auth.authResponseChange callback.
+     * const credential = FacebookAuthProvider.credential(event.authResponse.accessToken);
+     * const result = await signInWithCredential(credential);
+     * ```
+     *
+     * @param accessToken - Facebook access token.
+     */
+    static credential(accessToken: string): OAuthCredential;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromResult(userCredential: UserCredential): OAuthCredential | null;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+     * thrown during a sign-in, link, or reauthenticate operation.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromError(error: FirebaseError): OAuthCredential | null;
+    private static credentialFromTaggedObject;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/federated.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/federated.d.ts
new file mode 100644
index 0000000..91d38b1
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/federated.d.ts
@@ -0,0 +1,64 @@
+/**
+ * @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 { AuthProvider } from '../../model/public_types';
+/**
+ * Map of OAuth Custom Parameters.
+ *
+ * @public
+ */
+export type CustomParameters = Record<string, string>;
+/**
+ * The base class for all Federated providers (OAuth (including OIDC), SAML).
+ *
+ * This class is not meant to be instantiated directly.
+ *
+ * @public
+ */
+export declare abstract class FederatedAuthProvider implements AuthProvider {
+    readonly providerId: string;
+    /** @internal */
+    defaultLanguageCode: string | null;
+    /** @internal */
+    private customParameters;
+    /**
+     * Constructor for generic OAuth providers.
+     *
+     * @param providerId - Provider for which credentials should be generated.
+     */
+    constructor(providerId: string);
+    /**
+     * Set the language gode.
+     *
+     * @param languageCode - language code
+     */
+    setDefaultLanguage(languageCode: string | null): void;
+    /**
+     * Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in
+     * operations.
+     *
+     * @remarks
+     * For a detailed list, check the reserved required OAuth 2.0 parameters such as `client_id`,
+     * `redirect_uri`, `scope`, `response_type`, and `state` are not allowed and will be ignored.
+     *
+     * @param customOAuthParameters - The custom OAuth parameters to pass in the OAuth request.
+     */
+    setCustomParameters(customOAuthParameters: CustomParameters): AuthProvider;
+    /**
+     * Retrieve the current list of {@link CustomParameters}.
+     */
+    getCustomParameters(): CustomParameters;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/github.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/github.d.ts
new file mode 100644
index 0000000..b8b3ee9
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/github.d.ts
@@ -0,0 +1,89 @@
+/**
+ * @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 { UserCredential } from '../../model/public_types';
+import { FirebaseError } from '@firebase/util';
+import { OAuthCredential } from '../credentials/oauth';
+import { BaseOAuthProvider } from './oauth';
+/**
+ * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.GITHUB.
+ *
+ * @remarks
+ * GitHub requires an OAuth 2.0 redirect, so you can either handle the redirect directly, or use
+ * the {@link signInWithPopup} handler:
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new GithubAuthProvider();
+ * // Start a sign in process for an unauthenticated user.
+ * provider.addScope('repo');
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ *   // This is the signed-in user
+ *   const user = result.user;
+ *   // This gives you a GitHub Access Token.
+ *   const credential = GithubAuthProvider.credentialFromResult(result);
+ *   const token = credential.accessToken;
+ * }
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new GithubAuthProvider();
+ * provider.addScope('repo');
+ * const result = await signInWithPopup(auth, provider);
+ *
+ * // The signed-in user info.
+ * const user = result.user;
+ * // This gives you a GitHub Access Token.
+ * const credential = GithubAuthProvider.credentialFromResult(result);
+ * const token = credential.accessToken;
+ * ```
+ * @public
+ */
+export declare class GithubAuthProvider extends BaseOAuthProvider {
+    /** Always set to {@link SignInMethod}.GITHUB. */
+    static readonly GITHUB_SIGN_IN_METHOD: 'github.com';
+    /** Always set to {@link ProviderId}.GITHUB. */
+    static readonly PROVIDER_ID: 'github.com';
+    constructor();
+    /**
+     * Creates a credential for GitHub.
+     *
+     * @param accessToken - GitHub access token.
+     */
+    static credential(accessToken: string): OAuthCredential;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromResult(userCredential: UserCredential): OAuthCredential | null;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+     * thrown during a sign-in, link, or reauthenticate operation.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromError(error: FirebaseError): OAuthCredential | null;
+    private static credentialFromTaggedObject;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/google.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/google.d.ts
new file mode 100644
index 0000000..25d74c8
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/google.d.ts
@@ -0,0 +1,96 @@
+/**
+ * @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 { UserCredential } from '../../model/public_types';
+import { FirebaseError } from '@firebase/util';
+import { OAuthCredential } from '../credentials/oauth';
+import { BaseOAuthProvider } from './oauth';
+/**
+ * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.GOOGLE.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new GoogleAuthProvider();
+ * // Start a sign in process for an unauthenticated user.
+ * provider.addScope('profile');
+ * provider.addScope('email');
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ *   // This is the signed-in user
+ *   const user = result.user;
+ *   // This gives you a Google Access Token.
+ *   const credential = GoogleAuthProvider.credentialFromResult(result);
+ *   const token = credential.accessToken;
+ * }
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new GoogleAuthProvider();
+ * provider.addScope('profile');
+ * provider.addScope('email');
+ * const result = await signInWithPopup(auth, provider);
+ *
+ * // The signed-in user info.
+ * const user = result.user;
+ * // This gives you a Google Access Token.
+ * const credential = GoogleAuthProvider.credentialFromResult(result);
+ * const token = credential.accessToken;
+ * ```
+ *
+ * @public
+ */
+export declare class GoogleAuthProvider extends BaseOAuthProvider {
+    /** Always set to {@link SignInMethod}.GOOGLE. */
+    static readonly GOOGLE_SIGN_IN_METHOD: 'google.com';
+    /** Always set to {@link ProviderId}.GOOGLE. */
+    static readonly PROVIDER_ID: 'google.com';
+    constructor();
+    /**
+     * Creates a credential for Google. At least one of ID token and access token is required.
+     *
+     * @example
+     * ```javascript
+     * // \`googleUser\` from the onsuccess Google Sign In callback.
+     * const credential = GoogleAuthProvider.credential(googleUser.getAuthResponse().id_token);
+     * const result = await signInWithCredential(credential);
+     * ```
+     *
+     * @param idToken - Google ID token.
+     * @param accessToken - Google access token.
+     */
+    static credential(idToken?: string | null, accessToken?: string | null): OAuthCredential;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromResult(userCredential: UserCredential): OAuthCredential | null;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+     * thrown during a sign-in, link, or reauthenticate operation.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromError(error: FirebaseError): OAuthCredential | null;
+    private static credentialFromTaggedObject;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/oauth.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/oauth.d.ts
new file mode 100644
index 0000000..3e8e664
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/oauth.d.ts
@@ -0,0 +1,151 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthProvider, UserCredential } from '../../model/public_types';
+import { OAuthCredential } from '../credentials/oauth';
+import { FirebaseError } from '@firebase/util';
+import { FederatedAuthProvider } from './federated';
+/**
+ * Defines the options for initializing an {@link OAuthCredential}.
+ *
+ * @remarks
+ * For ID tokens with nonce claim, the raw nonce has to also be provided.
+ *
+ * @public
+ */
+export interface OAuthCredentialOptions {
+    /**
+     * The OAuth ID token used to initialize the {@link OAuthCredential}.
+     */
+    idToken?: string;
+    /**
+     * The OAuth access token used to initialize the {@link OAuthCredential}.
+     */
+    accessToken?: string;
+    /**
+     * The raw nonce associated with the ID token.
+     *
+     * @remarks
+     * It is required when an ID token with a nonce field is provided. The SHA-256 hash of the
+     * raw nonce must match the nonce field in the ID token.
+     */
+    rawNonce?: string;
+}
+/**
+ * Common code to all OAuth providers. This is separate from the
+ * {@link OAuthProvider} so that child providers (like
+ * {@link GoogleAuthProvider}) don't inherit the `credential` instance method.
+ * Instead, they rely on a static `credential` method.
+ */
+export declare abstract class BaseOAuthProvider extends FederatedAuthProvider implements AuthProvider {
+    /** @internal */
+    private scopes;
+    /**
+     * Add an OAuth scope to the credential.
+     *
+     * @param scope - Provider OAuth scope to add.
+     */
+    addScope(scope: string): AuthProvider;
+    /**
+     * Retrieve the current list of OAuth scopes.
+     */
+    getScopes(): string[];
+}
+/**
+ * Provider for generating generic {@link OAuthCredential}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new OAuthProvider('google.com');
+ * // Start a sign in process for an unauthenticated user.
+ * provider.addScope('profile');
+ * provider.addScope('email');
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ *   // This is the signed-in user
+ *   const user = result.user;
+ *   // This gives you a OAuth Access Token for the provider.
+ *   const credential = provider.credentialFromResult(auth, result);
+ *   const token = credential.accessToken;
+ * }
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new OAuthProvider('google.com');
+ * provider.addScope('profile');
+ * provider.addScope('email');
+ * const result = await signInWithPopup(auth, provider);
+ *
+ * // The signed-in user info.
+ * const user = result.user;
+ * // This gives you a OAuth Access Token for the provider.
+ * const credential = provider.credentialFromResult(auth, result);
+ * const token = credential.accessToken;
+ * ```
+ * @public
+ */
+export declare class OAuthProvider extends BaseOAuthProvider {
+    /**
+     * Creates an {@link OAuthCredential} from a JSON string or a plain object.
+     * @param json - A plain object or a JSON string
+     */
+    static credentialFromJSON(json: object | string): OAuthCredential;
+    /**
+     * Creates a {@link OAuthCredential} from a generic OAuth provider's access token or ID token.
+     *
+     * @remarks
+     * The raw nonce is required when an ID token with a nonce field is provided. The SHA-256 hash of
+     * the raw nonce must match the nonce field in the ID token.
+     *
+     * @example
+     * ```javascript
+     * // `googleUser` from the onsuccess Google Sign In callback.
+     * // Initialize a generate OAuth provider with a `google.com` providerId.
+     * const provider = new OAuthProvider('google.com');
+     * const credential = provider.credential({
+     *   idToken: googleUser.getAuthResponse().id_token,
+     * });
+     * const result = await signInWithCredential(credential);
+     * ```
+     *
+     * @param params - Either the options object containing the ID token, access token and raw nonce
+     * or the ID token string.
+     */
+    credential(params: OAuthCredentialOptions): OAuthCredential;
+    /** An internal credential method that accepts more permissive options */
+    private _credential;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromResult(userCredential: UserCredential): OAuthCredential | null;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+     * thrown during a sign-in, link, or reauthenticate operation.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromError(error: FirebaseError): OAuthCredential | null;
+    private static oauthCredentialFromTaggedObject;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/saml.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/saml.d.ts
new file mode 100644
index 0000000..6017bfe
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/saml.d.ts
@@ -0,0 +1,62 @@
+/**
+ * @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 { FirebaseError } from '@firebase/util';
+import { UserCredential } from '../../model/public_types';
+import { AuthCredential } from '../credentials';
+import { FederatedAuthProvider } from './federated';
+/**
+ * An {@link AuthProvider} for SAML.
+ *
+ * @public
+ */
+export declare class SAMLAuthProvider extends FederatedAuthProvider {
+    /**
+     * Constructor. The providerId must start with "saml."
+     * @param providerId - SAML provider ID.
+     */
+    constructor(providerId: string);
+    /**
+     * Generates an {@link AuthCredential} from a {@link UserCredential} after a
+     * successful SAML flow completes.
+     *
+     * @remarks
+     *
+     * For example, to get an {@link AuthCredential}, you could write the
+     * following code:
+     *
+     * ```js
+     * const userCredential = await signInWithPopup(auth, samlProvider);
+     * const credential = SAMLAuthProvider.credentialFromResult(userCredential);
+     * ```
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromResult(userCredential: UserCredential): AuthCredential | null;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+     * thrown during a sign-in, link, or reauthenticate operation.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromError(error: FirebaseError): AuthCredential | null;
+    /**
+     * Creates an {@link AuthCredential} from a JSON string or a plain object.
+     * @param json - A plain object or a JSON string
+     */
+    static credentialFromJSON(json: string | object): AuthCredential;
+    private static samlCredentialFromTaggedObject;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/twitter.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/twitter.d.ts
new file mode 100644
index 0000000..612913d
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/providers/twitter.d.ts
@@ -0,0 +1,103 @@
+/**
+ * @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.
+ */
+/**
+ * @license
+ * Copyright 2020 Twitter 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 { UserCredential } from '../../model/public_types';
+import { FirebaseError } from '@firebase/util';
+import { OAuthCredential } from '../credentials/oauth';
+import { BaseOAuthProvider } from './oauth';
+/**
+ * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.TWITTER.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new TwitterAuthProvider();
+ * // Start a sign in process for an unauthenticated user.
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ *   // This is the signed-in user
+ *   const user = result.user;
+ *   // This gives you a Twitter Access Token and Secret.
+ *   const credential = TwitterAuthProvider.credentialFromResult(result);
+ *   const token = credential.accessToken;
+ *   const secret = credential.secret;
+ * }
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new TwitterAuthProvider();
+ * const result = await signInWithPopup(auth, provider);
+ *
+ * // The signed-in user info.
+ * const user = result.user;
+ * // This gives you a Twitter Access Token and Secret.
+ * const credential = TwitterAuthProvider.credentialFromResult(result);
+ * const token = credential.accessToken;
+ * const secret = credential.secret;
+ * ```
+ *
+ * @public
+ */
+export declare class TwitterAuthProvider extends BaseOAuthProvider {
+    /** Always set to {@link SignInMethod}.TWITTER. */
+    static readonly TWITTER_SIGN_IN_METHOD: 'twitter.com';
+    /** Always set to {@link ProviderId}.TWITTER. */
+    static readonly PROVIDER_ID: 'twitter.com';
+    constructor();
+    /**
+     * Creates a credential for Twitter.
+     *
+     * @param token - Twitter access token.
+     * @param secret - Twitter secret.
+     */
+    static credential(token: string, secret: string): OAuthCredential;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromResult(userCredential: UserCredential): OAuthCredential | null;
+    /**
+     * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+     * thrown during a sign-in, link, or reauthenticate operation.
+     *
+     * @param userCredential - The user credential.
+     */
+    static credentialFromError(error: FirebaseError): OAuthCredential | null;
+    private static credentialFromTaggedObject;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/abstract_popup_redirect_operation.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/abstract_popup_redirect_operation.d.ts
new file mode 100644
index 0000000..6f5e076
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/abstract_popup_redirect_operation.d.ts
@@ -0,0 +1,44 @@
+/**
+ * @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 { FirebaseError } from '@firebase/util';
+import { AuthEvent, AuthEventConsumer, AuthEventType, PopupRedirectResolverInternal } from '../../model/popup_redirect';
+import { UserInternal, UserCredentialInternal } from '../../model/user';
+import { AuthInternal } from '../../model/auth';
+/**
+ * Popup event manager. Handles the popup's entire lifecycle; listens to auth
+ * events
+ */
+export declare abstract class AbstractPopupRedirectOperation implements AuthEventConsumer {
+    protected readonly auth: AuthInternal;
+    protected readonly resolver: PopupRedirectResolverInternal;
+    protected user?: UserInternal | undefined;
+    protected readonly bypassAuthState: boolean;
+    private pendingPromise;
+    private eventManager;
+    readonly filter: AuthEventType[];
+    abstract eventId: string | null;
+    constructor(auth: AuthInternal, filter: AuthEventType | AuthEventType[], resolver: PopupRedirectResolverInternal, user?: UserInternal | undefined, bypassAuthState?: boolean);
+    abstract onExecution(): Promise<void>;
+    execute(): Promise<UserCredentialInternal | null>;
+    onAuthEvent(event: AuthEvent): Promise<void>;
+    onError(error: FirebaseError): void;
+    private getIdpTask;
+    protected resolve(cred: UserCredentialInternal | null): void;
+    protected reject(error: Error): void;
+    private unregisterAndCleanUp;
+    abstract cleanUp(): void;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/action_code_settings.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/action_code_settings.d.ts
new file mode 100644
index 0000000..23fa039
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/action_code_settings.d.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ActionCodeSettings, Auth } from '../../model/public_types';
+import { GetOobCodeRequest } from '../../api/authentication/email_and_password';
+export declare function _setActionCodeSettingsOnRequest(auth: Auth, request: GetOobCodeRequest, actionCodeSettings: ActionCodeSettings): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/anonymous.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/anonymous.d.ts
new file mode 100644
index 0000000..687a797
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/anonymous.d.ts
@@ -0,0 +1,32 @@
+/**
+ * @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 { Auth, UserCredential } from '../../model/public_types';
+/**
+ * Asynchronously signs in as an anonymous user.
+ *
+ * @remarks
+ * If there is already an anonymous user signed in, that user will be returned; otherwise, a
+ * new anonymous user identity will be created and returned.
+ *
+ * This method is not supported by {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @param auth - The {@link Auth} instance.
+ *
+ * @public
+ */
+export declare function signInAnonymously(auth: Auth): Promise<UserCredential>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/credential.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/credential.d.ts
new file mode 100644
index 0000000..392d663
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/credential.d.ts
@@ -0,0 +1,64 @@
+/**
+ * @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 { UserCredential, Auth, User } from '../../model/public_types';
+import { AuthInternal } from '../../model/auth';
+import { AuthCredential } from '../credentials';
+export declare function _signInWithCredential(auth: AuthInternal, credential: AuthCredential, bypassAuthState?: boolean): Promise<UserCredential>;
+/**
+ * Asynchronously signs in with the given credentials.
+ *
+ * @remarks
+ * An {@link AuthProvider} can be used to generate the credential.
+ *
+ * This method is not supported by {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param credential - The auth credential.
+ *
+ * @public
+ */
+export declare function signInWithCredential(auth: Auth, credential: AuthCredential): Promise<UserCredential>;
+/**
+ * Links the user account with the given credentials.
+ *
+ * @remarks
+ * An {@link AuthProvider} can be used to generate the credential.
+ *
+ * @param user - The user.
+ * @param credential - The auth credential.
+ *
+ * @public
+ */
+export declare function linkWithCredential(user: User, credential: AuthCredential): Promise<UserCredential>;
+/**
+ * Re-authenticates a user using a fresh credential.
+ *
+ * @remarks
+ * Use before operations such as {@link updatePassword} that require tokens from recent sign-in
+ * attempts. This method can be used to recover from a `CREDENTIAL_TOO_OLD_LOGIN_AGAIN` error
+ * or a `TOKEN_EXPIRED` error.
+ *
+ * This method is not supported on any {@link User} signed in by {@link Auth} instances
+ * created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @param user - The user.
+ * @param credential - The auth credential.
+ *
+ * @public
+ */
+export declare function reauthenticateWithCredential(user: User, credential: AuthCredential): Promise<UserCredential>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/custom_token.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/custom_token.d.ts
new file mode 100644
index 0000000..e95cc38
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/custom_token.d.ts
@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Auth, UserCredential } from '../../model/public_types';
+/**
+ * Asynchronously signs in using a custom token.
+ *
+ * @remarks
+ * Custom tokens are used to integrate Firebase Auth with existing auth systems, and must
+ * be generated by an auth backend using the
+ * {@link https://firebase.google.com/docs/reference/admin/node/admin.auth.Auth#createcustomtoken | createCustomToken}
+ * method in the {@link https://firebase.google.com/docs/auth/admin | Admin SDK} .
+ *
+ * Fails with an error if the token is invalid, expired, or not accepted by the Firebase Auth service.
+ *
+ * This method is not supported by {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param customToken - The custom token to sign in with.
+ *
+ * @public
+ */
+export declare function signInWithCustomToken(auth: Auth, customToken: string): Promise<UserCredential>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email.d.ts
new file mode 100644
index 0000000..3505c34
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email.d.ts
@@ -0,0 +1,104 @@
+/**
+ * @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 { ActionCodeSettings, Auth, User } from '../../model/public_types';
+/**
+ * Gets the list of possible sign in methods for the given email address. This method returns an
+ * empty list when
+ * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+ * is enabled, irrespective of the number of authentication methods available for the given email.
+ *
+ * @remarks
+ * This is useful to differentiate methods of sign-in for the same provider, eg.
+ * {@link EmailAuthProvider} which has 2 methods of sign-in,
+ * {@link SignInMethod}.EMAIL_PASSWORD and
+ * {@link SignInMethod}.EMAIL_LINK.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param email - The user's email address.
+ *
+ * Deprecated. Migrating off of this method is recommended as a security best-practice.
+ * Learn more in the Identity Platform documentation for
+ * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}.
+ * @public
+ */
+export declare function fetchSignInMethodsForEmail(auth: Auth, email: string): Promise<string[]>;
+/**
+ * Sends a verification email to a user.
+ *
+ * @remarks
+ * The verification process is completed by calling {@link applyActionCode}.
+ *
+ * @example
+ * ```javascript
+ * const actionCodeSettings = {
+ *   url: 'https://www.example.com/?email=user@example.com',
+ *   iOS: {
+ *      bundleId: 'com.example.ios'
+ *   },
+ *   android: {
+ *     packageName: 'com.example.android',
+ *     installApp: true,
+ *     minimumVersion: '12'
+ *   },
+ *   handleCodeInApp: true
+ * };
+ * await sendEmailVerification(user, actionCodeSettings);
+ * // Obtain code from the user.
+ * await applyActionCode(auth, code);
+ * ```
+ *
+ * @param user - The user.
+ * @param actionCodeSettings - The {@link ActionCodeSettings}.
+ *
+ * @public
+ */
+export declare function sendEmailVerification(user: User, actionCodeSettings?: ActionCodeSettings | null): Promise<void>;
+/**
+ * Sends a verification email to a new email address.
+ *
+ * @remarks
+ * The user's email will be updated to the new one after being verified.
+ *
+ * If you have a custom email action handler, you can complete the verification process by calling
+ * {@link applyActionCode}.
+ *
+ * @example
+ * ```javascript
+ * const actionCodeSettings = {
+ *   url: 'https://www.example.com/?email=user@example.com',
+ *   iOS: {
+ *      bundleId: 'com.example.ios'
+ *   },
+ *   android: {
+ *     packageName: 'com.example.android',
+ *     installApp: true,
+ *     minimumVersion: '12'
+ *   },
+ *   handleCodeInApp: true
+ * };
+ * await verifyBeforeUpdateEmail(user, 'newemail@example.com', actionCodeSettings);
+ * // Obtain code from the user.
+ * await applyActionCode(auth, code);
+ * ```
+ *
+ * @param user - The user.
+ * @param newEmail - The new email address to be verified before update.
+ * @param actionCodeSettings - The {@link ActionCodeSettings}.
+ *
+ * @public
+ */
+export declare function verifyBeforeUpdateEmail(user: User, newEmail: string, actionCodeSettings?: ActionCodeSettings | null): Promise<void>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email_and_password.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email_and_password.d.ts
new file mode 100644
index 0000000..205f33a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email_and_password.d.ts
@@ -0,0 +1,139 @@
+/**
+ * @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 { ActionCodeInfo, ActionCodeSettings, Auth, UserCredential } from '../../model/public_types';
+/**
+ * Sends a password reset email to the given email address. This method does not throw an error when
+ * there's no user account with the given email address and
+ * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+ * is enabled.
+ *
+ * @remarks
+ * To complete the password reset, call {@link confirmPasswordReset} with the code supplied in
+ * the email sent to the user, along with the new password specified by the user.
+ *
+ * @example
+ * ```javascript
+ * const actionCodeSettings = {
+ *   url: 'https://www.example.com/?email=user@example.com',
+ *   iOS: {
+ *      bundleId: 'com.example.ios'
+ *   },
+ *   android: {
+ *     packageName: 'com.example.android',
+ *     installApp: true,
+ *     minimumVersion: '12'
+ *   },
+ *   handleCodeInApp: true
+ * };
+ * await sendPasswordResetEmail(auth, 'user@example.com', actionCodeSettings);
+ * // Obtain code from user.
+ * await confirmPasswordReset('user@example.com', code);
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param email - The user's email address.
+ * @param actionCodeSettings - The {@link ActionCodeSettings}.
+ *
+ * @public
+ */
+export declare function sendPasswordResetEmail(auth: Auth, email: string, actionCodeSettings?: ActionCodeSettings): Promise<void>;
+/**
+ * Completes the password reset process, given a confirmation code and new password.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param oobCode - A confirmation code sent to the user.
+ * @param newPassword - The new password.
+ *
+ * @public
+ */
+export declare function confirmPasswordReset(auth: Auth, oobCode: string, newPassword: string): Promise<void>;
+/**
+ * Applies a verification code sent to the user by email or other out-of-band mechanism.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param oobCode - A verification code sent to the user.
+ *
+ * @public
+ */
+export declare function applyActionCode(auth: Auth, oobCode: string): Promise<void>;
+/**
+ * Checks a verification code sent to the user by email or other out-of-band mechanism.
+ *
+ * @returns metadata about the code.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param oobCode - A verification code sent to the user.
+ *
+ * @public
+ */
+export declare function checkActionCode(auth: Auth, oobCode: string): Promise<ActionCodeInfo>;
+/**
+ * Checks a password reset code sent to the user by email or other out-of-band mechanism.
+ *
+ * @returns the user's email address if valid.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param code - A verification code sent to the user.
+ *
+ * @public
+ */
+export declare function verifyPasswordResetCode(auth: Auth, code: string): Promise<string>;
+/**
+ * Creates a new user account associated with the specified email address and password.
+ *
+ * @remarks
+ * On successful creation of the user account, this user will also be signed in to your application.
+ *
+ * User account creation can fail if the account already exists or the password is invalid.
+ *
+ * This method is not supported on {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * Note: The email address acts as a unique identifier for the user and enables an email-based
+ * password reset. This function will create a new user account and set the initial user password.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param email - The user's email address.
+ * @param password - The user's chosen password.
+ *
+ * @public
+ */
+export declare function createUserWithEmailAndPassword(auth: Auth, email: string, password: string): Promise<UserCredential>;
+/**
+ * Asynchronously signs in using an email and password.
+ *
+ * @remarks
+ * Fails with an error if the email address and password do not match. When
+ * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+ * is enabled, this method fails with "auth/invalid-credential" in case of an invalid
+ * email/password.
+ *
+ * This method is not supported on {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * Note: The user's password is NOT the password used to access the user's email account. The
+ * email address serves as a unique identifier for the user, and the password is used to access
+ * the user's account in your Firebase project. See also: {@link createUserWithEmailAndPassword}.
+ *
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param email - The users email address.
+ * @param password - The users password.
+ *
+ * @public
+ */
+export declare function signInWithEmailAndPassword(auth: Auth, email: string, password: string): Promise<UserCredential>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email_link.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email_link.d.ts
new file mode 100644
index 0000000..8d01e8a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/email_link.d.ts
@@ -0,0 +1,107 @@
+/**
+ * @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 { ActionCodeSettings, Auth, UserCredential } from '../../model/public_types';
+/**
+ * Sends a sign-in email link to the user with the specified email.
+ *
+ * @remarks
+ * The sign-in operation has to always be completed in the app unlike other out of band email
+ * actions (password reset and email verifications). This is because, at the end of the flow,
+ * the user is expected to be signed in and their Auth state persisted within the app.
+ *
+ * To complete sign in with the email link, call {@link signInWithEmailLink} with the email
+ * address and the email link supplied in the email sent to the user.
+ *
+ * @example
+ * ```javascript
+ * const actionCodeSettings = {
+ *   url: 'https://www.example.com/?email=user@example.com',
+ *   iOS: {
+ *      bundleId: 'com.example.ios'
+ *   },
+ *   android: {
+ *     packageName: 'com.example.android',
+ *     installApp: true,
+ *     minimumVersion: '12'
+ *   },
+ *   handleCodeInApp: true
+ * };
+ * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);
+ * // Obtain emailLink from the user.
+ * if(isSignInWithEmailLink(auth, emailLink)) {
+ *   await signInWithEmailLink(auth, 'user@example.com', emailLink);
+ * }
+ * ```
+ *
+ * @param authInternal - The {@link Auth} instance.
+ * @param email - The user's email address.
+ * @param actionCodeSettings - The {@link ActionCodeSettings}.
+ *
+ * @public
+ */
+export declare function sendSignInLinkToEmail(auth: Auth, email: string, actionCodeSettings: ActionCodeSettings): Promise<void>;
+/**
+ * Checks if an incoming link is a sign-in with email link suitable for {@link signInWithEmailLink}.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param emailLink - The link sent to the user's email address.
+ *
+ * @public
+ */
+export declare function isSignInWithEmailLink(auth: Auth, emailLink: string): boolean;
+/**
+ * Asynchronously signs in using an email and sign-in email link.
+ *
+ * @remarks
+ * If no link is passed, the link is inferred from the current URL.
+ *
+ * Fails with an error if the email address is invalid or OTP in email link expires.
+ *
+ * This method is not supported by {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * Note: Confirm the link is a sign-in email link before calling this method firebase.auth.Auth.isSignInWithEmailLink.
+ *
+ * @example
+ * ```javascript
+ * const actionCodeSettings = {
+ *   url: 'https://www.example.com/?email=user@example.com',
+ *   iOS: {
+ *      bundleId: 'com.example.ios'
+ *   },
+ *   android: {
+ *     packageName: 'com.example.android',
+ *     installApp: true,
+ *     minimumVersion: '12'
+ *   },
+ *   handleCodeInApp: true
+ * };
+ * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);
+ * // Obtain emailLink from the user.
+ * if(isSignInWithEmailLink(auth, emailLink)) {
+ *   await signInWithEmailLink(auth, 'user@example.com', emailLink);
+ * }
+ * ```
+ *
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param email - The user's email address.
+ * @param emailLink - The link sent to the user's email address.
+ *
+ * @public
+ */
+export declare function signInWithEmailLink(auth: Auth, email: string, emailLink?: string): Promise<UserCredential>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/idp.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/idp.d.ts
new file mode 100644
index 0000000..179d4f7
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/idp.d.ts
@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { UserInternal, UserCredentialInternal } from '../../model/user';
+export interface IdpTaskParams {
+    auth: AuthInternal;
+    requestUri: string;
+    sessionId?: string;
+    tenantId?: string;
+    postBody?: string;
+    pendingToken?: string;
+    user?: UserInternal;
+    bypassAuthState?: boolean;
+}
+export type IdpTask = (params: IdpTaskParams) => Promise<UserCredentialInternal>;
+export declare function _signIn(params: IdpTaskParams): Promise<UserCredentialInternal>;
+export declare function _reauth(params: IdpTaskParams): Promise<UserCredentialInternal>;
+export declare function _link(params: IdpTaskParams): Promise<UserCredentialInternal>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/redirect.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/redirect.d.ts
new file mode 100644
index 0000000..10178ef
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/strategies/redirect.d.ts
@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { AuthEvent, PopupRedirectResolverInternal } from '../../model/popup_redirect';
+import { UserCredentialInternal } from '../../model/user';
+import { AbstractPopupRedirectOperation } from './abstract_popup_redirect_operation';
+export declare class RedirectAction extends AbstractPopupRedirectOperation {
+    eventId: null;
+    constructor(auth: AuthInternal, resolver: PopupRedirectResolverInternal, bypassAuthState?: boolean);
+    /**
+     * Override the execute function; if we already have a redirect result, then
+     * just return it.
+     */
+    execute(): Promise<UserCredentialInternal | null>;
+    onAuthEvent(event: AuthEvent): Promise<void>;
+    onExecution(): Promise<void>;
+    cleanUp(): void;
+}
+export declare function _getAndClearPendingRedirectStatus(resolver: PopupRedirectResolverInternal, auth: AuthInternal): Promise<boolean>;
+export declare function _setPendingRedirectStatus(resolver: PopupRedirectResolverInternal, auth: AuthInternal): Promise<void>;
+export declare function _clearRedirectOutcomes(): void;
+export declare function _overrideRedirectResult(auth: AuthInternal, result: () => Promise<UserCredentialInternal | null>): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/account_info.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/account_info.d.ts
new file mode 100644
index 0000000..312e23c
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/account_info.d.ts
@@ -0,0 +1,68 @@
+/**
+ * @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 { User } from '../../model/public_types';
+/**
+ * Updates a user's profile data.
+ *
+ * @param user - The user.
+ * @param profile - The profile's `displayName` and `photoURL` to update.
+ *
+ * @public
+ */
+export declare function updateProfile(user: User, { displayName, photoURL: photoUrl }: {
+    displayName?: string | null;
+    photoURL?: string | null;
+}): Promise<void>;
+/**
+ * Updates the user's email address.
+ *
+ * @remarks
+ * An email will be sent to the original email address (if it was set) that allows to revoke the
+ * email address change, in order to protect them from account hijacking.
+ *
+ * This method is not supported on any {@link User} signed in by {@link Auth} instances
+ * created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * Important: this is a security sensitive operation that requires the user to have recently signed
+ * in. If this requirement isn't met, ask the user to authenticate again and then call
+ * {@link reauthenticateWithCredential}.
+ *
+ * @param user - The user.
+ * @param newEmail - The new email address.
+ *
+ * Throws "auth/operation-not-allowed" error when
+ * {@link https://cloud.google.com/identity-platform/docs/admin/email-enumeration-protection | Email Enumeration Protection}
+ * is enabled.
+ * Deprecated - Use {@link verifyBeforeUpdateEmail} instead.
+ *
+ * @public
+ */
+export declare function updateEmail(user: User, newEmail: string): Promise<void>;
+/**
+ * Updates the user's password.
+ *
+ * @remarks
+ * Important: this is a security sensitive operation that requires the user to have recently signed
+ * in. If this requirement isn't met, ask the user to authenticate again and then call
+ * {@link reauthenticateWithCredential}.
+ *
+ * @param user - The user.
+ * @param newPassword - The new password.
+ *
+ * @public
+ */
+export declare function updatePassword(user: User, newPassword: string): Promise<void>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/additional_user_info.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/additional_user_info.d.ts
new file mode 100644
index 0000000..d5fd65b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/additional_user_info.d.ts
@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AdditionalUserInfo, UserCredential } from '../../model/public_types';
+import { IdTokenResponse } from '../../model/id_token';
+/**
+ * Parse the `AdditionalUserInfo` from the ID token response.
+ *
+ */
+export declare function _fromIdTokenResponse(idTokenResponse?: IdTokenResponse): AdditionalUserInfo | null;
+/**
+ * Extracts provider specific {@link AdditionalUserInfo} for the given credential.
+ *
+ * @param userCredential - The user credential.
+ *
+ * @public
+ */
+export declare function getAdditionalUserInfo(userCredential: UserCredential): AdditionalUserInfo | null;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/id_token_result.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/id_token_result.d.ts
new file mode 100644
index 0000000..c1b2032
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/id_token_result.d.ts
@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { IdTokenResult, ParsedToken, User } from '../../model/public_types';
+/**
+ * Returns a JSON Web Token (JWT) used to identify the user to a Firebase service.
+ *
+ * @remarks
+ * Returns the current token if it has not expired or if it will not expire in the next five
+ * minutes. Otherwise, this will refresh the token and return a new one.
+ *
+ * @param user - The user.
+ * @param forceRefresh - Force refresh regardless of token expiration.
+ *
+ * @public
+ */
+export declare function getIdToken(user: User, forceRefresh?: boolean): Promise<string>;
+/**
+ * Returns a deserialized JSON Web Token (JWT) used to identify the user to a Firebase service.
+ *
+ * @remarks
+ * Returns the current token if it has not expired or if it will not expire in the next five
+ * minutes. Otherwise, this will refresh the token and return a new one.
+ *
+ * @param user - The user.
+ * @param forceRefresh - Force refresh regardless of token expiration.
+ *
+ * @public
+ */
+export declare function getIdTokenResult(user: User, forceRefresh?: boolean): Promise<IdTokenResult>;
+export declare function _parseToken(token: string): ParsedToken | null;
+/**
+ * Extract expiresIn TTL from a token by subtracting the expiration from the issuance.
+ */
+export declare function _tokenExpiresIn(token: string): number;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/invalidation.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/invalidation.d.ts
new file mode 100644
index 0000000..81446ea
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/invalidation.d.ts
@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { UserInternal } from '../../model/user';
+export declare function _logoutIfInvalidated<T>(user: UserInternal, promise: Promise<T>, bypassAuthState?: boolean): Promise<T>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/link_unlink.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/link_unlink.d.ts
new file mode 100644
index 0000000..9408524
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/link_unlink.d.ts
@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { User } from '../../model/public_types';
+import { UserInternal, UserCredentialInternal } from '../../model/user';
+import { AuthCredential } from '../credentials';
+/**
+ * Unlinks a provider from a user account.
+ *
+ * @param user - The user.
+ * @param providerId - The provider to unlink.
+ *
+ * @public
+ */
+export declare function unlink(user: User, providerId: string): Promise<User>;
+export declare function _link(user: UserInternal, credential: AuthCredential, bypassAuthState?: boolean): Promise<UserCredentialInternal>;
+export declare function _assertLinkedStatus(expected: boolean, user: UserInternal, provider: string): Promise<void>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/proactive_refresh.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/proactive_refresh.d.ts
new file mode 100644
index 0000000..ff52286
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/proactive_refresh.d.ts
@@ -0,0 +1,34 @@
+/**
+ * @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 { UserInternal } from '../../model/user';
+export declare const enum Duration {
+    OFFSET = 300000,
+    RETRY_BACKOFF_MIN = 30000,
+    RETRY_BACKOFF_MAX = 960000
+}
+export declare class ProactiveRefresh {
+    private readonly user;
+    private isRunning;
+    private timerId;
+    private errorBackoff;
+    constructor(user: UserInternal);
+    _start(): void;
+    _stop(): void;
+    private getInterval;
+    private schedule;
+    private iteration;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/reauthenticate.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/reauthenticate.d.ts
new file mode 100644
index 0000000..1855132
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/reauthenticate.d.ts
@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { UserInternal } from '../../model/user';
+import { AuthCredential } from '../credentials';
+import { UserCredentialImpl } from './user_credential_impl';
+export declare function _reauthenticate(user: UserInternal, credential: AuthCredential, bypassAuthState?: boolean): Promise<UserCredentialImpl>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/reload.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/reload.d.ts
new file mode 100644
index 0000000..f2690fa
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/reload.d.ts
@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { User, UserInfo } from '../../model/public_types';
+import { ProviderUserInfo } from '../../api/account_management/account';
+import { UserInternal } from '../../model/user';
+export declare function _reloadWithoutSaving(user: UserInternal): Promise<void>;
+/**
+ * Reloads user account data, if signed in.
+ *
+ * @param user - The user.
+ *
+ * @public
+ */
+export declare function reload(user: User): Promise<void>;
+export declare function extractProviderData(providers: ProviderUserInfo[]): UserInfo[];
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/token_manager.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/token_manager.d.ts
new file mode 100644
index 0000000..790e283
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/token_manager.d.ts
@@ -0,0 +1,50 @@
+/**
+ * @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 { FinalizeMfaResponse } from '../../api/authentication/mfa';
+import { AuthInternal } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+import { PersistedBlob } from '../persistence';
+/**
+ * The number of milliseconds before the official expiration time of a token
+ * to refresh that token, to provide a buffer for RPCs to complete.
+ */
+export declare const enum Buffer {
+    TOKEN_REFRESH = 30000
+}
+/**
+ * We need to mark this class as internal explicitly to exclude it in the public typings, because
+ * it references AuthInternal which has a circular dependency with UserInternal.
+ *
+ * @internal
+ */
+export declare class StsTokenManager {
+    refreshToken: string | null;
+    accessToken: string | null;
+    expirationTime: number | null;
+    get isExpired(): boolean;
+    updateFromServerResponse(response: IdTokenResponse | FinalizeMfaResponse): void;
+    updateFromIdToken(idToken: string): void;
+    getToken(auth: AuthInternal, forceRefresh?: boolean): Promise<string | null>;
+    clearRefreshToken(): void;
+    private refresh;
+    private updateTokensAndExpiration;
+    static fromJSON(appName: string, object: PersistedBlob): StsTokenManager;
+    toJSON(): object;
+    _assign(stsTokenManager: StsTokenManager): void;
+    _clone(): StsTokenManager;
+    _performRefresh(): never;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_credential_impl.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_credential_impl.d.ts
new file mode 100644
index 0000000..44ece34
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_credential_impl.d.ts
@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';
+import { IdTokenResponse } from '../../model/id_token';
+import { UserInternal, UserCredentialInternal } from '../../model/user';
+import { AuthInternal } from '../../model/auth';
+import { OperationType, ProviderId } from '../../model/enums';
+interface UserCredentialParams {
+    readonly user: UserInternal;
+    readonly providerId: ProviderId | string | null;
+    readonly _tokenResponse?: PhoneOrOauthTokenResponse;
+    readonly operationType: OperationType;
+}
+export declare class UserCredentialImpl implements UserCredentialInternal, UserCredentialParams {
+    readonly user: UserInternal;
+    readonly providerId: ProviderId | string | null;
+    readonly _tokenResponse: PhoneOrOauthTokenResponse | undefined;
+    readonly operationType: OperationType;
+    constructor(params: UserCredentialParams);
+    static _fromIdTokenResponse(auth: AuthInternal, operationType: OperationType, idTokenResponse: IdTokenResponse, isAnonymous?: boolean): Promise<UserCredentialInternal>;
+    static _forOperation(user: UserInternal, operationType: OperationType, response: PhoneOrOauthTokenResponse): Promise<UserCredentialImpl>;
+}
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_impl.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_impl.d.ts
new file mode 100644
index 0000000..f795111
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_impl.d.ts
@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { IdTokenResult } from '../../model/public_types';
+import { NextFn } from '@firebase/util';
+import { APIUserInfo, GetAccountInfoResponse } from '../../api/account_management/account';
+import { FinalizeMfaResponse } from '../../api/authentication/mfa';
+import { AuthInternal } from '../../model/auth';
+import { IdTokenResponse } from '../../model/id_token';
+import { MutableUserInfo, UserInternal, UserParameters } from '../../model/user';
+import { PersistedBlob } from '../persistence';
+import { StsTokenManager } from './token_manager';
+import { UserMetadata } from './user_metadata';
+import { ProviderId } from '../../model/enums';
+export declare class UserImpl implements UserInternal {
+    readonly providerId = ProviderId.FIREBASE;
+    stsTokenManager: StsTokenManager;
+    private accessToken;
+    uid: string;
+    auth: AuthInternal;
+    emailVerified: boolean;
+    isAnonymous: boolean;
+    tenantId: string | null;
+    readonly metadata: UserMetadata;
+    providerData: MutableUserInfo[];
+    displayName: string | null;
+    email: string | null;
+    phoneNumber: string | null;
+    photoURL: string | null;
+    _redirectEventId?: string;
+    private readonly proactiveRefresh;
+    constructor({ uid, auth, stsTokenManager, ...opt }: UserParameters);
+    getIdToken(forceRefresh?: boolean): Promise<string>;
+    getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
+    reload(): Promise<void>;
+    private reloadUserInfo;
+    private reloadListener;
+    _assign(user: UserInternal): void;
+    _clone(auth: AuthInternal): UserInternal;
+    _onReload(callback: NextFn<APIUserInfo>): void;
+    _notifyReloadListener(userInfo: APIUserInfo): void;
+    _startProactiveRefresh(): void;
+    _stopProactiveRefresh(): void;
+    _updateTokensIfNecessary(response: IdTokenResponse | FinalizeMfaResponse, reload?: boolean): Promise<void>;
+    delete(): Promise<void>;
+    toJSON(): PersistedBlob;
+    get refreshToken(): string;
+    static _fromJSON(auth: AuthInternal, object: PersistedBlob): UserInternal;
+    /**
+     * Initialize a User from an idToken server response
+     * @param auth
+     * @param idTokenResponse
+     */
+    static _fromIdTokenResponse(auth: AuthInternal, idTokenResponse: IdTokenResponse, isAnonymous?: boolean): Promise<UserInternal>;
+    /**
+     * Initialize a User from an idToken server response
+     * @param auth
+     * @param idTokenResponse
+     */
+    static _fromGetAccountInfoResponse(auth: AuthInternal, response: GetAccountInfoResponse, idToken: string): Promise<UserInternal>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_metadata.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_metadata.d.ts
new file mode 100644
index 0000000..c732ce3
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/user/user_metadata.d.ts
@@ -0,0 +1,27 @@
+/**
+ * @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 { UserMetadata as UserMetadataType } from '../../model/public_types';
+export declare class UserMetadata implements UserMetadataType {
+    private createdAt?;
+    private lastLoginAt?;
+    creationTime?: string;
+    lastSignInTime?: string;
+    constructor(createdAt?: (string | number) | undefined, lastLoginAt?: (string | number) | undefined);
+    private _initializeTime;
+    _copy(metadata: UserMetadata): void;
+    toJSON(): object;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/assert.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/assert.d.ts
new file mode 100644
index 0000000..b877b42
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/assert.d.ts
@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Auth } from '../../model/public_types';
+import { FirebaseError } from '@firebase/util';
+import { AuthErrorCode, AuthErrorParams } from '../errors';
+type LessAppName<K extends AuthErrorCode> = Omit<AuthErrorParams[K], 'appName'>;
+/**
+ * Unconditionally fails, throwing a developer facing INTERNAL_ERROR
+ *
+ * @example
+ * ```javascript
+ * fail(auth, AuthErrorCode.MFA_REQUIRED);  // Error: the MFA_REQUIRED error needs more params than appName
+ * fail(auth, AuthErrorCode.MFA_REQUIRED, {serverResponse});  // Compiles
+ * fail(AuthErrorCode.INTERNAL_ERROR);  // Compiles; internal error does not need appName
+ * fail(AuthErrorCode.USER_DELETED);  // Error: USER_DELETED requires app name
+ * fail(auth, AuthErrorCode.USER_DELETED);  // Compiles; USER_DELETED _only_ needs app name
+ * ```
+ *
+ * @param appName App name for tagging the error
+ * @throws FirebaseError
+ */
+export declare function _fail<K extends AuthErrorCode>(code: K, ...data: {} extends AuthErrorParams[K] ? [AuthErrorParams[K]?] : [AuthErrorParams[K]]): never;
+export declare function _fail<K extends AuthErrorCode>(auth: Auth, code: K, ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]): never;
+export declare function _createError<K extends AuthErrorCode>(code: K, ...data: {} extends AuthErrorParams[K] ? [AuthErrorParams[K]?] : [AuthErrorParams[K]]): FirebaseError;
+export declare function _createError<K extends AuthErrorCode>(auth: Auth, code: K, ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]): FirebaseError;
+export declare function _errorWithCustomMessage(auth: Auth, code: AuthErrorCode, message: string): FirebaseError;
+export declare function _serverAppCurrentUserOperationNotSupportedError(auth: Auth): FirebaseError;
+export declare function _assertInstanceOf(auth: Auth, object: object, instance: unknown): void;
+export declare function _assert<K extends AuthErrorCode>(assertion: unknown, code: K, ...data: {} extends AuthErrorParams[K] ? [AuthErrorParams[K]?] : [AuthErrorParams[K]]): asserts assertion;
+export declare function _assert<K extends AuthErrorCode>(assertion: unknown, auth: Auth, code: K, ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]): asserts assertion;
+type TypeExpectation = Function | string | MapType;
+interface MapType extends Record<string, TypeExpectation | Optional> {
+}
+declare class Optional {
+    readonly type: TypeExpectation;
+    constructor(type: TypeExpectation);
+}
+export declare function opt(type: TypeExpectation): Optional;
+/**
+ * Asserts the runtime types of arguments. The 'expected' field can be one of
+ * a class, a string (representing a "typeof" call), or a record map of name
+ * to type. Furthermore, the opt() function can be used to mark a field as
+ * optional. For example:
+ *
+ * function foo(auth: Auth, profile: {displayName?: string}, update = false) {
+ *   assertTypes(arguments, [AuthImpl, {displayName: opt('string')}, opt('boolean')]);
+ * }
+ *
+ * opt() can be used for any type:
+ * function foo(auth?: Auth) {
+ *   assertTypes(arguments, [opt(AuthImpl)]);
+ * }
+ *
+ * The string types can be or'd together, and you can use "null" as well (note
+ * that typeof null === 'object'; this is an edge case). For example:
+ *
+ * function foo(profile: {displayName?: string | null}) {
+ *   assertTypes(arguments, [{displayName: opt('string|null')}]);
+ * }
+ *
+ * @param args
+ * @param expected
+ */
+export declare function assertTypes(args: Omit<IArguments, 'callee'>, ...expected: Array<TypeExpectation | Optional>): void;
+/**
+ * Unconditionally fails, throwing an internal error with the given message.
+ *
+ * @param failure type of failure encountered
+ * @throws Error
+ */
+export declare function debugFail(failure: string): never;
+/**
+ * Fails if the given assertion condition is false, throwing an Error with the
+ * given message if it did.
+ *
+ * @param assertion
+ * @param message
+ */
+export declare function debugAssert(assertion: unknown, message: string): asserts assertion;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/browser.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/browser.d.ts
new file mode 100644
index 0000000..f2abeb6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/browser.d.ts
@@ -0,0 +1,50 @@
+/**
+ * @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.
+ */
+/**
+ * Enums for Browser name.
+ */
+export declare const enum BrowserName {
+    ANDROID = "Android",
+    BLACKBERRY = "Blackberry",
+    EDGE = "Edge",
+    FIREFOX = "Firefox",
+    IE = "IE",
+    IEMOBILE = "IEMobile",
+    OPERA = "Opera",
+    OTHER = "Other",
+    CHROME = "Chrome",
+    SAFARI = "Safari",
+    SILK = "Silk",
+    WEBOS = "Webos"
+}
+/**
+ * Determine the browser for the purposes of reporting usage to the API
+ */
+export declare function _getBrowserName(userAgent: string): BrowserName | string;
+export declare function _isFirefox(ua?: string): boolean;
+export declare function _isSafari(userAgent?: string): boolean;
+export declare function _isChromeIOS(ua?: string): boolean;
+export declare function _isIEMobile(ua?: string): boolean;
+export declare function _isAndroid(ua?: string): boolean;
+export declare function _isBlackBerry(ua?: string): boolean;
+export declare function _isWebOS(ua?: string): boolean;
+export declare function _isIOS(ua?: string): boolean;
+export declare function _isIOS7Or8(ua?: string): boolean;
+export declare function _isIOSStandalone(ua?: string): boolean;
+export declare function _isIE10(): boolean;
+export declare function _isMobileBrowser(ua?: string): boolean;
+export declare function _isIframe(): boolean;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/delay.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/delay.d.ts
new file mode 100644
index 0000000..6358c7e
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/delay.d.ts
@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const enum DelayMin {
+    OFFLINE = 5000
+}
+/**
+ * A structure to help pick between a range of long and short delay durations
+ * depending on the current environment. In general, the long delay is used for
+ * mobile environments whereas short delays are used for desktop environments.
+ */
+export declare class Delay {
+    private readonly shortDelay;
+    private readonly longDelay;
+    private readonly isMobile;
+    constructor(shortDelay: number, longDelay: number);
+    get(): number;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/emulator.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/emulator.d.ts
new file mode 100644
index 0000000..068c50a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/emulator.d.ts
@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ConfigInternal } from '../../model/auth';
+export declare function _emulatorUrl(config: ConfigInternal, path?: string): string;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/event_id.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/event_id.d.ts
new file mode 100644
index 0000000..a235857
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/event_id.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function _generateEventId(prefix?: string, digits?: number): string;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/fetch_provider.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/fetch_provider.d.ts
new file mode 100644
index 0000000..b30fc05
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/fetch_provider.d.ts
@@ -0,0 +1,25 @@
+/**
+ * @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 declare class FetchProvider {
+    private static fetchImpl;
+    private static headersImpl;
+    private static responseImpl;
+    static initialize(fetchImpl: typeof fetch, headersImpl?: typeof Headers, responseImpl?: typeof Response): void;
+    static fetch(): typeof fetch;
+    static headers(): typeof Headers;
+    static response(): typeof Response;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/handler.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/handler.d.ts
new file mode 100644
index 0000000..d5ff063
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/handler.d.ts
@@ -0,0 +1,20 @@
+/**
+ * @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 { AuthProvider } from '../../model/public_types';
+import { AuthInternal } from '../../model/auth';
+import { AuthEventType } from '../../model/popup_redirect';
+export declare function _getRedirectUrl(auth: AuthInternal, provider: AuthProvider, authType: AuthEventType, redirectUrl?: string, eventId?: string, additionalParams?: Record<string, string>): Promise<string>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/instantiator.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/instantiator.d.ts
new file mode 100644
index 0000000..33e7c95
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/instantiator.d.ts
@@ -0,0 +1,28 @@
+/**
+ * @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.
+ */
+/**
+ * Our API has a lot of one-off constants that are used to do things.
+ * Unfortunately we can't export these as classes instantiated directly since
+ * the constructor may side effect and therefore can't be proven to be safely
+ * culled. Instead, we export these classes themselves as a lowerCamelCase
+ * constant, and instantiate them under the hood.
+ */
+export interface SingletonInstantiator<T> {
+    new (): T;
+}
+export declare function _getInstance<T>(cls: unknown): T;
+export declare function _clearInstanceMap(): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/location.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/location.d.ts
new file mode 100644
index 0000000..c79ac38
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/location.d.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function _getCurrentUrl(): string;
+export declare function _isHttpOrHttps(): boolean;
+export declare function _getCurrentScheme(): string | null;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/log.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/log.d.ts
new file mode 100644
index 0000000..b65ea5c
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/log.d.ts
@@ -0,0 +1,23 @@
+/**
+ * @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 { LogLevel } from '@firebase/logger';
+export { LogLevel };
+export declare function _getLogLevel(): LogLevel;
+export declare function _setLogLevel(newLevel: LogLevel): void;
+export declare function _logDebug(msg: string, ...args: string[]): void;
+export declare function _logWarn(msg: string, ...args: string[]): void;
+export declare function _logError(msg: string, ...args: string[]): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/navigator.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/navigator.d.ts
new file mode 100644
index 0000000..ac91633
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/navigator.d.ts
@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Determine whether the browser is working online
+ */
+export declare function _isOnline(): boolean;
+export declare function _getUserLanguage(): string | null;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/providers.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/providers.d.ts
new file mode 100644
index 0000000..c2ffdb3
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/providers.d.ts
@@ -0,0 +1,23 @@
+/**
+ * @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 interface ProviderAssociatedObject {
+    providerId?: string;
+}
+/**
+ * Takes a set of UserInfo provider data and converts it to a set of names
+ */
+export declare function providerDataAsNames<T extends ProviderAssociatedObject>(providerData: T[]): Set<string>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/resolver.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/resolver.d.ts
new file mode 100644
index 0000000..e7c2c7c
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/resolver.d.ts
@@ -0,0 +1,25 @@
+/**
+ * @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 { PopupRedirectResolver } from '../../model/public_types';
+import { AuthInternal } from '../../model/auth';
+import { PopupRedirectResolverInternal } from '../../model/popup_redirect';
+/**
+ * Chooses a popup/redirect resolver to use. This prefers the override (which
+ * is directly passed in), and falls back to the property set on the auth
+ * object. If neither are available, this function errors w/ an argument error.
+ */
+export declare function _withDefaultResolver(auth: AuthInternal, resolverOverride: PopupRedirectResolver | undefined): PopupRedirectResolverInternal;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/time.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/time.d.ts
new file mode 100644
index 0000000..d82976e
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/time.d.ts
@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function utcTimestampToDateString(utcTimestamp?: string | number): string | undefined;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/validate_origin.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/validate_origin.d.ts
new file mode 100644
index 0000000..dde89b0
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/validate_origin.d.ts
@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+export declare function _validateOrigin(auth: AuthInternal): Promise<void>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/core/util/version.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/version.d.ts
new file mode 100644
index 0000000..342ceb5
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/core/util/version.d.ts
@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const enum ClientImplementation {
+    CORE = "JsCore"
+}
+/**
+ * @internal
+ */
+export declare const enum ClientPlatform {
+    BROWSER = "Browser",
+    NODE = "Node",
+    REACT_NATIVE = "ReactNative",
+    CORDOVA = "Cordova",
+    WORKER = "Worker",
+    WEB_EXTENSION = "WebExtension"
+}
+export declare function _getClientVersion(clientPlatform: ClientPlatform, frameworks?: readonly string[]): string;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/index.d.ts
new file mode 100644
index 0000000..4b71927
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/index.d.ts
@@ -0,0 +1,18 @@
+/**
+ * @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.
+ */
+export * from './core';
+export * from './mfa';
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/assertions/totp.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/assertions/totp.d.ts
new file mode 100644
index 0000000..6b6df19
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/assertions/totp.d.ts
@@ -0,0 +1,124 @@
+/**
+ * @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 { TotpMultiFactorAssertion, MultiFactorSession } from '../../model/public_types';
+import { AuthInternal } from '../../model/auth';
+import { StartTotpMfaEnrollmentResponse, TotpVerificationInfo } from '../../api/account_management/mfa';
+import { FinalizeMfaResponse } from '../../api/authentication/mfa';
+import { MultiFactorAssertionImpl } from '../../mfa/mfa_assertion';
+/**
+ * Provider for generating a {@link TotpMultiFactorAssertion}.
+ *
+ * @public
+ */
+export declare class TotpMultiFactorGenerator {
+    /**
+     * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of
+     * the TOTP (time-based one-time password) second factor.
+     * This assertion is used to complete enrollment in TOTP second factor.
+     *
+     * @param secret A {@link TotpSecret} containing the shared secret key and other TOTP parameters.
+     * @param oneTimePassword One-time password from TOTP App.
+     * @returns A {@link TotpMultiFactorAssertion} which can be used with
+     * {@link MultiFactorUser.enroll}.
+     */
+    static assertionForEnrollment(secret: TotpSecret, oneTimePassword: string): TotpMultiFactorAssertion;
+    /**
+     * Provides a {@link TotpMultiFactorAssertion} to confirm ownership of the TOTP second factor.
+     * This assertion is used to complete signIn with TOTP as the second factor.
+     *
+     * @param enrollmentId identifies the enrolled TOTP second factor.
+     * @param oneTimePassword One-time password from TOTP App.
+     * @returns A {@link TotpMultiFactorAssertion} which can be used with
+     * {@link MultiFactorResolver.resolveSignIn}.
+     */
+    static assertionForSignIn(enrollmentId: string, oneTimePassword: string): TotpMultiFactorAssertion;
+    /**
+     * Returns a promise to {@link TotpSecret} which contains the TOTP shared secret key and other parameters.
+     * Creates a TOTP secret as part of enrolling a TOTP second factor.
+     * Used for generating a QR code URL or inputting into a TOTP app.
+     * This method uses the auth instance corresponding to the user in the multiFactorSession.
+     *
+     * @param session The {@link MultiFactorSession} that the user is part of.
+     * @returns A promise to {@link TotpSecret}.
+     */
+    static generateSecret(session: MultiFactorSession): Promise<TotpSecret>;
+    /**
+     * The identifier of the TOTP second factor: `totp`.
+     */
+    static FACTOR_ID: 'totp';
+}
+export declare class TotpMultiFactorAssertionImpl extends MultiFactorAssertionImpl implements TotpMultiFactorAssertion {
+    readonly otp: string;
+    readonly enrollmentId?: string | undefined;
+    readonly secret?: TotpSecret | undefined;
+    constructor(otp: string, enrollmentId?: string | undefined, secret?: TotpSecret | undefined);
+    /** @internal */
+    static _fromSecret(secret: TotpSecret, otp: string): TotpMultiFactorAssertionImpl;
+    /** @internal */
+    static _fromEnrollmentId(enrollmentId: string, otp: string): TotpMultiFactorAssertionImpl;
+    /** @internal */
+    _finalizeEnroll(auth: AuthInternal, idToken: string, displayName?: string | null): Promise<FinalizeMfaResponse>;
+    /** @internal */
+    _finalizeSignIn(auth: AuthInternal, mfaPendingCredential: string): Promise<FinalizeMfaResponse>;
+}
+/**
+ * Provider for generating a {@link TotpMultiFactorAssertion}.
+ *
+ * Stores the shared secret key and other parameters to generate time-based OTPs.
+ * Implements methods to retrieve the shared secret key and generate a QR code URL.
+ * @public
+ */
+export declare class TotpSecret {
+    private readonly sessionInfo;
+    private readonly auth;
+    /**
+     * Shared secret key/seed used for enrolling in TOTP MFA and generating OTPs.
+     */
+    readonly secretKey: string;
+    /**
+     * Hashing algorithm used.
+     */
+    readonly hashingAlgorithm: string;
+    /**
+     * Length of the one-time passwords to be generated.
+     */
+    readonly codeLength: number;
+    /**
+     * The interval (in seconds) when the OTP codes should change.
+     */
+    readonly codeIntervalSeconds: number;
+    /**
+     * The timestamp (UTC string) by which TOTP enrollment should be completed.
+     */
+    readonly enrollmentCompletionDeadline: string;
+    private constructor();
+    /** @internal */
+    static _fromStartTotpMfaEnrollmentResponse(response: StartTotpMfaEnrollmentResponse, auth: AuthInternal): TotpSecret;
+    /** @internal */
+    _makeTotpVerificationInfo(otp: string): TotpVerificationInfo;
+    /**
+     * Returns a QR code URL as described in
+     * https://github.com/google/google-authenticator/wiki/Key-Uri-Format
+     * This can be displayed to the user as a QR code to be scanned into a TOTP app like Google Authenticator.
+     * If the optional parameters are unspecified, an accountName of <userEmail> and issuer of <firebaseAppName> are used.
+     *
+     * @param accountName the name of the account/app along with a user identifier.
+     * @param issuer issuer of the TOTP (likely the app name).
+     * @returns A QR code URL string.
+     */
+    generateQrCodeUrl(accountName?: string, issuer?: string): string;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/index.d.ts
new file mode 100644
index 0000000..c976896
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/index.d.ts
@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { getMultiFactorResolver } from './mfa_resolver';
+export { multiFactor } from './mfa_user';
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_assertion.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_assertion.d.ts
new file mode 100644
index 0000000..ab9d4fb
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_assertion.d.ts
@@ -0,0 +1,27 @@
+/**
+ * @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 { FactorId, MultiFactorAssertion } from '../model/public_types';
+import { MultiFactorSessionImpl } from './mfa_session';
+import { FinalizeMfaResponse } from '../api/authentication/mfa';
+import { AuthInternal } from '../model/auth';
+export declare abstract class MultiFactorAssertionImpl implements MultiFactorAssertion {
+    readonly factorId: FactorId;
+    protected constructor(factorId: FactorId);
+    _process(auth: AuthInternal, session: MultiFactorSessionImpl, displayName?: string | null): Promise<FinalizeMfaResponse>;
+    abstract _finalizeEnroll(auth: AuthInternal, idToken: string, displayName?: string | null): Promise<FinalizeMfaResponse>;
+    abstract _finalizeSignIn(auth: AuthInternal, mfaPendingCredential: string): Promise<FinalizeMfaResponse>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_error.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_error.d.ts
new file mode 100644
index 0000000..d6b719c
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_error.d.ts
@@ -0,0 +1,35 @@
+/**
+ * @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 { MultiFactorError as MultiFactorErrorPublic } from '../model/public_types';
+import { FirebaseError } from '@firebase/util';
+import { AuthInternal } from '../model/auth';
+import { IdTokenResponse } from '../model/id_token';
+import { UserInternal } from '../model/user';
+import { AuthCredential } from '../core/credentials';
+import { IdTokenMfaResponse } from '../api/authentication/mfa';
+import { OperationType } from '../model/enums';
+export type MultiFactorErrorData = MultiFactorErrorPublic['customData'] & {
+    _serverResponse: IdTokenMfaResponse;
+};
+export declare class MultiFactorError extends FirebaseError implements MultiFactorErrorPublic {
+    readonly operationType: OperationType;
+    readonly user?: UserInternal | undefined;
+    readonly customData: MultiFactorErrorData;
+    private constructor();
+    static _fromErrorAndOperation(auth: AuthInternal, error: FirebaseError, operationType: OperationType, user?: UserInternal): MultiFactorError;
+}
+export declare function _processCredentialSavingMfaContextIfNecessary(auth: AuthInternal, operationType: OperationType, credential: AuthCredential, user?: UserInternal): Promise<IdTokenResponse>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_info.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_info.d.ts
new file mode 100644
index 0000000..49888fd
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_info.d.ts
@@ -0,0 +1,36 @@
+/**
+ * @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 { FactorId, MultiFactorInfo, PhoneMultiFactorInfo, TotpMultiFactorInfo } from '../model/public_types';
+import { MfaEnrollment } from '../api/account_management/mfa';
+import { AuthInternal } from '../model/auth';
+export declare abstract class MultiFactorInfoImpl implements MultiFactorInfo {
+    readonly factorId: FactorId;
+    readonly uid: string;
+    readonly displayName?: string | null;
+    readonly enrollmentTime: string;
+    protected constructor(factorId: FactorId, response: MfaEnrollment);
+    static _fromServerResponse(auth: AuthInternal, enrollment: MfaEnrollment): MultiFactorInfoImpl;
+}
+export declare class PhoneMultiFactorInfoImpl extends MultiFactorInfoImpl implements PhoneMultiFactorInfo {
+    readonly phoneNumber: string;
+    private constructor();
+    static _fromServerResponse(_auth: AuthInternal, enrollment: MfaEnrollment): PhoneMultiFactorInfoImpl;
+}
+export declare class TotpMultiFactorInfoImpl extends MultiFactorInfoImpl implements TotpMultiFactorInfo {
+    private constructor();
+    static _fromServerResponse(_auth: AuthInternal, enrollment: MfaEnrollment): TotpMultiFactorInfoImpl;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_resolver.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_resolver.d.ts
new file mode 100644
index 0000000..edf54ed
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_resolver.d.ts
@@ -0,0 +1,41 @@
+/**
+ * @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 { Auth, MultiFactorResolver, UserCredential, MultiFactorError } from '../model/public_types';
+import { MultiFactorAssertionImpl } from './mfa_assertion';
+import { MultiFactorError as MultiFactorErrorInternal } from './mfa_error';
+import { MultiFactorInfoImpl } from './mfa_info';
+import { MultiFactorSessionImpl } from './mfa_session';
+export declare class MultiFactorResolverImpl implements MultiFactorResolver {
+    readonly session: MultiFactorSessionImpl;
+    readonly hints: MultiFactorInfoImpl[];
+    private readonly signInResolver;
+    private constructor();
+    /** @internal */
+    static _fromError(authExtern: Auth, error: MultiFactorErrorInternal): MultiFactorResolverImpl;
+    resolveSignIn(assertionExtern: MultiFactorAssertionImpl): Promise<UserCredential>;
+}
+/**
+ * Provides a {@link MultiFactorResolver} suitable for completion of a
+ * multi-factor flow.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param error - The {@link MultiFactorError} raised during a sign-in, or
+ * reauthentication operation.
+ *
+ * @public
+ */
+export declare function getMultiFactorResolver(auth: Auth, error: MultiFactorError): MultiFactorResolver;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_session.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_session.d.ts
new file mode 100644
index 0000000..a144670
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_session.d.ts
@@ -0,0 +1,39 @@
+/**
+ * @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 { UserInternal } from '../model/user';
+import { MultiFactorSession } from '../model/public_types';
+export declare const enum MultiFactorSessionType {
+    ENROLL = "enroll",
+    SIGN_IN = "signin"
+}
+interface SerializedMultiFactorSession {
+    multiFactorSession: {
+        idToken?: string;
+        pendingCredential?: string;
+    };
+}
+export declare class MultiFactorSessionImpl implements MultiFactorSession {
+    readonly type: MultiFactorSessionType;
+    readonly credential: string;
+    readonly user?: UserInternal | undefined;
+    private constructor();
+    static _fromIdtoken(idToken: string, user?: UserInternal): MultiFactorSessionImpl;
+    static _fromMfaPendingCredential(mfaPendingCredential: string): MultiFactorSessionImpl;
+    toJSON(): SerializedMultiFactorSession;
+    static fromJSON(obj: Partial<SerializedMultiFactorSession>): MultiFactorSessionImpl | null;
+}
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_user.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_user.d.ts
new file mode 100644
index 0000000..4850e26
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/mfa/mfa_user.d.ts
@@ -0,0 +1,38 @@
+/**
+ * @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 { MultiFactorAssertion, MultiFactorInfo, MultiFactorSession, MultiFactorUser, User } from '../model/public_types';
+import { UserInternal } from '../model/user';
+export declare class MultiFactorUserImpl implements MultiFactorUser {
+    readonly user: UserInternal;
+    enrolledFactors: MultiFactorInfo[];
+    private constructor();
+    static _fromUser(user: UserInternal): MultiFactorUserImpl;
+    getSession(): Promise<MultiFactorSession>;
+    enroll(assertionExtern: MultiFactorAssertion, displayName?: string | null): Promise<void>;
+    unenroll(infoOrUid: MultiFactorInfo | string): Promise<void>;
+}
+/**
+ * The {@link MultiFactorUser} corresponding to the user.
+ *
+ * @remarks
+ * This is used to access all multi-factor properties and operations related to the user.
+ *
+ * @param user - The user.
+ *
+ * @public
+ */
+export declare function multiFactor(user: User): MultiFactorUser;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/application_verifier.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/application_verifier.d.ts
new file mode 100644
index 0000000..fc6dca5
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/application_verifier.d.ts
@@ -0,0 +1,23 @@
+/**
+ * @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 { ApplicationVerifier } from './public_types';
+export interface ApplicationVerifierInternal extends ApplicationVerifier {
+    /**
+     * @internal
+     */
+    _reset(): void;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/auth.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/auth.d.ts
new file mode 100644
index 0000000..986054b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/auth.d.ts
@@ -0,0 +1,90 @@
+/**
+ * @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 { Auth, AuthSettings, Config, EmulatorConfig, PasswordPolicy, PasswordValidationStatus, PopupRedirectResolver, User } from './public_types';
+import { ErrorFactory } from '@firebase/util';
+import { AuthErrorCode, AuthErrorParams } from '../core/errors';
+import { PopupRedirectResolverInternal } from './popup_redirect';
+import { UserInternal } from './user';
+import { ClientPlatform } from '../core/util/version';
+import { RecaptchaConfig } from '../platform_browser/recaptcha/recaptcha';
+import { PasswordPolicyInternal } from './password_policy';
+import { PersistenceInternal } from '../core/persistence';
+export type AppName = string;
+export type ApiKey = string;
+export type AuthDomain = string;
+/**
+ * @internal
+ */
+export interface ConfigInternal extends Config {
+    /**
+     * @readonly
+     */
+    emulator?: {
+        url: string;
+    };
+    /**
+     * @readonly
+     */
+    clientPlatform: ClientPlatform;
+}
+/**
+ * UserInternal and AuthInternal reference each other, so both of them are included in the public typings.
+ * In order to exclude them, we mark them as internal explicitly.
+ *
+ * @internal
+ */
+export interface AuthInternal extends Auth {
+    currentUser: User | null;
+    emulatorConfig: EmulatorConfig | null;
+    _agentRecaptchaConfig: RecaptchaConfig | null;
+    _tenantRecaptchaConfigs: Record<string, RecaptchaConfig>;
+    _projectPasswordPolicy: PasswordPolicy | null;
+    _tenantPasswordPolicies: Record<string, PasswordPolicy>;
+    _canInitEmulator: boolean;
+    _isInitialized: boolean;
+    _initializationPromise: Promise<void> | null;
+    _persistenceManagerAvailable: Promise<void>;
+    _updateCurrentUser(user: UserInternal | null): Promise<void>;
+    _onStorageEvent(): void;
+    _notifyListenersIfCurrent(user: UserInternal): void;
+    _persistUserIfCurrent(user: UserInternal): Promise<void>;
+    _setRedirectUser(user: UserInternal | null, popupRedirectResolver?: PopupRedirectResolver): Promise<void>;
+    _redirectUserForId(id: string): Promise<UserInternal | null>;
+    _popupRedirectResolver: PopupRedirectResolverInternal | null;
+    _key(): string;
+    _startProactiveRefresh(): void;
+    _stopProactiveRefresh(): void;
+    _getPersistenceType(): string;
+    _getPersistence(): PersistenceInternal;
+    _getRecaptchaConfig(): RecaptchaConfig | null;
+    _getPasswordPolicyInternal(): PasswordPolicyInternal | null;
+    _updatePasswordPolicy(): Promise<void>;
+    _logFramework(framework: string): void;
+    _getFrameworks(): readonly string[];
+    _getAdditionalHeaders(): Promise<Record<string, string>>;
+    _getAppCheckToken(): Promise<string | undefined>;
+    readonly name: AppName;
+    readonly config: ConfigInternal;
+    languageCode: string | null;
+    tenantId: string | null;
+    readonly settings: AuthSettings;
+    _errorFactory: ErrorFactory<AuthErrorCode, AuthErrorParams>;
+    useDeviceLanguage(): void;
+    signOut(): Promise<void>;
+    validatePassword(password: string): Promise<PasswordValidationStatus>;
+    revokeAccessToken(token: string): Promise<void>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/enum_maps.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/enum_maps.d.ts
new file mode 100644
index 0000000..60095b5
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/enum_maps.d.ts
@@ -0,0 +1,98 @@
+/**
+ * @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.
+ */
+/**
+ * An enum of factors that may be used for multifactor authentication.
+ *
+ * @public
+ */
+export declare const FactorId: {
+    /** Phone as second factor */
+    readonly PHONE: "phone";
+    readonly TOTP: "totp";
+};
+/**
+ * Enumeration of supported providers.
+ *
+ * @public
+ */
+export declare const ProviderId: {
+    /** Facebook provider ID */
+    readonly FACEBOOK: "facebook.com";
+    /** GitHub provider ID */
+    readonly GITHUB: "github.com";
+    /** Google provider ID */
+    readonly GOOGLE: "google.com";
+    /** Password provider */
+    readonly PASSWORD: "password";
+    /** Phone provider */
+    readonly PHONE: "phone";
+    /** Twitter provider ID */
+    readonly TWITTER: "twitter.com";
+};
+/**
+ * Enumeration of supported sign-in methods.
+ *
+ * @public
+ */
+export declare const SignInMethod: {
+    /** Email link sign in method */
+    readonly EMAIL_LINK: "emailLink";
+    /** Email/password sign in method */
+    readonly EMAIL_PASSWORD: "password";
+    /** Facebook sign in method */
+    readonly FACEBOOK: "facebook.com";
+    /** GitHub sign in method */
+    readonly GITHUB: "github.com";
+    /** Google sign in method */
+    readonly GOOGLE: "google.com";
+    /** Phone sign in method */
+    readonly PHONE: "phone";
+    /** Twitter sign in method */
+    readonly TWITTER: "twitter.com";
+};
+/**
+ * Enumeration of supported operation types.
+ *
+ * @public
+ */
+export declare const OperationType: {
+    /** Operation involving linking an additional provider to an already signed-in user. */
+    readonly LINK: "link";
+    /** Operation involving using a provider to reauthenticate an already signed-in user. */
+    readonly REAUTHENTICATE: "reauthenticate";
+    /** Operation involving signing in a user. */
+    readonly SIGN_IN: "signIn";
+};
+/**
+ * An enumeration of the possible email action types.
+ *
+ * @public
+ */
+export declare const ActionCodeOperation: {
+    /** The email link sign-in action. */
+    readonly EMAIL_SIGNIN: "EMAIL_SIGNIN";
+    /** The password reset action. */
+    readonly PASSWORD_RESET: "PASSWORD_RESET";
+    /** The email revocation action. */
+    readonly RECOVER_EMAIL: "RECOVER_EMAIL";
+    /** The revert second factor addition email action. */
+    readonly REVERT_SECOND_FACTOR_ADDITION: "REVERT_SECOND_FACTOR_ADDITION";
+    /** The revert second factor addition email action. */
+    readonly VERIFY_AND_CHANGE_EMAIL: "VERIFY_AND_CHANGE_EMAIL";
+    /** The email verification action. */
+    readonly VERIFY_EMAIL: "VERIFY_EMAIL";
+};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/enums.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/enums.d.ts
new file mode 100644
index 0000000..a917e14
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/enums.d.ts
@@ -0,0 +1,74 @@
+/**
+ * @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.
+ */
+/**
+ * Enumeration of supported providers.
+ * @internal
+ */
+export declare const enum ProviderId {
+    /** @internal */
+    ANONYMOUS = "anonymous",
+    /** @internal */
+    CUSTOM = "custom",
+    /** Facebook provider ID */
+    FACEBOOK = "facebook.com",
+    /** @internal */
+    FIREBASE = "firebase",
+    /** GitHub provider ID */
+    GITHUB = "github.com",
+    /** Google provider ID */
+    GOOGLE = "google.com",
+    /** Password provider */
+    PASSWORD = "password",
+    /** Phone provider */
+    PHONE = "phone",
+    /** Twitter provider ID */
+    TWITTER = "twitter.com"
+}
+/**
+ * Enumeration of supported sign-in methods.
+ * @internal
+ */
+export declare const enum SignInMethod {
+    /** @internal */
+    ANONYMOUS = "anonymous",
+    /** Email link sign in method */
+    EMAIL_LINK = "emailLink",
+    /** Email/password sign in method */
+    EMAIL_PASSWORD = "password",
+    /** Facebook sign in method */
+    FACEBOOK = "facebook.com",
+    /** GitHub sign in method */
+    GITHUB = "github.com",
+    /** Google sign in method */
+    GOOGLE = "google.com",
+    /** Phone sign in method */
+    PHONE = "phone",
+    /** Twitter sign in method */
+    TWITTER = "twitter.com"
+}
+/**
+ * Enumeration of supported operation types.
+ * @internal
+ */
+export declare const enum OperationType {
+    /** Operation involving linking an additional provider to an already signed-in user. */
+    LINK = "link",
+    /** Operation involving using a provider to reauthenticate an already signed-in user. */
+    REAUTHENTICATE = "reauthenticate",
+    /** Operation involving signing in a user. */
+    SIGN_IN = "signIn"
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/id_token.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/id_token.d.ts
new file mode 100644
index 0000000..b288dcf
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/id_token.d.ts
@@ -0,0 +1,87 @@
+/**
+ * @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 { PhoneOrOauthTokenResponse } from '../api/authentication/mfa';
+/**
+ * Raw encoded JWT
+ *
+ */
+export type IdToken = string;
+/**
+ * Raw parsed JWT
+ *
+ */
+export interface ParsedIdToken {
+    iss: string;
+    aud: string;
+    exp: number;
+    sub: string;
+    iat: number;
+    email?: string;
+    verified: boolean;
+    providerId?: string;
+    tenantId?: string;
+    anonymous: boolean;
+    federatedId?: string;
+    displayName?: string;
+    photoURL?: string;
+    toString(): string;
+}
+/**
+ * IdToken as returned by the API
+ *
+ * @internal
+ */
+export interface IdTokenResponse {
+    localId: string;
+    idToken?: IdToken;
+    refreshToken?: string;
+    expiresIn?: string;
+    providerId?: string;
+    displayName?: string | null;
+    isNewUser?: boolean;
+    kind?: IdTokenResponseKind;
+    photoUrl?: string | null;
+    rawUserInfo?: string;
+    screenName?: string | null;
+}
+/**
+ * The possible types of the `IdTokenResponse`
+ *
+ * @internal
+ */
+export declare const enum IdTokenResponseKind {
+    CreateAuthUri = "identitytoolkit#CreateAuthUriResponse",
+    DeleteAccount = "identitytoolkit#DeleteAccountResponse",
+    DownloadAccount = "identitytoolkit#DownloadAccountResponse",
+    EmailLinkSignin = "identitytoolkit#EmailLinkSigninResponse",
+    GetAccountInfo = "identitytoolkit#GetAccountInfoResponse",
+    GetOobConfirmationCode = "identitytoolkit#GetOobConfirmationCodeResponse",
+    GetRecaptchaParam = "identitytoolkit#GetRecaptchaParamResponse",
+    ResetPassword = "identitytoolkit#ResetPasswordResponse",
+    SetAccountInfo = "identitytoolkit#SetAccountInfoResponse",
+    SignupNewUser = "identitytoolkit#SignupNewUserResponse",
+    UploadAccount = "identitytoolkit#UploadAccountResponse",
+    VerifyAssertion = "identitytoolkit#VerifyAssertionResponse",
+    VerifyCustomToken = "identitytoolkit#VerifyCustomTokenResponse",
+    VerifyPassword = "identitytoolkit#VerifyPasswordResponse"
+}
+/**
+ * @internal
+ */
+export interface TaggedWithTokenResponse {
+    _tokenResponse?: PhoneOrOauthTokenResponse;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/password_policy.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/password_policy.d.ts
new file mode 100644
index 0000000..0a438d2
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/password_policy.d.ts
@@ -0,0 +1,111 @@
+/**
+ * @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 { PasswordPolicy, PasswordValidationStatus } from './public_types';
+/**
+ * Internal typing of password policy that includes the schema version and methods for
+ * validating that a password meets the policy. The developer does not need access to
+ * these properties and methods, so they are excluded from the public typing.
+ *
+ * @internal
+ */
+export interface PasswordPolicyInternal extends PasswordPolicy {
+    /**
+     * Requirements enforced by the password policy.
+     */
+    readonly customStrengthOptions: PasswordPolicyCustomStrengthOptions;
+    /**
+     * Schema version of the password policy.
+     */
+    readonly schemaVersion: number;
+    /**
+     * Validates the password against the policy.
+     * @param password Password to validate.
+     */
+    validatePassword(password: string): PasswordValidationStatus;
+}
+/**
+ * Internal typing of the password policy custom strength options that is modifiable. This
+ * allows us to construct the strength options before storing them in the policy.
+ *
+ * @internal
+ */
+export interface PasswordPolicyCustomStrengthOptions {
+    /**
+     * Minimum password length.
+     */
+    minPasswordLength?: number;
+    /**
+     * Maximum password length.
+     */
+    maxPasswordLength?: number;
+    /**
+     * Whether the password should contain a lowercase letter.
+     */
+    containsLowercaseLetter?: boolean;
+    /**
+     * Whether the password should contain an uppercase letter.
+     */
+    containsUppercaseLetter?: boolean;
+    /**
+     * Whether the password should contain a numeric character.
+     */
+    containsNumericCharacter?: boolean;
+    /**
+     * Whether the password should contain a non-alphanumeric character.
+     */
+    containsNonAlphanumericCharacter?: boolean;
+}
+/**
+ * Internal typing of password validation status that is modifiable. This allows us to
+ * construct the validation status before returning it.
+ *
+ * @internal
+ */
+export interface PasswordValidationStatusInternal extends PasswordValidationStatus {
+    /**
+     * Whether the password meets all requirements.
+     */
+    isValid: boolean;
+    /**
+     * Whether the password meets the minimum password length.
+     */
+    meetsMinPasswordLength?: boolean;
+    /**
+     * Whether the password meets the maximum password length.
+     */
+    meetsMaxPasswordLength?: boolean;
+    /**
+     * Whether the password contains a lowercase letter, if required.
+     */
+    containsLowercaseLetter?: boolean;
+    /**
+     * Whether the password contains an uppercase letter, if required.
+     */
+    containsUppercaseLetter?: boolean;
+    /**
+     * Whether the password contains a numeric character, if required.
+     */
+    containsNumericCharacter?: boolean;
+    /**
+     * Whether the password contains a non-alphanumeric character, if required.
+     */
+    containsNonAlphanumericCharacter?: boolean;
+    /**
+     * The policy used to validate the password.
+     */
+    passwordPolicy: PasswordPolicy;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/popup_redirect.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/popup_redirect.d.ts
new file mode 100644
index 0000000..1ed2872
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/popup_redirect.d.ts
@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Auth, AuthProvider, Persistence, PopupRedirectResolver, UserCredential } from './public_types';
+import { FirebaseError } from '@firebase/util';
+import { AuthPopup } from '../platform_browser/util/popup';
+import { AuthInternal } from './auth';
+import { UserCredentialInternal } from './user';
+export declare const enum EventFilter {
+    POPUP = 0,
+    REDIRECT = 1
+}
+export declare const enum GapiOutcome {
+    ACK = "ACK",
+    ERROR = "ERROR"
+}
+export interface GapiAuthEvent extends gapi.iframes.Message {
+    authEvent: AuthEvent;
+}
+/**
+ * @internal
+ */
+export declare const enum AuthEventType {
+    LINK_VIA_POPUP = "linkViaPopup",
+    LINK_VIA_REDIRECT = "linkViaRedirect",
+    REAUTH_VIA_POPUP = "reauthViaPopup",
+    REAUTH_VIA_REDIRECT = "reauthViaRedirect",
+    SIGN_IN_VIA_POPUP = "signInViaPopup",
+    SIGN_IN_VIA_REDIRECT = "signInViaRedirect",
+    UNKNOWN = "unknown",
+    VERIFY_APP = "verifyApp"
+}
+export interface AuthEventError extends Error {
+    code: string;
+    message: string;
+}
+/**
+ * @internal
+ */
+export interface AuthEvent {
+    type: AuthEventType;
+    eventId: string | null;
+    urlResponse: string | null;
+    sessionId: string | null;
+    postBody: string | null;
+    tenantId: string | null;
+    error?: AuthEventError;
+}
+/**
+ * @internal
+ */
+export interface AuthEventConsumer {
+    readonly filter: AuthEventType[];
+    eventId: string | null;
+    onAuthEvent(event: AuthEvent): unknown;
+    onError(error: FirebaseError): unknown;
+}
+/**
+ * @internal
+ */
+export interface EventManager {
+    registerConsumer(authEventConsumer: AuthEventConsumer): void;
+    unregisterConsumer(authEventConsumer: AuthEventConsumer): void;
+}
+/**
+ * We need to mark this interface as internal explicitly to exclude it in the public typings, because
+ * it references AuthInternal which has a circular dependency with UserInternal.
+ *
+ * @internal
+ */
+export interface PopupRedirectResolverInternal extends PopupRedirectResolver {
+    _shouldInitProactively: boolean;
+    _initialize(auth: AuthInternal): Promise<EventManager>;
+    _openPopup(auth: AuthInternal, provider: AuthProvider, authType: AuthEventType, eventId?: string): Promise<AuthPopup>;
+    _openRedirect(auth: AuthInternal, provider: AuthProvider, authType: AuthEventType, eventId?: string): Promise<void | never>;
+    _isIframeWebStorageSupported(auth: AuthInternal, cb: (support: boolean) => unknown): void;
+    _redirectPersistence: Persistence;
+    _originValidation(auth: Auth): Promise<void>;
+    _completeRedirectFn: (auth: Auth, resolver: PopupRedirectResolver, bypassAuthState: boolean) => Promise<UserCredential | null>;
+    _overrideRedirectResult: (auth: AuthInternal, resultGetter: () => Promise<UserCredentialInternal | null>) => void;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/public_types.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/public_types.d.ts
new file mode 100644
index 0000000..d1600ce
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/public_types.d.ts
@@ -0,0 +1,1291 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FirebaseApp } from '@firebase/app';
+import { CompleteFn, ErrorFn, FirebaseError, NextFn, Observer, Unsubscribe } from '@firebase/util';
+import { FactorId as FactorIdMap, OperationType as OperationTypeMap, ActionCodeOperation as ActionCodeOperationMap } from './enum_maps';
+export { CompleteFn, ErrorFn, NextFn, Unsubscribe };
+/**
+ * Interface representing the `Auth` config.
+ *
+ * @public
+ */
+export interface Config {
+    /**
+     * The API Key used to communicate with the Firebase Auth backend.
+     */
+    apiKey: string;
+    /**
+     * The host at which the Firebase Auth backend is running.
+     */
+    apiHost: string;
+    /**
+     * The scheme used to communicate with the Firebase Auth backend.
+     */
+    apiScheme: string;
+    /**
+     * The host at which the Secure Token API is running.
+     */
+    tokenApiHost: string;
+    /**
+     * The SDK Client Version.
+     */
+    sdkClientVersion: string;
+    /**
+     * The domain at which the web widgets are hosted (provided via Firebase Config).
+     */
+    authDomain?: string;
+}
+/**
+ * Interface representing reCAPTCHA parameters.
+ *
+ * See the {@link https://developers.google.com/recaptcha/docs/display#render_param | reCAPTCHA docs}
+ * for the list of accepted parameters. All parameters are accepted except for `sitekey`: Firebase Auth
+ * provisions a reCAPTCHA for each project and will configure the site key upon rendering.
+ *
+ * For an invisible reCAPTCHA, set the `size` key to `invisible`.
+ *
+ * @public
+ */
+export interface RecaptchaParameters {
+    [key: string]: any;
+}
+/**
+ * Interface representing a parsed ID token.
+ *
+ * @privateRemarks TODO(avolkovi): consolidate with parsed_token in implementation.
+ *
+ * @public
+ */
+export interface ParsedToken {
+    /** Expiration time of the token. */
+    'exp'?: string;
+    /** UID of the user. */
+    'sub'?: string;
+    /** Time at which authentication was performed. */
+    'auth_time'?: string;
+    /** Issuance time of the token. */
+    'iat'?: string;
+    /** Firebase specific claims, containing the provider(s) used to authenticate the user. */
+    'firebase'?: {
+        'sign_in_provider'?: string;
+        'sign_in_second_factor'?: string;
+        'identities'?: Record<string, string>;
+    };
+    /** Map of any additional custom claims. */
+    [key: string]: unknown;
+}
+/**
+ * Type definition for an event callback.
+ *
+ * @privateRemarks TODO(avolkovi): should we consolidate with Subscribe<T> since we're changing the API anyway?
+ *
+ * @public
+ */
+export type NextOrObserver<T> = NextFn<T | null> | Observer<T | null>;
+/**
+ * Interface for an `Auth` error.
+ *
+ * @public
+ */
+export interface AuthError extends FirebaseError {
+    /** Details about the Firebase Auth error.  */
+    readonly customData: {
+        /** The name of the Firebase App which triggered this error.  */
+        readonly appName: string;
+        /** The email address of the user's account, used for sign-in and linking. */
+        readonly email?: string;
+        /** The phone number of the user's account, used for sign-in and linking. */
+        readonly phoneNumber?: string;
+        /**
+         * The tenant ID being used for sign-in and linking.
+         *
+         * @remarks
+         * If you use {@link signInWithRedirect} to sign in,
+         * you have to set the tenant ID on the {@link Auth} instance again as the tenant ID is not persisted
+         * after redirection.
+         */
+        readonly tenantId?: string;
+    };
+}
+/**
+ * Interface representing an {@link Auth} instance's settings.
+ *
+ * @remarks Currently used for enabling/disabling app verification for phone Auth testing.
+ *
+ * @public
+ */
+export interface AuthSettings {
+    /**
+     * When set, this property disables app verification for the purpose of testing phone
+     * authentication. For this property to take effect, it needs to be set before rendering a
+     * reCAPTCHA app verifier. When this is disabled, a mock reCAPTCHA is rendered instead. This is
+     * useful for manual testing during development or for automated integration tests.
+     *
+     * In order to use this feature, you will need to
+     * {@link https://firebase.google.com/docs/auth/web/phone-auth#test-with-whitelisted-phone-numbers | whitelist your phone number}
+     * via the Firebase Console.
+     *
+     * The default value is false (app verification is enabled).
+     */
+    appVerificationDisabledForTesting: boolean;
+}
+/**
+ * Interface representing Firebase Auth service.
+ *
+ * @remarks
+ * See {@link https://firebase.google.com/docs/auth/ | Firebase Authentication} for a full guide
+ * on how to use the Firebase Auth service.
+ *
+ * @public
+ */
+export interface Auth {
+    /** The {@link @firebase/app#FirebaseApp} associated with the `Auth` service instance. */
+    readonly app: FirebaseApp;
+    /** The name of the app associated with the `Auth` service instance. */
+    readonly name: string;
+    /** The {@link Config} used to initialize this instance. */
+    readonly config: Config;
+    /**
+     * Changes the type of persistence on the `Auth` instance.
+     *
+     * @remarks
+     * This will affect the currently saved Auth session and applies this type of persistence for
+     * future sign-in requests, including sign-in with redirect requests.
+     *
+     * This makes it easy for a user signing in to specify whether their session should be
+     * remembered or not. It also makes it easier to never persist the Auth state for applications
+     * that are shared by other users or have sensitive data.
+     *
+     * This method does not work in a Node.js environment.
+     *
+     * @example
+     * ```javascript
+     * auth.setPersistence(browserSessionPersistence);
+     * ```
+     *
+     * @param persistence - The {@link Persistence} to use.
+     */
+    setPersistence(persistence: Persistence): Promise<void>;
+    /**
+     * The {@link Auth} instance's language code.
+     *
+     * @remarks
+     * This is a readable/writable property. When set to null, the default Firebase Console language
+     * setting is applied. The language code will propagate to email action templates (password
+     * reset, email verification and email change revocation), SMS templates for phone authentication,
+     * reCAPTCHA verifier and OAuth popup/redirect operations provided the specified providers support
+     * localization with the language code specified.
+     */
+    languageCode: string | null;
+    /**
+     * The {@link Auth} instance's tenant ID.
+     *
+     * @remarks
+     * This is a readable/writable property. When you set the tenant ID of an {@link Auth} instance, all
+     * future sign-in/sign-up operations will pass this tenant ID and sign in or sign up users to
+     * the specified tenant project. When set to null, users are signed in to the parent project.
+     *
+     * @example
+     * ```javascript
+     * // Set the tenant ID on Auth instance.
+     * auth.tenantId = 'TENANT_PROJECT_ID';
+     *
+     * // All future sign-in request now include tenant ID.
+     * const result = await signInWithEmailAndPassword(auth, email, password);
+     * // result.user.tenantId should be 'TENANT_PROJECT_ID'.
+     * ```
+     *
+     * @defaultValue null
+     */
+    tenantId: string | null;
+    /**
+     * The {@link Auth} instance's settings.
+     *
+     * @remarks
+     * This is used to edit/read configuration related options such as app verification mode for
+     * phone authentication.
+     */
+    readonly settings: AuthSettings;
+    /**
+     * Adds an observer for changes to the user's sign-in state.
+     *
+     * @remarks
+     * To keep the old behavior, see {@link Auth.onIdTokenChanged}.
+     *
+     * @param nextOrObserver - callback triggered on change.
+     * @param error - Deprecated. This callback is never triggered. Errors
+     * on signing in/out can be caught in promises returned from
+     * sign-in/sign-out functions.
+     * @param completed - Deprecated. This callback is never triggered.
+     */
+    onAuthStateChanged(nextOrObserver: NextOrObserver<User | null>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+    /**
+     * Adds a blocking callback that runs before an auth state change
+     * sets a new user.
+     *
+     * @param callback - callback triggered before new user value is set.
+     *   If this throws, it blocks the user from being set.
+     * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`
+     *   callback throws, allowing you to undo any side effects.
+     */
+    beforeAuthStateChanged(callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
+    /**
+     * Adds an observer for changes to the signed-in user's ID token.
+     *
+     * @remarks
+     * This includes sign-in, sign-out, and token refresh events.
+     *
+     * @param nextOrObserver - callback triggered on change.
+     * @param error - Deprecated. This callback is never triggered. Errors
+     * on signing in/out can be caught in promises returned from
+     * sign-in/sign-out functions.
+     * @param completed - Deprecated. This callback is never triggered.
+     */
+    onIdTokenChanged(nextOrObserver: NextOrObserver<User | null>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+    /**
+     * returns a promise that resolves immediately when the initial
+     * auth state is settled. When the promise resolves, the current user might be a valid user
+     * or `null` if the user signed out.
+     */
+    authStateReady(): Promise<void>;
+    /** The currently signed-in user (or null). */
+    readonly currentUser: User | null;
+    /** The current emulator configuration (or null). */
+    readonly emulatorConfig: EmulatorConfig | null;
+    /**
+     * Asynchronously sets the provided user as {@link Auth.currentUser} on the {@link Auth} instance.
+     *
+     * @remarks
+     * A new instance copy of the user provided will be made and set as currentUser.
+     *
+     * This will trigger {@link Auth.onAuthStateChanged} and {@link Auth.onIdTokenChanged} listeners
+     * like other sign in methods.
+     *
+     * The operation fails with an error if the user to be updated belongs to a different Firebase
+     * project.
+     *
+     * @param user - The new {@link User}.
+     */
+    updateCurrentUser(user: User | null): Promise<void>;
+    /**
+     * Sets the current language to the default device/browser preference.
+     */
+    useDeviceLanguage(): void;
+    /**
+     * Signs out the current user. This does not automatically revoke the user's ID token.
+     *
+     * @remarks
+     * This method is not supported by {@link Auth} instances created with a
+     * {@link @firebase/app#FirebaseServerApp}.
+     */
+    signOut(): Promise<void>;
+}
+/**
+ * An interface covering the possible persistence mechanism types.
+ *
+ * @public
+ */
+export interface Persistence {
+    /**
+     * Type of Persistence.
+     * - 'SESSION' is used for temporary persistence such as `sessionStorage`.
+     * - 'LOCAL' is used for long term persistence such as `localStorage` or `IndexedDB`.
+     * - 'NONE' is used for in-memory, or no persistence.
+     * - 'COOKIE' is used for cookie persistence, useful for server-side rendering.
+     */
+    readonly type: 'SESSION' | 'LOCAL' | 'NONE' | 'COOKIE';
+}
+/**
+ * Interface representing ID token result obtained from {@link User.getIdTokenResult}.
+ *
+ * @remarks
+ * `IdTokenResult` contains the ID token JWT string and other helper properties for getting different data
+ * associated with the token as well as all the decoded payload claims.
+ *
+ * Note that these claims are not to be trusted as they are parsed client side. Only server side
+ * verification can guarantee the integrity of the token claims.
+ *
+ * @public
+ */
+export interface IdTokenResult {
+    /**
+     * The authentication time formatted as a UTC string.
+     *
+     * @remarks
+     * This is the time the user authenticated (signed in) and not the time the token was refreshed.
+     */
+    authTime: string;
+    /** The ID token expiration time formatted as a UTC string. */
+    expirationTime: string;
+    /** The ID token issuance time formatted as a UTC string. */
+    issuedAtTime: string;
+    /**
+     * The sign-in provider through which the ID token was obtained (anonymous, custom, phone,
+     * password, etc).
+     *
+     * @remarks
+     * Note, this does not map to provider IDs.
+     */
+    signInProvider: string | null;
+    /**
+     * The type of second factor associated with this session, provided the user was multi-factor
+     * authenticated (eg. phone, etc).
+     */
+    signInSecondFactor: string | null;
+    /** The Firebase Auth ID token JWT string. */
+    token: string;
+    /**
+     * The entire payload claims of the ID token including the standard reserved claims as well as
+     * the custom claims.
+     */
+    claims: ParsedToken;
+}
+/**
+ * A response from {@link checkActionCode}.
+ *
+ * @public
+ */
+export interface ActionCodeInfo {
+    /**
+     * The data associated with the action code.
+     *
+     * @remarks
+     * For the {@link ActionCodeOperation}.PASSWORD_RESET, {@link ActionCodeOperation}.VERIFY_EMAIL, and
+     * {@link ActionCodeOperation}.RECOVER_EMAIL actions, this object contains an email field with the address
+     * the email was sent to.
+     *
+     * For the {@link ActionCodeOperation}.RECOVER_EMAIL action, which allows a user to undo an email address
+     * change, this object also contains a `previousEmail` field with the user account's current
+     * email address. After the action completes, the user's email address will revert to the value
+     * in the `email` field from the value in `previousEmail` field.
+     *
+     * For the {@link ActionCodeOperation}.VERIFY_AND_CHANGE_EMAIL action, which allows a user to verify the
+     * email before updating it, this object contains a `previousEmail` field with the user account's
+     * email address before updating. After the action completes, the user's email address will be
+     * updated to the value in the `email` field from the value in `previousEmail` field.
+     *
+     * For the {@link ActionCodeOperation}.REVERT_SECOND_FACTOR_ADDITION action, which allows a user to
+     * unenroll a newly added second factor, this object contains a `multiFactorInfo` field with
+     * the information about the second factor. For phone second factor, the `multiFactorInfo`
+     * is a {@link MultiFactorInfo} object, which contains the phone number.
+     */
+    data: {
+        email?: string | null;
+        multiFactorInfo?: MultiFactorInfo | null;
+        previousEmail?: string | null;
+    };
+    /**
+     * The type of operation that generated the action code.
+     */
+    operation: (typeof ActionCodeOperationMap)[keyof typeof ActionCodeOperationMap];
+}
+/**
+ * An enumeration of the possible email action types.
+ *
+ * @internal
+ */
+export declare const enum ActionCodeOperation {
+    /** The email link sign-in action. */
+    EMAIL_SIGNIN = "EMAIL_SIGNIN",
+    /** The password reset action. */
+    PASSWORD_RESET = "PASSWORD_RESET",
+    /** The email revocation action. */
+    RECOVER_EMAIL = "RECOVER_EMAIL",
+    /** The revert second factor addition email action. */
+    REVERT_SECOND_FACTOR_ADDITION = "REVERT_SECOND_FACTOR_ADDITION",
+    /** The revert second factor addition email action. */
+    VERIFY_AND_CHANGE_EMAIL = "VERIFY_AND_CHANGE_EMAIL",
+    /** The email verification action. */
+    VERIFY_EMAIL = "VERIFY_EMAIL"
+}
+/**
+ * An interface that defines the required continue/state URL with optional Android and iOS
+ * bundle identifiers.
+ *
+ * @public
+ */
+export interface ActionCodeSettings {
+    /**
+     * Sets the Android package name.
+     *
+     * @remarks
+     * This will try to open the link in an Android app if it is installed.
+     */
+    android?: {
+        installApp?: boolean;
+        minimumVersion?: string;
+        packageName: string;
+    };
+    /**
+     * When set to true, the action code link will be be sent as a Universal Link or Android App
+     * Link and will be opened by the app if installed.
+     *
+     * @remarks
+     * In the false case, the code will be sent to the web widget first and then on continue will
+     * redirect to the app if installed.
+     *
+     * @defaultValue false
+     */
+    handleCodeInApp?: boolean;
+    /**
+     * Sets the iOS bundle ID.
+     *
+     * @remarks
+     * This will try to open the link in an iOS app if it is installed.
+     */
+    iOS?: {
+        bundleId: string;
+    };
+    /**
+     * Sets the link continue/state URL.
+     *
+     * @remarks
+     * This has different meanings in different contexts:
+     * - When the link is handled in the web action widgets, this is the deep link in the
+     * `continueUrl` query parameter.
+     * - When the link is handled in the app directly, this is the `continueUrl` query parameter in
+     * the deep link of the Dynamic Link or Hosting link.
+     */
+    url: string;
+    /**
+     * When multiple custom dynamic link domains are defined for a project, specify which one to use
+     * when the link is to be opened via a specified mobile app (for example, `example.page.link`).
+     *
+     *
+     * @defaultValue The first domain is automatically selected.
+     *
+     * @deprecated Firebase Dynamic Links is deprecated and will be shut down as early as August
+     * 2025. Instead, use {@link ActionCodeSettings.linkDomain} to set a custom domain for mobile
+     * links. Learn more in the {@link https://firebase.google.com/support/dynamic-links-faq | Dynamic Links deprecation FAQ}.
+     */
+    dynamicLinkDomain?: string;
+    /**
+     * The optional custom Firebase Hosting domain to use when the link is to be opened via
+     * a specified mobile app. The domain must be configured in Firebase Hosting and owned
+     * by the project. This cannot be a default Hosting domain (`web.app` or `firebaseapp.com`).
+     *
+     * @defaultValue The default Hosting domain will be used (for example, `example.firebaseapp.com`).
+     */
+    linkDomain?: string;
+}
+/**
+ * A verifier for domain verification and abuse prevention.
+ *
+ * @remarks
+ * Currently, the only implementation is {@link RecaptchaVerifier}.
+ *
+ * @public
+ */
+export interface ApplicationVerifier {
+    /**
+     * Identifies the type of application verifier (e.g. "recaptcha").
+     */
+    readonly type: string;
+    /**
+     * Executes the verification process.
+     *
+     * @returns A Promise for a token that can be used to assert the validity of a request.
+     */
+    verify(): Promise<string>;
+}
+/**
+ * Interface that represents an auth provider, used to facilitate creating {@link AuthCredential}.
+ *
+ * @public
+ */
+export interface AuthProvider {
+    /**
+     * Provider for which credentials can be constructed.
+     */
+    readonly providerId: string;
+}
+/**
+ * An enum of factors that may be used for multifactor authentication.
+ *
+ * Internally we use an enum type for FactorId, ActionCodeOperation, but there is a copy in https://github.com/firebase/firebase-js-sdk/blob/48a2096aec53a7eaa9ffcc2625016ecb9f90d113/packages/auth/src/model/enum_maps.ts#L23 that uses maps.
+ * const enums are better for tree-shaking, however can cause runtime errors if exposed in public APIs, example - https://github.com/microsoft/rushstack/issues/3058
+ * So, we expose enum maps publicly, but use const enums internally to get some tree-shaking benefit.
+ * @internal
+ */
+export declare const enum FactorId {
+    /** Phone as second factor */
+    PHONE = "phone",
+    TOTP = "totp"
+}
+/**
+ * A result from a phone number sign-in, link, or reauthenticate call.
+ *
+ * @public
+ */
+export interface ConfirmationResult {
+    /**
+     * The phone number authentication operation's verification ID.
+     *
+     * @remarks
+     * This can be used along with the verification code to initialize a
+     * {@link PhoneAuthCredential}.
+     */
+    readonly verificationId: string;
+    /**
+     * Finishes a phone number sign-in, link, or reauthentication.
+     *
+     * @example
+     * ```javascript
+     * const confirmationResult = await signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);
+     * // Obtain verificationCode from the user.
+     * const userCredential = await confirmationResult.confirm(verificationCode);
+     * ```
+     *
+     * @param verificationCode - The code that was sent to the user's mobile device.
+     */
+    confirm(verificationCode: string): Promise<UserCredential>;
+}
+/**
+ * The base class for asserting ownership of a second factor.
+ *
+ * @remarks
+ * This is used to facilitate enrollment of a second factor on an existing user or sign-in of a
+ * user who already verified the first factor.
+ *
+ * @public
+ */
+export interface MultiFactorAssertion {
+    /** The identifier of the second factor. */
+    readonly factorId: (typeof FactorIdMap)[keyof typeof FactorIdMap];
+}
+/**
+ * The error thrown when the user needs to provide a second factor to sign in successfully.
+ *
+ * @remarks
+ * The error code for this error is `auth/multi-factor-auth-required`.
+ *
+ * @example
+ * ```javascript
+ * let resolver;
+ * let multiFactorHints;
+ *
+ * signInWithEmailAndPassword(auth, email, password)
+ *     .then((result) => {
+ *       // User signed in. No 2nd factor challenge is needed.
+ *     })
+ *     .catch((error) => {
+ *       if (error.code == 'auth/multi-factor-auth-required') {
+ *         resolver = getMultiFactorResolver(auth, error);
+ *         multiFactorHints = resolver.hints;
+ *       } else {
+ *         // Handle other errors.
+ *       }
+ *     });
+ *
+ * // Obtain a multiFactorAssertion by verifying the second factor.
+ *
+ * const userCredential = await resolver.resolveSignIn(multiFactorAssertion);
+ * ```
+ *
+ * @public
+ */
+export interface MultiFactorError extends AuthError {
+    /** Details about the MultiFactorError. */
+    readonly customData: AuthError['customData'] & {
+        /**
+         * The type of operation (sign-in, linking, or re-authentication) that raised the error.
+         */
+        readonly operationType: (typeof OperationTypeMap)[keyof typeof OperationTypeMap];
+    };
+}
+/**
+ * A structure containing the information of a second factor entity.
+ *
+ * @public
+ */
+export interface MultiFactorInfo {
+    /** The multi-factor enrollment ID. */
+    readonly uid: string;
+    /** The user friendly name of the current second factor. */
+    readonly displayName?: string | null;
+    /** The enrollment date of the second factor formatted as a UTC string. */
+    readonly enrollmentTime: string;
+    /** The identifier of the second factor. */
+    readonly factorId: (typeof FactorIdMap)[keyof typeof FactorIdMap];
+}
+/**
+ * The subclass of the {@link MultiFactorInfo} interface for phone number
+ * second factors. The `factorId` of this second factor is {@link FactorId}.PHONE.
+ * @public
+ */
+export interface PhoneMultiFactorInfo extends MultiFactorInfo {
+    /** The phone number associated with the current second factor. */
+    readonly phoneNumber: string;
+}
+/**
+ * The subclass of the {@link MultiFactorInfo} interface for TOTP
+ * second factors. The `factorId` of this second factor is {@link FactorId}.TOTP.
+ * @public
+ */
+export interface TotpMultiFactorInfo extends MultiFactorInfo {
+}
+/**
+ * The class used to facilitate recovery from {@link MultiFactorError} when a user needs to
+ * provide a second factor to sign in.
+ *
+ * @example
+ * ```javascript
+ * let resolver;
+ * let multiFactorHints;
+ *
+ * signInWithEmailAndPassword(auth, email, password)
+ *     .then((result) => {
+ *       // User signed in. No 2nd factor challenge is needed.
+ *     })
+ *     .catch((error) => {
+ *       if (error.code == 'auth/multi-factor-auth-required') {
+ *         resolver = getMultiFactorResolver(auth, error);
+ *         // Show UI to let user select second factor.
+ *         multiFactorHints = resolver.hints;
+ *       } else {
+ *         // Handle other errors.
+ *       }
+ *     });
+ *
+ * // The enrolled second factors that can be used to complete
+ * // sign-in are returned in the `MultiFactorResolver.hints` list.
+ * // UI needs to be presented to allow the user to select a second factor
+ * // from that list.
+ *
+ * const selectedHint = // ; selected from multiFactorHints
+ * const phoneAuthProvider = new PhoneAuthProvider(auth);
+ * const phoneInfoOptions = {
+ *   multiFactorHint: selectedHint,
+ *   session: resolver.session
+ * };
+ * const verificationId = phoneAuthProvider.verifyPhoneNumber(phoneInfoOptions, appVerifier);
+ * // Store `verificationId` and show UI to let user enter verification code.
+ *
+ * // UI to enter verification code and continue.
+ * // Continue button click handler
+ * const phoneAuthCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+ * const multiFactorAssertion = PhoneMultiFactorGenerator.assertion(phoneAuthCredential);
+ * const userCredential = await resolver.resolveSignIn(multiFactorAssertion);
+ * ```
+ *
+ * @public
+ */
+export interface MultiFactorResolver {
+    /**
+     * The list of hints for the second factors needed to complete the sign-in for the current
+     * session.
+     */
+    readonly hints: MultiFactorInfo[];
+    /**
+     * The session identifier for the current sign-in flow, which can be used to complete the second
+     * factor sign-in.
+     */
+    readonly session: MultiFactorSession;
+    /**
+     * A helper function to help users complete sign in with a second factor using an
+     * {@link MultiFactorAssertion} confirming the user successfully completed the second factor
+     * challenge.
+     *
+     * @example
+     * ```javascript
+     * const phoneAuthCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+     * const multiFactorAssertion = PhoneMultiFactorGenerator.assertion(phoneAuthCredential);
+     * const userCredential = await resolver.resolveSignIn(multiFactorAssertion);
+     * ```
+     *
+     * @param assertion - The multi-factor assertion to resolve sign-in with.
+     * @returns The promise that resolves with the user credential object.
+     */
+    resolveSignIn(assertion: MultiFactorAssertion): Promise<UserCredential>;
+}
+/**
+ * An interface defining the multi-factor session object used for enrolling a second factor on a
+ * user or helping sign in an enrolled user with a second factor.
+ *
+ * @public
+ */
+export interface MultiFactorSession {
+}
+/**
+ * An interface that defines the multi-factor related properties and operations pertaining
+ * to a {@link User}.
+ *
+ * @public
+ */
+export interface MultiFactorUser {
+    /** Returns a list of the user's enrolled second factors. */
+    readonly enrolledFactors: MultiFactorInfo[];
+    /**
+     * Returns the session identifier for a second factor enrollment operation. This is used to
+     * identify the user trying to enroll a second factor.
+     *
+     * @example
+     * ```javascript
+     * const multiFactorUser = multiFactor(auth.currentUser);
+     * const multiFactorSession = await multiFactorUser.getSession();
+     *
+     * // Send verification code.
+     * const phoneAuthProvider = new PhoneAuthProvider(auth);
+     * const phoneInfoOptions = {
+     *   phoneNumber: phoneNumber,
+     *   session: multiFactorSession
+     * };
+     * const verificationId = await phoneAuthProvider.verifyPhoneNumber(phoneInfoOptions, appVerifier);
+     *
+     * // Obtain verification code from user.
+     * const phoneAuthCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+     * const multiFactorAssertion = PhoneMultiFactorGenerator.assertion(phoneAuthCredential);
+     * await multiFactorUser.enroll(multiFactorAssertion);
+     * ```
+     *
+     * @returns The promise that resolves with the {@link MultiFactorSession}.
+     */
+    getSession(): Promise<MultiFactorSession>;
+    /**
+     *
+     * Enrolls a second factor as identified by the {@link MultiFactorAssertion} for the
+     * user.
+     *
+     * @remarks
+     * On resolution, the user tokens are updated to reflect the change in the JWT payload.
+     * Accepts an additional display name parameter used to identify the second factor to the end
+     * user. Recent re-authentication is required for this operation to succeed. On successful
+     * enrollment, existing Firebase sessions (refresh tokens) are revoked. When a new factor is
+     * enrolled, an email notification is sent to the user’s email.
+     *
+     * @example
+     * ```javascript
+     * const multiFactorUser = multiFactor(auth.currentUser);
+     * const multiFactorSession = await multiFactorUser.getSession();
+     *
+     * // Send verification code.
+     * const phoneAuthProvider = new PhoneAuthProvider(auth);
+     * const phoneInfoOptions = {
+     *   phoneNumber: phoneNumber,
+     *   session: multiFactorSession
+     * };
+     * const verificationId = await phoneAuthProvider.verifyPhoneNumber(phoneInfoOptions, appVerifier);
+     *
+     * // Obtain verification code from user.
+     * const phoneAuthCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+     * const multiFactorAssertion = PhoneMultiFactorGenerator.assertion(phoneAuthCredential);
+     * await multiFactorUser.enroll(multiFactorAssertion);
+     * // Second factor enrolled.
+     * ```
+     *
+     * @param assertion - The multi-factor assertion to enroll with.
+     * @param displayName - The display name of the second factor.
+     */
+    enroll(assertion: MultiFactorAssertion, displayName?: string | null): Promise<void>;
+    /**
+     * Unenrolls the specified second factor.
+     *
+     * @remarks
+     * To specify the factor to remove, pass a {@link MultiFactorInfo} object (retrieved from
+     * {@link MultiFactorUser.enrolledFactors}) or the
+     * factor's UID string. Sessions are not revoked when the account is unenrolled. An email
+     * notification is likely to be sent to the user notifying them of the change. Recent
+     * re-authentication is required for this operation to succeed. When an existing factor is
+     * unenrolled, an email notification is sent to the user’s email.
+     *
+     * @example
+     * ```javascript
+     * const multiFactorUser = multiFactor(auth.currentUser);
+     * // Present user the option to choose which factor to unenroll.
+     * await multiFactorUser.unenroll(multiFactorUser.enrolledFactors[i])
+     * ```
+     *
+     * @param option - The multi-factor option to unenroll.
+     * @returns - A `Promise` which resolves when the unenroll operation is complete.
+     */
+    unenroll(option: MultiFactorInfo | string): Promise<void>;
+}
+/**
+ * The class for asserting ownership of a phone second factor. Provided by
+ * {@link PhoneMultiFactorGenerator.assertion}.
+ *
+ * @public
+ */
+export interface PhoneMultiFactorAssertion extends MultiFactorAssertion {
+}
+/**
+ * The information required to verify the ownership of a phone number.
+ *
+ * @remarks
+ * The information that's required depends on whether you are doing single-factor sign-in,
+ * multi-factor enrollment or multi-factor sign-in.
+ *
+ * @public
+ */
+export type PhoneInfoOptions = PhoneSingleFactorInfoOptions | PhoneMultiFactorEnrollInfoOptions | PhoneMultiFactorSignInInfoOptions;
+/**
+ * Options used for single-factor sign-in.
+ *
+ * @public
+ */
+export interface PhoneSingleFactorInfoOptions {
+    /** Phone number to send a verification code to. */
+    phoneNumber: string;
+}
+/**
+ * Options used for enrolling a second factor.
+ *
+ * @public
+ */
+export interface PhoneMultiFactorEnrollInfoOptions {
+    /** Phone number to send a verification code to. */
+    phoneNumber: string;
+    /** The {@link MultiFactorSession} obtained via {@link MultiFactorUser.getSession}. */
+    session: MultiFactorSession;
+}
+/**
+ * Options used for signing in with a second factor.
+ *
+ * @public
+ */
+export interface PhoneMultiFactorSignInInfoOptions {
+    /**
+     * The {@link MultiFactorInfo} obtained via {@link MultiFactorResolver.hints}.
+     *
+     * One of `multiFactorHint` or `multiFactorUid` is required.
+     */
+    multiFactorHint?: MultiFactorInfo;
+    /**
+     * The uid of the second factor.
+     *
+     * One of `multiFactorHint` or `multiFactorUid` is required.
+     */
+    multiFactorUid?: string;
+    /** The {@link MultiFactorSession} obtained via {@link MultiFactorResolver.session}. */
+    session: MultiFactorSession;
+}
+/**
+ * Interface for a supplied `AsyncStorage`.
+ *
+ * @public
+ */
+export interface ReactNativeAsyncStorage {
+    /**
+     * Persist an item in storage.
+     *
+     * @param key - storage key.
+     * @param value - storage value.
+     */
+    setItem(key: string, value: string): Promise<void>;
+    /**
+     * Retrieve an item from storage.
+     *
+     * @param key - storage key.
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * Remove an item from storage.
+     *
+     * @param key - storage key.
+     */
+    removeItem(key: string): Promise<void>;
+}
+/**
+ * A user account.
+ *
+ * @public
+ */
+export interface User extends UserInfo {
+    /**
+     * Whether the email has been verified with {@link sendEmailVerification} and
+     * {@link applyActionCode}.
+     */
+    readonly emailVerified: boolean;
+    /**
+     * Whether the user is authenticated using the {@link ProviderId}.ANONYMOUS provider.
+     */
+    readonly isAnonymous: boolean;
+    /**
+     * Additional metadata around user creation and sign-in times.
+     */
+    readonly metadata: UserMetadata;
+    /**
+     * Additional per provider such as displayName and profile information.
+     */
+    readonly providerData: UserInfo[];
+    /**
+     * Refresh token used to reauthenticate the user. Avoid using this directly and prefer
+     * {@link User.getIdToken} to refresh the ID token instead.
+     */
+    readonly refreshToken: string;
+    /**
+     * The user's tenant ID.
+     *
+     * @remarks
+     * This is a read-only property, which indicates the tenant ID
+     * used to sign in the user. This is null if the user is signed in from the parent
+     * project.
+     *
+     * @example
+     * ```javascript
+     * // Set the tenant ID on Auth instance.
+     * auth.tenantId = 'TENANT_PROJECT_ID';
+     *
+     * // All future sign-in request now include tenant ID.
+     * const result = await signInWithEmailAndPassword(auth, email, password);
+     * // result.user.tenantId should be 'TENANT_PROJECT_ID'.
+     * ```
+     */
+    readonly tenantId: string | null;
+    /**
+     * Deletes and signs out the user.
+     *
+     * @remarks
+     * Important: this is a security-sensitive operation that requires the user to have recently
+     * signed in. If this requirement isn't met, ask the user to authenticate again and then call
+     * one of the reauthentication methods like {@link reauthenticateWithCredential}.
+     *
+     * This method is not supported on any {@link User} signed in by {@link Auth} instances
+     * created with a {@link @firebase/app#FirebaseServerApp}.
+     */
+    delete(): Promise<void>;
+    /**
+     * Returns a JSON Web Token (JWT) used to identify the user to a Firebase service.
+     *
+     * @remarks
+     * Returns the current token if it has not expired or if it will not expire in the next five
+     * minutes. Otherwise, this will refresh the token and return a new one.
+     *
+     * @param forceRefresh - Force refresh regardless of token expiration.
+     */
+    getIdToken(forceRefresh?: boolean): Promise<string>;
+    /**
+     * Returns a deserialized JSON Web Token (JWT) used to identify the user to a Firebase service.
+     *
+     * @remarks
+     * Returns the current token if it has not expired or if it will not expire in the next five
+     * minutes. Otherwise, this will refresh the token and return a new one.
+     *
+     * @param forceRefresh - Force refresh regardless of token expiration.
+     */
+    getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
+    /**
+     * Refreshes the user, if signed in.
+     */
+    reload(): Promise<void>;
+    /**
+     * Returns a JSON-serializable representation of this object.
+     *
+     * @returns A JSON-serializable representation of this object.
+     */
+    toJSON(): object;
+}
+/**
+ * A structure containing a {@link User}, the {@link OperationType}, and the provider ID.
+ *
+ * @remarks
+ * `operationType` could be {@link OperationType}.SIGN_IN for a sign-in operation,
+ * {@link OperationType}.LINK for a linking operation and {@link OperationType}.REAUTHENTICATE for
+ * a reauthentication operation.
+ *
+ * @public
+ */
+export interface UserCredential {
+    /**
+     * The user authenticated by this credential.
+     */
+    user: User;
+    /**
+     * The provider which was used to authenticate the user.
+     */
+    providerId: string | null;
+    /**
+     * The type of operation which was used to authenticate the user (such as sign-in or link).
+     */
+    operationType: (typeof OperationTypeMap)[keyof typeof OperationTypeMap];
+}
+/**
+ * User profile information, visible only to the Firebase project's apps.
+ *
+ * @public
+ */
+export interface UserInfo {
+    /**
+     * The display name of the user.
+     */
+    readonly displayName: string | null;
+    /**
+     * The email of the user.
+     */
+    readonly email: string | null;
+    /**
+     * The phone number normalized based on the E.164 standard (e.g. +16505550101) for the
+     * user.
+     *
+     * @remarks
+     * This is null if the user has no phone credential linked to the account.
+     */
+    readonly phoneNumber: string | null;
+    /**
+     * The profile photo URL of the user.
+     */
+    readonly photoURL: string | null;
+    /**
+     * The provider used to authenticate the user.
+     */
+    readonly providerId: string;
+    /**
+     * The user's unique ID, scoped to the project.
+     */
+    readonly uid: string;
+}
+/**
+ * Interface representing a user's metadata.
+ *
+ * @public
+ */
+export interface UserMetadata {
+    /** Time the user was created. */
+    readonly creationTime?: string;
+    /** Time the user last signed in. */
+    readonly lastSignInTime?: string;
+}
+/**
+ * A structure containing additional user information from a federated identity provider.
+ *
+ * @public
+ */
+export interface AdditionalUserInfo {
+    /**
+     * Whether the user is new (created via sign-up) or existing (authenticated using sign-in).
+     */
+    readonly isNewUser: boolean;
+    /**
+     * Map containing IDP-specific user data.
+     */
+    readonly profile: Record<string, unknown> | null;
+    /**
+     * Identifier for the provider used to authenticate this user.
+     */
+    readonly providerId: string | null;
+    /**
+     * The username if the provider is GitHub or Twitter.
+     */
+    readonly username?: string | null;
+}
+/**
+ * User profile used in {@link AdditionalUserInfo}.
+ *
+ * @public
+ */
+export type UserProfile = Record<string, unknown>;
+/**
+ * A resolver used for handling DOM specific operations like {@link signInWithPopup}
+ * or {@link signInWithRedirect}.
+ *
+ * @public
+ */
+export interface PopupRedirectResolver {
+}
+declare module '@firebase/component' {
+    interface NameServiceMapping {
+        'auth': Auth;
+    }
+}
+/**
+ * Configuration of Firebase Authentication Emulator.
+ * @public
+ */
+export interface EmulatorConfig {
+    /**
+     * The protocol used to communicate with the emulator ("http"/"https").
+     */
+    readonly protocol: string;
+    /**
+     * The hostname of the emulator, which may be a domain ("localhost"), IPv4 address ("127.0.0.1")
+     * or quoted IPv6 address ("[::1]").
+     */
+    readonly host: string;
+    /**
+     * The port of the emulator, or null if port isn't specified (i.e. protocol default).
+     */
+    readonly port: number | null;
+    /**
+     * The emulator-specific options.
+     */
+    readonly options: {
+        /**
+         * Whether the warning banner attached to the DOM was disabled.
+         */
+        readonly disableWarnings: boolean;
+    };
+}
+/**
+ * A mapping of error codes to error messages.
+ *
+ * @remarks
+ *
+ * While error messages are useful for debugging (providing verbose textual
+ * context around what went wrong), these strings take up a lot of space in the
+ * compiled code. When deploying code in production, using {@link prodErrorMap}
+ * will save you roughly 10k compressed/gzipped over {@link debugErrorMap}. You
+ * can select the error map during initialization:
+ *
+ * ```javascript
+ * initializeAuth(app, {errorMap: debugErrorMap})
+ * ```
+ *
+ * When initializing Auth, {@link prodErrorMap} is default.
+ *
+ * @public
+ */
+export interface AuthErrorMap {
+}
+/**
+ * The dependencies that can be used to initialize an {@link Auth} instance.
+ *
+ * @remarks
+ *
+ * The modular SDK enables tree shaking by allowing explicit declarations of
+ * dependencies. For example, a web app does not need to include code that
+ * enables Cordova redirect sign in. That functionality is therefore split into
+ * {@link browserPopupRedirectResolver} and
+ * {@link cordovaPopupRedirectResolver}. The dependencies object is how Auth is
+ * configured to reduce bundle sizes.
+ *
+ * There are two ways to initialize an {@link Auth} instance: {@link getAuth} and
+ * {@link initializeAuth}. `getAuth` initializes everything using
+ * platform-specific configurations, while `initializeAuth` takes a
+ * `Dependencies` object directly, giving you more control over what is used.
+ *
+ * @public
+ */
+export interface Dependencies {
+    /**
+     * Which {@link Persistence} to use. If this is an array, the first
+     * `Persistence` that the device supports is used. The SDK searches for an
+     * existing account in order and, if one is found in a secondary
+     * `Persistence`, the account is moved to the primary `Persistence`.
+     *
+     * If no persistence is provided, the SDK falls back on
+     * {@link inMemoryPersistence}.
+     */
+    persistence?: Persistence | Persistence[];
+    /**
+     * The {@link PopupRedirectResolver} to use. This value depends on the
+     * platform. Options are {@link browserPopupRedirectResolver} and
+     * {@link cordovaPopupRedirectResolver}. This field is optional if neither
+     * {@link signInWithPopup} or {@link signInWithRedirect} are being used.
+     */
+    popupRedirectResolver?: PopupRedirectResolver;
+    /**
+     * Which {@link AuthErrorMap} to use.
+     */
+    errorMap?: AuthErrorMap;
+}
+/**
+ * The class for asserting ownership of a TOTP second factor. Provided by
+ * {@link TotpMultiFactorGenerator.assertionForEnrollment} and
+ * {@link TotpMultiFactorGenerator.assertionForSignIn}.
+ *
+ * @public
+ */
+export interface TotpMultiFactorAssertion extends MultiFactorAssertion {
+}
+/**
+ * A structure specifying password policy requirements.
+ *
+ * @public
+ */
+export interface PasswordPolicy {
+    /**
+     * Requirements enforced by this password policy.
+     */
+    readonly customStrengthOptions: {
+        /**
+         * Minimum password length, or undefined if not configured.
+         */
+        readonly minPasswordLength?: number;
+        /**
+         * Maximum password length, or undefined if not configured.
+         */
+        readonly maxPasswordLength?: number;
+        /**
+         * Whether the password should contain a lowercase letter, or undefined if not configured.
+         */
+        readonly containsLowercaseLetter?: boolean;
+        /**
+         * Whether the password should contain an uppercase letter, or undefined if not configured.
+         */
+        readonly containsUppercaseLetter?: boolean;
+        /**
+         * Whether the password should contain a numeric character, or undefined if not configured.
+         */
+        readonly containsNumericCharacter?: boolean;
+        /**
+         * Whether the password should contain a non-alphanumeric character, or undefined if not configured.
+         */
+        readonly containsNonAlphanumericCharacter?: boolean;
+    };
+    /**
+     * List of characters that are considered non-alphanumeric during validation.
+     */
+    readonly allowedNonAlphanumericCharacters: string;
+    /**
+     * The enforcement state of the policy. Can be 'OFF' or 'ENFORCE'.
+     */
+    readonly enforcementState: string;
+    /**
+     * Whether existing passwords must meet the policy.
+     */
+    readonly forceUpgradeOnSignin: boolean;
+}
+/**
+ * A structure indicating which password policy requirements were met or violated and what the
+ * requirements are.
+ *
+ * @public
+ */
+export interface PasswordValidationStatus {
+    /**
+     * Whether the password meets all requirements.
+     */
+    readonly isValid: boolean;
+    /**
+     * Whether the password meets the minimum password length, or undefined if not required.
+     */
+    readonly meetsMinPasswordLength?: boolean;
+    /**
+     * Whether the password meets the maximum password length, or undefined if not required.
+     */
+    readonly meetsMaxPasswordLength?: boolean;
+    /**
+     * Whether the password contains a lowercase letter, or undefined if not required.
+     */
+    readonly containsLowercaseLetter?: boolean;
+    /**
+     * Whether the password contains an uppercase letter, or undefined if not required.
+     */
+    readonly containsUppercaseLetter?: boolean;
+    /**
+     * Whether the password contains a numeric character, or undefined if not required.
+     */
+    readonly containsNumericCharacter?: boolean;
+    /**
+     * Whether the password contains a non-alphanumeric character, or undefined if not required.
+     */
+    readonly containsNonAlphanumericCharacter?: boolean;
+    /**
+     * The policy used to validate the password.
+     */
+    readonly passwordPolicy: PasswordPolicy;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/model/user.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/model/user.d.ts
new file mode 100644
index 0000000..7e40566
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/model/user.d.ts
@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { IdTokenResult, User, UserCredential, UserInfo } from './public_types';
+import { NextFn } from '@firebase/util';
+import { APIUserInfo } from '../api/account_management/account';
+import { FinalizeMfaResponse } from '../api/authentication/mfa';
+import { PersistedBlob } from '../core/persistence';
+import { StsTokenManager } from '../core/user/token_manager';
+import { UserMetadata } from '../core/user/user_metadata';
+import { AuthInternal } from './auth';
+import { IdTokenResponse, TaggedWithTokenResponse } from './id_token';
+import { ProviderId } from './enums';
+export type MutableUserInfo = {
+    -readonly [K in keyof UserInfo]: UserInfo[K];
+};
+export interface UserParameters {
+    uid: string;
+    auth: AuthInternal;
+    stsTokenManager: StsTokenManager;
+    displayName?: string | null;
+    email?: string | null;
+    phoneNumber?: string | null;
+    photoURL?: string | null;
+    isAnonymous?: boolean | null;
+    emailVerified?: boolean | null;
+    tenantId?: string | null;
+    providerData?: MutableUserInfo[] | null;
+    createdAt?: string | null;
+    lastLoginAt?: string | null;
+}
+/**
+ * UserInternal and AuthInternal reference each other, so both of them are included in the public typings.
+ * In order to exclude them, we mark them as internal explicitly.
+ *
+ * @internal
+ */
+export interface UserInternal extends User {
+    displayName: string | null;
+    email: string | null;
+    phoneNumber: string | null;
+    photoURL: string | null;
+    auth: AuthInternal;
+    providerId: ProviderId.FIREBASE;
+    refreshToken: string;
+    emailVerified: boolean;
+    tenantId: string | null;
+    providerData: MutableUserInfo[];
+    metadata: UserMetadata;
+    stsTokenManager: StsTokenManager;
+    _redirectEventId?: string;
+    _updateTokensIfNecessary(response: IdTokenResponse | FinalizeMfaResponse, reload?: boolean): Promise<void>;
+    _assign(user: UserInternal): void;
+    _clone(auth: AuthInternal): UserInternal;
+    _onReload: (cb: NextFn<APIUserInfo>) => void;
+    _notifyReloadListener: NextFn<APIUserInfo>;
+    _startProactiveRefresh: () => void;
+    _stopProactiveRefresh: () => void;
+    getIdToken(forceRefresh?: boolean): Promise<string>;
+    getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
+    reload(): Promise<void>;
+    delete(): Promise<void>;
+    toJSON(): PersistedBlob;
+}
+/**
+ * @internal
+ */
+export interface UserCredentialInternal extends UserCredential, TaggedWithTokenResponse {
+    user: UserInternal;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/auth_window.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/auth_window.d.ts
new file mode 100644
index 0000000..b3087c7
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/auth_window.d.ts
@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Recaptcha, GreCAPTCHATopLevel } from './recaptcha/recaptcha';
+/**
+ * A specialized window type that melds the normal window type plus the
+ * various bits we need. The three different blocks that are &'d together
+ * cant be defined in the same block together.
+ */
+export type AuthWindow = {
+    [T in keyof Window]: Window[T];
+} & {
+    grecaptcha?: Recaptcha | GreCAPTCHATopLevel;
+    ___jsl?: Record<string, any>;
+    gapi?: typeof gapi;
+} & {
+    [callback: string]: (...args: unknown[]) => void;
+};
+/**
+ * Lazy accessor for window, since the compat layer won't tree shake this out,
+ * we need to make sure not to mess with window unless we have to
+ */
+export declare function _window(): AuthWindow;
+export declare function _setWindowLocation(url: string): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/gapi.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/gapi.d.ts
new file mode 100644
index 0000000..c2a65cd
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/gapi.d.ts
@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+export declare function _loadGapi(auth: AuthInternal): Promise<gapi.iframes.Context>;
+export declare function _resetLoader(): void;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/gapi.iframes.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/gapi.iframes.d.ts
new file mode 100644
index 0000000..9b5f24b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/gapi.iframes.d.ts
@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+declare namespace gapi {
+    type LoadCallback = () => void;
+    interface LoadConfig {
+    }
+    interface LoadOptions {
+        callback?: LoadCallback;
+        timeout?: number;
+        ontimeout?: LoadCallback;
+    }
+    function load(features: 'gapi.iframes', options?: LoadOptions | LoadCallback): void;
+}
+declare namespace gapi.iframes {
+    interface Message {
+        type: string;
+    }
+    type IframesFilter = (iframe: Iframe) => boolean;
+    type MessageHandler<T extends Message> = (message: T) => unknown | Promise<void>;
+    type SendCallback = () => void;
+    type Callback = (iframe: Iframe) => void;
+    class Context {
+        open(options: Record<string, unknown>, callback?: Callback): Promise<Iframe>;
+    }
+    class Iframe {
+        register<T extends Message>(message: string, handler: MessageHandler<T>, filter?: IframesFilter): void;
+        send<T extends Message, U extends Message>(type: string, data: T, callback?: MessageHandler<U>, filter?: IframesFilter): void;
+        ping(callback: SendCallback, data?: unknown): Promise<unknown[]>;
+        restyle(style: Record<string, string | boolean>, callback?: SendCallback): Promise<unknown[]>;
+    }
+    const CROSS_ORIGIN_IFRAMES_FILTER: IframesFilter;
+    function getContext(): Context;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/iframe.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/iframe.d.ts
new file mode 100644
index 0000000..781c92f
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/iframe/iframe.d.ts
@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+export declare function _openIframe(auth: AuthInternal): Promise<gapi.iframes.Iframe>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/index.d.ts
new file mode 100644
index 0000000..ebd5cb8
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/index.d.ts
@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FirebaseApp } from '@firebase/app';
+import { Auth } from '../model/public_types';
+/**
+ * Returns the Auth instance associated with the provided {@link @firebase/app#FirebaseApp}.
+ * If no instance exists, initializes an Auth instance with platform-specific default dependencies.
+ *
+ * @param app - The Firebase App.
+ *
+ * @public
+ */
+export declare function getAuth(app?: FirebaseApp): Auth;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/load_js.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/load_js.d.ts
new file mode 100644
index 0000000..861517a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/load_js.d.ts
@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+interface ExternalJSProvider {
+    loadJS(url: string): Promise<Event>;
+    recaptchaV2Script: string;
+    recaptchaEnterpriseScript: string;
+    gapiScript: string;
+}
+export declare function _setExternalJSProvider(p: ExternalJSProvider): void;
+export declare function _loadJS(url: string): Promise<Event>;
+export declare function _recaptchaV2ScriptUrl(): string;
+export declare function _recaptchaEnterpriseScriptUrl(): string;
+export declare function _gapiScriptUrl(): string;
+export declare function _generateCallbackName(prefix: string): string;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/index.d.ts
new file mode 100644
index 0000000..78beb52
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/index.d.ts
@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PromiseSettledResult } from './promise';
+export declare const enum _TimeoutDuration {
+    ACK = 50,
+    COMPLETION = 3000,
+    LONG_ACK = 800
+}
+/**
+ * Enumeration of possible response types from the Receiver.
+ */
+export declare const enum _Status {
+    ACK = "ack",
+    DONE = "done"
+}
+export declare const enum _MessageError {
+    CONNECTION_CLOSED = "connection_closed",
+    CONNECTION_UNAVAILABLE = "connection_unavailable",
+    INVALID_RESPONSE = "invalid_response",
+    TIMEOUT = "timeout",
+    UNKNOWN = "unknown_error",
+    UNSUPPORTED_EVENT = "unsupported_event"
+}
+/**
+ * Enumeration of possible events sent by the Sender.
+ */
+export declare const enum _EventType {
+    KEY_CHANGED = "keyChanged",
+    PING = "ping"
+}
+/**
+ * Response to a {@link EventType.KEY_CHANGED} event.
+ */
+export interface KeyChangedResponse {
+    keyProcessed: boolean;
+}
+/**
+ * Response to a {@link EventType.PING} event.
+ */
+export type _PingResponse = _EventType[];
+export type _ReceiverResponse = KeyChangedResponse | _PingResponse;
+interface MessageEvent {
+    eventType: _EventType;
+    eventId: string;
+}
+/**
+ * Request for a {@link EventType.KEY_CHANGED} event.
+ */
+export interface KeyChangedRequest {
+    key: string;
+}
+/**
+ * Request for a {@link EventType.PING} event.
+ */
+export interface PingRequest {
+}
+/** Data sent by Sender */
+export type _SenderRequest = KeyChangedRequest | PingRequest;
+/** Receiver handler to process events sent by the Sender */
+export interface ReceiverHandler<T extends _ReceiverResponse, S extends _SenderRequest> {
+    (origin: string, data: S): T | Promise<T>;
+}
+/** Full message sent by Sender  */
+export interface SenderMessageEvent<T extends _SenderRequest> extends MessageEvent {
+    data: T;
+}
+export type _ReceiverMessageResponse<T extends _ReceiverResponse> = Array<PromiseSettledResult<T>> | null;
+/** Full message sent by Receiver */
+export interface ReceiverMessageEvent<T extends _ReceiverResponse> extends MessageEvent {
+    status: _Status;
+    response: _ReceiverMessageResponse<T>;
+}
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/promise.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/promise.d.ts
new file mode 100644
index 0000000..d57013b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/promise.d.ts
@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** TODO: remove this once tslib has a polyfill for Promise.allSettled */
+interface PromiseFulfilledResult<T> {
+    fulfilled: true;
+    value: T;
+}
+interface PromiseRejectedResult {
+    fulfilled: false;
+    reason: any;
+}
+export type PromiseSettledResult<T> = PromiseFulfilledResult<T> | PromiseRejectedResult;
+/**
+ * Shim for Promise.allSettled, note the slightly different format of `fulfilled` vs `status`.
+ *
+ * @param promises - Array of promises to wait on.
+ */
+export declare function _allSettled<T>(promises: Array<Promise<T>>): Promise<Array<PromiseSettledResult<T>>>;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/receiver.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/receiver.d.ts
new file mode 100644
index 0000000..394de7b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/receiver.d.ts
@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ReceiverHandler, _EventType, _ReceiverResponse, _SenderRequest } from './index';
+/**
+ * Interface class for receiving messages.
+ *
+ */
+export declare class Receiver {
+    private readonly eventTarget;
+    private static readonly receivers;
+    private readonly boundEventHandler;
+    private readonly handlersMap;
+    constructor(eventTarget: EventTarget);
+    /**
+     * Obtain an instance of a Receiver for a given event target, if none exists it will be created.
+     *
+     * @param eventTarget - An event target (such as window or self) through which the underlying
+     * messages will be received.
+     */
+    static _getInstance(eventTarget: EventTarget): Receiver;
+    private isListeningto;
+    /**
+     * Fans out a MessageEvent to the appropriate listeners.
+     *
+     * @remarks
+     * Sends an {@link Status.ACK} upon receipt and a {@link Status.DONE} once all handlers have
+     * finished processing.
+     *
+     * @param event - The MessageEvent.
+     *
+     */
+    private handleEvent;
+    /**
+     * Subscribe an event handler for a particular event.
+     *
+     * @param eventType - Event name to subscribe to.
+     * @param eventHandler - The event handler which should receive the events.
+     *
+     */
+    _subscribe<T extends _ReceiverResponse, S extends _SenderRequest>(eventType: _EventType, eventHandler: ReceiverHandler<T, S>): void;
+    /**
+     * Unsubscribe an event handler from a particular event.
+     *
+     * @param eventType - Event name to unsubscribe from.
+     * @param eventHandler - Optional event handler, if none provided, unsubscribe all handlers on this event.
+     *
+     */
+    _unsubscribe<T extends _ReceiverResponse, S extends _SenderRequest>(eventType: _EventType, eventHandler?: ReceiverHandler<T, S>): void;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/sender.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/sender.d.ts
new file mode 100644
index 0000000..a1121b6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/messagechannel/sender.d.ts
@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { _SenderRequest, _EventType, _ReceiverMessageResponse, _ReceiverResponse, _TimeoutDuration } from './index';
+/**
+ * Interface for sending messages and waiting for a completion response.
+ *
+ */
+export declare class Sender {
+    private readonly target;
+    private readonly handlers;
+    constructor(target: ServiceWorker);
+    /**
+     * Unsubscribe the handler and remove it from our tracking Set.
+     *
+     * @param handler - The handler to unsubscribe.
+     */
+    private removeMessageHandler;
+    /**
+     * Send a message to the Receiver located at {@link target}.
+     *
+     * @remarks
+     * We'll first wait a bit for an ACK , if we get one we will wait significantly longer until the
+     * receiver has had a chance to fully process the event.
+     *
+     * @param eventType - Type of event to send.
+     * @param data - The payload of the event.
+     * @param timeout - Timeout for waiting on an ACK from the receiver.
+     *
+     * @returns An array of settled promises from all the handlers that were listening on the receiver.
+     */
+    _send<T extends _ReceiverResponse, S extends _SenderRequest>(eventType: _EventType, data: S, timeout?: _TimeoutDuration): Promise<_ReceiverMessageResponse<T>>;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/mfa/assertions/phone.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/mfa/assertions/phone.d.ts
new file mode 100644
index 0000000..dc0292d
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/mfa/assertions/phone.d.ts
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PhoneMultiFactorAssertion } from '../../../model/public_types';
+import { MultiFactorAssertionImpl } from '../../../mfa/mfa_assertion';
+import { AuthInternal } from '../../../model/auth';
+import { PhoneAuthCredential } from '../../../core/credentials/phone';
+import { FinalizeMfaResponse } from '../../../api/authentication/mfa';
+/**
+ * {@inheritdoc PhoneMultiFactorAssertion}
+ *
+ * @public
+ */
+export declare class PhoneMultiFactorAssertionImpl extends MultiFactorAssertionImpl implements PhoneMultiFactorAssertion {
+    private readonly credential;
+    private constructor();
+    /** @internal */
+    static _fromCredential(credential: PhoneAuthCredential): PhoneMultiFactorAssertionImpl;
+    /** @internal */
+    _finalizeEnroll(auth: AuthInternal, idToken: string, displayName?: string | null): Promise<FinalizeMfaResponse>;
+    /** @internal */
+    _finalizeSignIn(auth: AuthInternal, mfaPendingCredential: string): Promise<FinalizeMfaResponse>;
+}
+/**
+ * Provider for generating a {@link PhoneMultiFactorAssertion}.
+ *
+ * @public
+ */
+export declare class PhoneMultiFactorGenerator {
+    private constructor();
+    /**
+     * Provides a {@link PhoneMultiFactorAssertion} to confirm ownership of the phone second factor.
+     *
+     * @remarks
+     * This method does not work in a Node.js environment.
+     *
+     * @param phoneAuthCredential - A credential provided by {@link PhoneAuthProvider.credential}.
+     * @returns A {@link PhoneMultiFactorAssertion} which can be used with
+     * {@link MultiFactorResolver.resolveSignIn}
+     */
+    static assertion(credential: PhoneAuthCredential): PhoneMultiFactorAssertion;
+    /**
+     * The identifier of the phone second factor: `phone`.
+     */
+    static FACTOR_ID: string;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/browser.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/browser.d.ts
new file mode 100644
index 0000000..5635d97
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/browser.d.ts
@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { PersistenceValue, PersistenceType } from '../../core/persistence';
+export declare abstract class BrowserPersistenceClass {
+    protected readonly storageRetriever: () => Storage;
+    readonly type: PersistenceType;
+    protected constructor(storageRetriever: () => Storage, type: PersistenceType);
+    _isAvailable(): Promise<boolean>;
+    _set(key: string, value: PersistenceValue): Promise<void>;
+    _get<T extends PersistenceValue>(key: string): Promise<T | null>;
+    _remove(key: string): Promise<void>;
+    protected get storage(): Storage;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/cookie_storage.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/cookie_storage.d.ts
new file mode 100644
index 0000000..f30bcef
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/cookie_storage.d.ts
@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Persistence } from '../../model/public_types';
+import { PersistenceInternal, PersistenceType, PersistenceValue, StorageEventListener } from '../../core/persistence';
+export declare class CookiePersistence implements PersistenceInternal {
+    static type: 'COOKIE';
+    readonly type = PersistenceType.COOKIE;
+    listenerUnsubscribes: Map<StorageEventListener, () => void>;
+    _getFinalTarget(originalUrl: string): URL | string;
+    _isAvailable(): Promise<boolean>;
+    _set(_key: string, _value: PersistenceValue): Promise<void>;
+    _get<T extends PersistenceValue>(key: string): Promise<T | null>;
+    _remove(key: string): Promise<void>;
+    _addListener(key: string, listener: StorageEventListener): void;
+    _removeListener(_key: string, listener: StorageEventListener): void;
+}
+/**
+ * An implementation of {@link Persistence} of type `COOKIE`, for use on the client side in
+ * applications leveraging hybrid rendering and middleware.
+ *
+ * @remarks This persistence method requires companion middleware to function, such as that provided
+ * by {@link https://firebaseopensource.com/projects/firebaseextended/reactfire/ | ReactFire} for
+ * NextJS.
+ * @beta
+ */
+export declare const browserCookiePersistence: Persistence;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/indexed_db.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/indexed_db.d.ts
new file mode 100644
index 0000000..23c1604
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/indexed_db.d.ts
@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Persistence } from '../../model/public_types';
+import { PersistenceValue } from '../../core/persistence/';
+export declare const DB_NAME = "firebaseLocalStorageDb";
+export declare function _clearDatabase(db: IDBDatabase): Promise<void>;
+export declare function _deleteDatabase(): Promise<void>;
+export declare function _openDatabase(): Promise<IDBDatabase>;
+export declare function _putObject(db: IDBDatabase, key: string, value: PersistenceValue | string): Promise<void>;
+export declare function _deleteObject(db: IDBDatabase, key: string): Promise<void>;
+export declare const _POLLING_INTERVAL_MS = 800;
+export declare const _TRANSACTION_RETRY_COUNT = 3;
+/**
+ * An implementation of {@link Persistence} of type `LOCAL` using `indexedDB`
+ * for the underlying storage.
+ *
+ * @public
+ */
+export declare const indexedDBLocalPersistence: Persistence;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/local_storage.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/local_storage.d.ts
new file mode 100644
index 0000000..34d8d64
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/local_storage.d.ts
@@ -0,0 +1,25 @@
+/**
+ * @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 { Persistence } from '../../model/public_types';
+export declare const _POLLING_INTERVAL_MS = 1000;
+/**
+ * An implementation of {@link Persistence} of type `LOCAL` using `localStorage`
+ * for the underlying storage.
+ *
+ * @public
+ */
+export declare const browserLocalPersistence: Persistence;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/session_storage.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/session_storage.d.ts
new file mode 100644
index 0000000..117c558
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/persistence/session_storage.d.ts
@@ -0,0 +1,24 @@
+/**
+ * @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 { Persistence } from '../../model/public_types';
+/**
+ * An implementation of {@link Persistence} of `SESSION` using `sessionStorage`
+ * for the underlying storage.
+ *
+ * @public
+ */
+export declare const browserSessionPersistence: Persistence;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/popup_redirect.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/popup_redirect.d.ts
new file mode 100644
index 0000000..61b8ca7
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/popup_redirect.d.ts
@@ -0,0 +1,27 @@
+/**
+ * @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 { PopupRedirectResolver } from '../model/public_types';
+/**
+ * An implementation of {@link PopupRedirectResolver} suitable for browser
+ * based applications.
+ *
+ * @remarks
+ * This method does not work in a Node.js environment.
+ *
+ * @public
+ */
+export declare const browserPopupRedirectResolver: PopupRedirectResolver;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/providers/phone.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/providers/phone.d.ts
new file mode 100644
index 0000000..6c1d728
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/providers/phone.d.ts
@@ -0,0 +1,154 @@
+/**
+ * @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 { Auth, PhoneInfoOptions, ApplicationVerifier, UserCredential } from '../../model/public_types';
+import { PhoneAuthCredential } from '../../core/credentials/phone';
+import { AuthCredential } from '../../core';
+import { FirebaseError } from '@firebase/util';
+/**
+ * Provider for generating an {@link PhoneAuthCredential}.
+ *
+ * @remarks
+ * `PhoneAuthProvider` does not work in a Node.js environment.
+ *
+ * @example
+ * ```javascript
+ * // 'recaptcha-container' is the ID of an element in the DOM.
+ * const applicationVerifier = new RecaptchaVerifier('recaptcha-container');
+ * const provider = new PhoneAuthProvider(auth);
+ * const verificationId = await provider.verifyPhoneNumber('+16505550101', applicationVerifier);
+ * // Obtain the verificationCode from the user.
+ * const phoneCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+ * const userCredential = await signInWithCredential(auth, phoneCredential);
+ * ```
+ *
+ * @public
+ */
+export declare class PhoneAuthProvider {
+    /** Always set to {@link ProviderId}.PHONE. */
+    static readonly PROVIDER_ID: 'phone';
+    /** Always set to {@link SignInMethod}.PHONE. */
+    static readonly PHONE_SIGN_IN_METHOD: 'phone';
+    /** Always set to {@link ProviderId}.PHONE. */
+    readonly providerId: "phone";
+    private readonly auth;
+    /**
+     * @param auth - The Firebase {@link Auth} instance in which sign-ins should occur.
+     *
+     */
+    constructor(auth: Auth);
+    /**
+     *
+     * Starts a phone number authentication flow by sending a verification code to the given phone
+     * number.
+     *
+     * @example
+     * ```javascript
+     * const provider = new PhoneAuthProvider(auth);
+     * const verificationId = await provider.verifyPhoneNumber(phoneNumber, applicationVerifier);
+     * // Obtain verificationCode from the user.
+     * const authCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+     * const userCredential = await signInWithCredential(auth, authCredential);
+     * ```
+     *
+     * @example
+     * An alternative flow is provided using the `signInWithPhoneNumber` method.
+     * ```javascript
+     * const confirmationResult = signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);
+     * // Obtain verificationCode from the user.
+     * const userCredential = confirmationResult.confirm(verificationCode);
+     * ```
+     *
+     * @param phoneInfoOptions - The user's {@link PhoneInfoOptions}. The phone number should be in
+     * E.164 format (e.g. +16505550101).
+     * @param applicationVerifier - An {@link ApplicationVerifier}, which prevents
+     * requests from unauthorized clients. This SDK includes an implementation
+     * based on reCAPTCHA v2, {@link RecaptchaVerifier}. If you've enabled
+     * reCAPTCHA Enterprise bot protection in Enforce mode, this parameter is
+     * optional; in all other configurations, the parameter is required.
+     *
+     * @returns A Promise for a verification ID that can be passed to
+     * {@link PhoneAuthProvider.credential} to identify this flow.
+     */
+    verifyPhoneNumber(phoneOptions: PhoneInfoOptions | string, applicationVerifier?: ApplicationVerifier): Promise<string>;
+    /**
+     * Creates a phone auth credential, given the verification ID from
+     * {@link PhoneAuthProvider.verifyPhoneNumber} and the code that was sent to the user's
+     * mobile device.
+     *
+     * @example
+     * ```javascript
+     * const provider = new PhoneAuthProvider(auth);
+     * const verificationId = provider.verifyPhoneNumber(phoneNumber, applicationVerifier);
+     * // Obtain verificationCode from the user.
+     * const authCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+     * const userCredential = signInWithCredential(auth, authCredential);
+     * ```
+     *
+     * @example
+     * An alternative flow is provided using the `signInWithPhoneNumber` method.
+     * ```javascript
+     * const confirmationResult = await signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);
+     * // Obtain verificationCode from the user.
+     * const userCredential = await confirmationResult.confirm(verificationCode);
+     * ```
+     *
+     * @param verificationId - The verification ID returned from {@link PhoneAuthProvider.verifyPhoneNumber}.
+     * @param verificationCode - The verification code sent to the user's mobile device.
+     *
+     * @returns The auth provider credential.
+     */
+    static credential(verificationId: string, verificationCode: string): PhoneAuthCredential;
+    /**
+     * Generates an {@link AuthCredential} from a {@link UserCredential}.
+     * @param userCredential - The user credential.
+     */
+    static credentialFromResult(userCredential: UserCredential): AuthCredential | null;
+    /**
+     * Returns an {@link AuthCredential} when passed an error.
+     *
+     * @remarks
+     *
+     * This method works for errors like
+     * `auth/account-exists-with-different-credentials`. This is useful for
+     * recovering when attempting to set a user's phone number but the number
+     * in question is already tied to another account. For example, the following
+     * code tries to update the current user's phone number, and if that
+     * fails, links the user with the account associated with that number:
+     *
+     * ```js
+     * const provider = new PhoneAuthProvider(auth);
+     * const verificationId = await provider.verifyPhoneNumber(number, verifier);
+     * try {
+     *   const code = ''; // Prompt the user for the verification code
+     *   await updatePhoneNumber(
+     *       auth.currentUser,
+     *       PhoneAuthProvider.credential(verificationId, code));
+     * } catch (e) {
+     *   if ((e as FirebaseError)?.code === 'auth/account-exists-with-different-credential') {
+     *     const cred = PhoneAuthProvider.credentialFromError(e);
+     *     await linkWithCredential(auth.currentUser, cred);
+     *   }
+     * }
+     *
+     * // At this point, auth.currentUser.phoneNumber === number.
+     * ```
+     *
+     * @param error - The error to generate a credential from.
+     */
+    static credentialFromError(error: FirebaseError): AuthCredential | null;
+    private static credentialFromTaggedObject;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha.d.ts
new file mode 100644
index 0000000..e47806b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha.d.ts
@@ -0,0 +1,78 @@
+/**
+ * @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 { RecaptchaParameters } from '../../model/public_types';
+import { GetRecaptchaConfigResponse, RecaptchaEnforcementProviderState } from '../../api/authentication/recaptcha';
+import { EnforcementState } from '../../api/index';
+export interface Recaptcha {
+    render: (container: HTMLElement, parameters: RecaptchaParameters) => number;
+    getResponse: (id: number) => string;
+    execute: (id: number) => unknown;
+    reset: (id: number) => unknown;
+}
+export declare function isV2(grecaptcha: Recaptcha | GreCAPTCHA | undefined): grecaptcha is Recaptcha;
+export interface GreCAPTCHATopLevel extends GreCAPTCHA {
+    enterprise: GreCAPTCHA;
+}
+export interface GreCAPTCHA {
+    ready: (callback: () => void) => void;
+    execute: (siteKey: string, options: {
+        action: string;
+    }) => Promise<string>;
+    render: (container: string | HTMLElement, parameters: GreCAPTCHARenderOption) => string;
+}
+export interface GreCAPTCHARenderOption {
+    sitekey: string;
+    size: 'invisible';
+}
+export declare function isEnterprise(grecaptcha: Recaptcha | GreCAPTCHA | undefined): grecaptcha is GreCAPTCHATopLevel;
+declare global {
+    interface Window {
+        grecaptcha?: Recaptcha | GreCAPTCHATopLevel;
+    }
+}
+export declare class RecaptchaConfig {
+    /**
+     * The reCAPTCHA site key.
+     */
+    siteKey: string;
+    /**
+     * The list of providers and their enablement status for reCAPTCHA Enterprise.
+     */
+    recaptchaEnforcementState: RecaptchaEnforcementProviderState[];
+    constructor(response: GetRecaptchaConfigResponse);
+    /**
+     * Returns the reCAPTCHA Enterprise enforcement state for the given provider.
+     *
+     * @param providerStr - The provider whose enforcement state is to be returned.
+     * @returns The reCAPTCHA Enterprise enforcement state for the given provider.
+     */
+    getProviderEnforcementState(providerStr: string): EnforcementState | null;
+    /**
+     * Returns true if the reCAPTCHA Enterprise enforcement state for the provider is set to ENFORCE or AUDIT.
+     *
+     * @param providerStr - The provider whose enablement state is to be returned.
+     * @returns Whether or not reCAPTCHA Enterprise protection is enabled for the given provider.
+     */
+    isProviderEnabled(providerStr: string): boolean;
+    /**
+     * Returns true if reCAPTCHA Enterprise protection is enabled in at least one provider, otherwise
+     * returns false.
+     *
+     * @returns Whether or not reCAPTCHA Enterprise protection is enabled for at least one provider.
+     */
+    isAnyProviderEnabled(): boolean;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.d.ts
new file mode 100644
index 0000000..adead53
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.d.ts
@@ -0,0 +1,45 @@
+/**
+ * @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 { RecaptchaActionName, RecaptchaAuthProvider } from '../../api';
+import { Auth } from '../../model/public_types';
+import { AuthInternal } from '../../model/auth';
+export declare const RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = "recaptcha-enterprise";
+export declare const FAKE_TOKEN = "NO_RECAPTCHA";
+export declare class RecaptchaEnterpriseVerifier {
+    /**
+     * Identifies the type of application verifier (e.g. "recaptcha-enterprise").
+     */
+    readonly type = "recaptcha-enterprise";
+    private readonly auth;
+    /**
+     *
+     * @param authExtern - The corresponding Firebase {@link Auth} instance.
+     *
+     */
+    constructor(authExtern: Auth);
+    /**
+     * Executes the verification process.
+     *
+     * @returns A Promise for a token that can be used to assert the validity of a request.
+     */
+    verify(action?: string, forceRefresh?: boolean): Promise<string>;
+}
+export declare function injectRecaptchaFields<T extends object>(auth: AuthInternal, request: T, action: RecaptchaActionName, isCaptchaResp?: boolean, isFakeToken?: boolean): Promise<T>;
+type ActionMethod<TRequest, TResponse> = (auth: AuthInternal, request: TRequest) => Promise<TResponse>;
+export declare function handleRecaptchaFlow<TRequest extends object, TResponse>(authInstance: AuthInternal, request: TRequest, actionName: RecaptchaActionName, actionMethod: ActionMethod<TRequest, TResponse>, recaptchaAuthProvider: RecaptchaAuthProvider): Promise<TResponse>;
+export declare function _initializeRecaptchaConfig(auth: Auth): Promise<void>;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_loader.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_loader.d.ts
new file mode 100644
index 0000000..b0fc1d9
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_loader.d.ts
@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { Recaptcha } from './recaptcha';
+export declare const _JSLOAD_CALLBACK: string;
+/**
+ * We need to mark this interface as internal explicitly to exclude it in the public typings, because
+ * it references AuthInternal which has a circular dependency with UserInternal.
+ *
+ * @internal
+ */
+export interface ReCaptchaLoader {
+    load(auth: AuthInternal, hl?: string): Promise<Recaptcha>;
+    clearedOneInstance(): void;
+}
+/**
+ * Loader for the GReCaptcha library. There should only ever be one of this.
+ */
+export declare class ReCaptchaLoaderImpl implements ReCaptchaLoader {
+    private hostLanguage;
+    private counter;
+    /**
+     * Check for `render()` method. `window.grecaptcha` will exist if the Enterprise
+     * version of the ReCAPTCHA script was loaded by someone else (e.g. App Check) but
+     * `window.grecaptcha.render()` will not. Another load will add it.
+     */
+    private readonly librarySeparatelyLoaded;
+    load(auth: AuthInternal, hl?: string): Promise<Recaptcha>;
+    clearedOneInstance(): void;
+    private shouldResolveImmediately;
+}
+export declare class MockReCaptchaLoaderImpl implements ReCaptchaLoader {
+    load(auth: AuthInternal): Promise<Recaptcha>;
+    clearedOneInstance(): void;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_mock.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_mock.d.ts
new file mode 100644
index 0000000..9cab21a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_mock.d.ts
@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { RecaptchaParameters } from '../../model/public_types';
+import { Recaptcha, GreCAPTCHATopLevel, GreCAPTCHARenderOption, GreCAPTCHA } from './recaptcha';
+export declare const _SOLVE_TIME_MS = 500;
+export declare const _EXPIRATION_TIME_MS = 60000;
+export declare const _WIDGET_ID_START = 1000000000000;
+export interface Widget {
+    getResponse: () => string | null;
+    delete: () => void;
+    execute: () => void;
+}
+export declare class MockReCaptcha implements Recaptcha {
+    private readonly auth;
+    private counter;
+    _widgets: Map<number, Widget>;
+    constructor(auth: AuthInternal);
+    render(container: string | HTMLElement, parameters?: RecaptchaParameters): number;
+    reset(optWidgetId?: number): void;
+    getResponse(optWidgetId?: number): string;
+    execute(optWidgetId?: number | string): Promise<string>;
+}
+export declare class MockGreCAPTCHATopLevel implements GreCAPTCHATopLevel {
+    enterprise: GreCAPTCHA;
+    ready(callback: () => void): void;
+    execute(_siteKey: string, _options: {
+        action: string;
+    }): Promise<string>;
+    render(_container: string | HTMLElement, _parameters: GreCAPTCHARenderOption): string;
+}
+export declare class MockGreCAPTCHA implements GreCAPTCHA {
+    ready(callback: () => void): void;
+    execute(_siteKey: string, _options: {
+        action: string;
+    }): Promise<string>;
+    render(_container: string | HTMLElement, _parameters: GreCAPTCHARenderOption): string;
+}
+export declare class MockWidget {
+    private readonly params;
+    private readonly container;
+    private readonly isVisible;
+    private timerId;
+    private deleted;
+    private responseToken;
+    private readonly clickHandler;
+    constructor(containerOrId: string | HTMLElement, appName: string, params: RecaptchaParameters);
+    getResponse(): string | null;
+    delete(): void;
+    execute(): void;
+    private checkIfDeleted;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_verifier.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_verifier.d.ts
new file mode 100644
index 0000000..cfca5c6
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/recaptcha/recaptcha_verifier.d.ts
@@ -0,0 +1,92 @@
+/**
+ * @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 { Auth, RecaptchaParameters } from '../../model/public_types';
+import { ApplicationVerifierInternal } from '../../model/application_verifier';
+import { ReCaptchaLoader } from './recaptcha_loader';
+export declare const RECAPTCHA_VERIFIER_TYPE = "recaptcha";
+/**
+ * An {@link https://www.google.com/recaptcha/ | reCAPTCHA}-based application verifier.
+ *
+ * @remarks
+ * `RecaptchaVerifier` does not work in a Node.js environment.
+ *
+ * @public
+ */
+export declare class RecaptchaVerifier implements ApplicationVerifierInternal {
+    private readonly parameters;
+    /**
+     * The application verifier type.
+     *
+     * @remarks
+     * For a reCAPTCHA verifier, this is 'recaptcha'.
+     */
+    readonly type = "recaptcha";
+    private destroyed;
+    private widgetId;
+    private readonly container;
+    private readonly isInvisible;
+    private readonly tokenChangeListeners;
+    private renderPromise;
+    private readonly auth;
+    /** @internal */
+    readonly _recaptchaLoader: ReCaptchaLoader;
+    private recaptcha;
+    /**
+     * @param authExtern - The corresponding Firebase {@link Auth} instance.
+     *
+     * @param containerOrId - The reCAPTCHA container parameter.
+     *
+     * @remarks
+     * This has different meaning depending on whether the reCAPTCHA is hidden or visible. For a
+     * visible reCAPTCHA the container must be empty. If a string is used, it has to correspond to
+     * an element ID. The corresponding element must also must be in the DOM at the time of
+     * initialization.
+     *
+     * @param parameters - The optional reCAPTCHA parameters.
+     *
+     * @remarks
+     * Check the reCAPTCHA docs for a comprehensive list. All parameters are accepted except for
+     * the sitekey. Firebase Auth backend provisions a reCAPTCHA for each project and will
+     * configure this upon rendering. For an invisible reCAPTCHA, a size key must have the value
+     * 'invisible'.
+     */
+    constructor(authExtern: Auth, containerOrId: HTMLElement | string, parameters?: RecaptchaParameters);
+    /**
+     * Waits for the user to solve the reCAPTCHA and resolves with the reCAPTCHA token.
+     *
+     * @returns A Promise for the reCAPTCHA token.
+     */
+    verify(): Promise<string>;
+    /**
+     * Renders the reCAPTCHA widget on the page.
+     *
+     * @returns A Promise that resolves with the reCAPTCHA widget ID.
+     */
+    render(): Promise<number>;
+    /** @internal */
+    _reset(): void;
+    /**
+     * Clears the reCAPTCHA widget from the page and destroys the instance.
+     */
+    clear(): void;
+    private validateStartingState;
+    private makeTokenCallback;
+    private assertNotDestroyed;
+    private makeRenderPromise;
+    private init;
+    private getAssertedRecaptcha;
+}
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/phone.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/phone.d.ts
new file mode 100644
index 0000000..26dab0b
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/phone.d.ts
@@ -0,0 +1,116 @@
+/**
+ * @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 { ApplicationVerifier, Auth, ConfirmationResult, PhoneInfoOptions, User } from '../../model/public_types';
+import { ApplicationVerifierInternal } from '../../model/application_verifier';
+import { PhoneAuthCredential } from '../../core/credentials/phone';
+import { AuthInternal } from '../../model/auth';
+/**
+ * Asynchronously signs in using a phone number.
+ *
+ * @remarks
+ * This method sends a code via SMS to the given
+ * phone number, and returns a {@link ConfirmationResult}. After the user
+ * provides the code sent to their phone, call {@link ConfirmationResult.confirm}
+ * with the code to sign the user in.
+ *
+ * For abuse prevention, this method requires a {@link ApplicationVerifier}.
+ * This SDK includes an implementation based on reCAPTCHA v2, {@link RecaptchaVerifier}.
+ * This function can work on other platforms that do not support the
+ * {@link RecaptchaVerifier} (like React Native), but you need to use a
+ * third-party {@link ApplicationVerifier} implementation.
+ *
+ * If you've enabled project-level reCAPTCHA Enterprise bot protection in
+ * Enforce mode, you can omit the {@link ApplicationVerifier}.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // 'recaptcha-container' is the ID of an element in the DOM.
+ * const applicationVerifier = new firebase.auth.RecaptchaVerifier('recaptcha-container');
+ * const confirmationResult = await signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);
+ * // Obtain a verificationCode from the user.
+ * const credential = await confirmationResult.confirm(verificationCode);
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).
+ * @param appVerifier - The {@link ApplicationVerifier}.
+ *
+ * @public
+ */
+export declare function signInWithPhoneNumber(auth: Auth, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
+/**
+ * Links the user account with the given phone number.
+ *
+ * @remarks
+ * This method does not work in a Node.js environment.
+ *
+ * @param user - The user.
+ * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).
+ * @param appVerifier - The {@link ApplicationVerifier}.
+ *
+ * @public
+ */
+export declare function linkWithPhoneNumber(user: User, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
+/**
+ * Re-authenticates a user using a fresh phone credential.
+ *
+ * @remarks
+ * Use before operations such as {@link updatePassword} that require tokens from recent sign-in attempts.
+ *
+ * This method does not work in a Node.js environment or on any {@link User} signed in by
+ * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @param user - The user.
+ * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).
+ * @param appVerifier - The {@link ApplicationVerifier}.
+ *
+ * @public
+ */
+export declare function reauthenticateWithPhoneNumber(user: User, phoneNumber: string, appVerifier?: ApplicationVerifier): Promise<ConfirmationResult>;
+/**
+ * Returns a verification ID to be used in conjunction with the SMS code that is sent.
+ *
+ */
+export declare function _verifyPhoneNumber(auth: AuthInternal, options: PhoneInfoOptions | string, verifier?: ApplicationVerifierInternal): Promise<string>;
+/**
+ * Updates the user's phone number.
+ *
+ * @remarks
+ * This method does not work in a Node.js environment or on any {@link User} signed in by
+ * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```
+ * // 'recaptcha-container' is the ID of an element in the DOM.
+ * const applicationVerifier = new RecaptchaVerifier('recaptcha-container');
+ * const provider = new PhoneAuthProvider(auth);
+ * const verificationId = await provider.verifyPhoneNumber('+16505550101', applicationVerifier);
+ * // Obtain the verificationCode from the user.
+ * const phoneCredential = PhoneAuthProvider.credential(verificationId, verificationCode);
+ * await updatePhoneNumber(user, phoneCredential);
+ * ```
+ *
+ * @param user - The user.
+ * @param credential - A credential authenticating the new phone number.
+ *
+ * @public
+ */
+export declare function updatePhoneNumber(user: User, credential: PhoneAuthCredential): Promise<void>;
+export declare function injectRecaptchaV2Token<T extends object>(auth: AuthInternal, request: T, recaptchaV2Verifier: ApplicationVerifierInternal): Promise<T>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/popup.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/popup.d.ts
new file mode 100644
index 0000000..72ba03a
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/popup.d.ts
@@ -0,0 +1,109 @@
+/**
+ * @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 { Auth, AuthProvider, PopupRedirectResolver, User, UserCredential } from '../../model/public_types';
+import { Delay } from '../../core/util/delay';
+export declare const enum _Timeout {
+    AUTH_EVENT = 8000
+}
+export declare const _POLL_WINDOW_CLOSE_TIMEOUT: Delay;
+/**
+ * Authenticates a Firebase client using a popup-based OAuth authentication flow.
+ *
+ * @remarks
+ * If succeeds, returns the signed in user along with the provider's credential. If sign in was
+ * unsuccessful, returns an error object containing additional information about the error.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new FacebookAuthProvider();
+ * const result = await signInWithPopup(auth, provider);
+ *
+ * // The signed-in user info.
+ * const user = result.user;
+ * // This gives you a Facebook Access Token.
+ * const credential = provider.credentialFromResult(auth, result);
+ * const token = credential.accessToken;
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+export declare function signInWithPopup(auth: Auth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+/**
+ * Reauthenticates the current user with the specified {@link OAuthProvider} using a pop-up based
+ * OAuth flow.
+ *
+ * @remarks
+ * If the reauthentication is successful, the returned result will contain the user and the
+ * provider's credential.
+ *
+ * This method does not work in a Node.js environment or on any {@link User} signed in by
+ * {@link Auth} instances created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a popup.
+ * const provider = new FacebookAuthProvider();
+ * const result = await signInWithPopup(auth, provider);
+ * // Reauthenticate using a popup.
+ * await reauthenticateWithPopup(result.user, provider);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+export declare function reauthenticateWithPopup(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+/**
+ * Links the authenticated provider to the user account using a pop-up based OAuth flow.
+ *
+ * @remarks
+ * If the linking is successful, the returned result will contain the user and the provider's credential.
+ *
+ * This method does not work in a Node.js environment.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using some other provider.
+ * const result = await signInWithEmailAndPassword(auth, email, password);
+ * // Link using a popup.
+ * const provider = new FacebookAuthProvider();
+ * await linkWithPopup(result.user, provider);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+export declare function linkWithPopup(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/redirect.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/redirect.d.ts
new file mode 100644
index 0000000..d0a9ae5
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/strategies/redirect.d.ts
@@ -0,0 +1,176 @@
+/**
+ * @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 { Auth, AuthProvider, PopupRedirectResolver, User, UserCredential } from '../../model/public_types';
+/**
+ * Authenticates a Firebase client using a full-page redirect flow.
+ *
+ * @remarks
+ * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+ * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+ * | best practices} when using {@link signInWithRedirect}.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * // You can add additional scopes to the provider:
+ * provider.addScope('user_birthday');
+ * // Start a sign in process for an unauthenticated user.
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ *   // This is the signed-in user
+ *   const user = result.user;
+ *   // This gives you a Facebook Access Token.
+ *   const credential = provider.credentialFromResult(auth, result);
+ *   const token = credential.accessToken;
+ * }
+ * // As this API can be used for sign-in, linking and reauthentication,
+ * // check the operationType to determine what triggered this redirect
+ * // operation.
+ * const operationType = result.operationType;
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+export declare function signInWithRedirect(auth: Auth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
+export declare function _signInWithRedirect(auth: Auth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<void | never>;
+/**
+ * Reauthenticates the current user with the specified {@link OAuthProvider} using a full-page redirect flow.
+ * @remarks
+ * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+ * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+ * | best practices} when using {@link reauthenticateWithRedirect}.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances
+ * created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * const result = await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * // Reauthenticate using a redirect.
+ * await reauthenticateWithRedirect(result.user, provider);
+ * // This will again trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+export declare function reauthenticateWithRedirect(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
+export declare function _reauthenticateWithRedirect(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<void | never>;
+/**
+ * Links the {@link OAuthProvider} to the user account using a full-page redirect flow.
+ * @remarks
+ * To handle the results and errors for this operation, refer to {@link getRedirectResult}.
+ * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices
+ * | best practices} when using {@link linkWithRedirect}.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances
+ * created with a {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using some other provider.
+ * const result = await signInWithEmailAndPassword(auth, email, password);
+ * // Link using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * await linkWithRedirect(result.user, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * ```
+ *
+ * @param user - The user.
+ * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.
+ * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+export declare function linkWithRedirect(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<never>;
+export declare function _linkWithRedirect(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<void | never>;
+/**
+ * Returns a {@link UserCredential} from the redirect-based sign-in flow.
+ *
+ * @remarks
+ * If sign-in succeeded, returns the signed in user. If sign-in was unsuccessful, fails with an
+ * error. If no redirect operation was called, returns `null`.
+ *
+ * This method does not work in a Node.js environment or with {@link Auth} instances created with a
+ * {@link @firebase/app#FirebaseServerApp}.
+ *
+ * @example
+ * ```javascript
+ * // Sign in using a redirect.
+ * const provider = new FacebookAuthProvider();
+ * // You can add additional scopes to the provider:
+ * provider.addScope('user_birthday');
+ * // Start a sign in process for an unauthenticated user.
+ * await signInWithRedirect(auth, provider);
+ * // This will trigger a full page redirect away from your app
+ *
+ * // After returning from the redirect when your app initializes you can obtain the result
+ * const result = await getRedirectResult(auth);
+ * if (result) {
+ *   // This is the signed-in user
+ *   const user = result.user;
+ *   // This gives you a Facebook Access Token.
+ *   const credential = provider.credentialFromResult(auth, result);
+ *   const token = credential.accessToken;
+ * }
+ * // As this API can be used for sign-in, linking and reauthentication,
+ * // check the operationType to determine what triggered this redirect
+ * // operation.
+ * const operationType = result.operationType;
+ * ```
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param resolver - An instance of {@link PopupRedirectResolver}, optional
+ * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.
+ *
+ * @public
+ */
+export declare function getRedirectResult(auth: Auth, resolver?: PopupRedirectResolver): Promise<UserCredential | null>;
+export declare function _getRedirectResult(auth: Auth, resolverExtern?: PopupRedirectResolver, bypassAuthState?: boolean): Promise<UserCredential | null>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/util/popup.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/util/popup.d.ts
new file mode 100644
index 0000000..111ca83
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/util/popup.d.ts
@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+export declare class AuthPopup {
+    readonly window: Window | null;
+    associatedEvent: string | null;
+    constructor(window: Window | null);
+    close(): void;
+}
+export declare function _open(auth: AuthInternal, url?: string, name?: string, width?: number, height?: number): AuthPopup;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/util/worker.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/util/worker.d.ts
new file mode 100644
index 0000000..c871903
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_browser/util/worker.d.ts
@@ -0,0 +1,20 @@
+/**
+ * @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 declare function _isWorker(): boolean;
+export declare function _getActiveServiceWorker(): Promise<ServiceWorker | null>;
+export declare function _getServiceWorkerController(): ServiceWorker | null;
+export declare function _getWorkerGlobalScope(): ServiceWorker | null;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/plugins.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/plugins.d.ts
new file mode 100644
index 0000000..d3e157d
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/plugins.d.ts
@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+export interface CordovaWindow extends Window {
+    cordova: {
+        plugins: {
+            browsertab: {
+                isAvailable(cb: (available: boolean) => void): void;
+                openUrl(url: string): void;
+                close(): void;
+            };
+        };
+        InAppBrowser: {
+            open(url: string, target: string, options: string): InAppBrowserRef;
+        };
+    };
+    universalLinks: {
+        subscribe(n: null, cb: (event: Record<string, string> | null) => void): void;
+    };
+    BuildInfo: {
+        readonly packageName: string;
+        readonly displayName: string;
+    };
+    handleOpenURL(url: string): void;
+}
+export interface InAppBrowserRef {
+    close?: () => void;
+}
+export declare function _cordovaWindow(): CordovaWindow;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/events.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/events.d.ts
new file mode 100644
index 0000000..0e5a406
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/events.d.ts
@@ -0,0 +1,39 @@
+/**
+ * @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 { AuthEventManager } from '../../core/auth/auth_event_manager';
+import { AuthInternal } from '../../model/auth';
+import { AuthEvent, AuthEventType } from '../../model/popup_redirect';
+/** Custom AuthEventManager that adds passive listeners to events */
+export declare class CordovaAuthEventManager extends AuthEventManager {
+    private readonly passiveListeners;
+    private resolveInitialized;
+    private initPromise;
+    addPassiveListener(cb: (e: AuthEvent) => void): void;
+    removePassiveListener(cb: (e: AuthEvent) => void): void;
+    resetRedirect(): void;
+    /** Override the onEvent method */
+    onEvent(event: AuthEvent): boolean;
+    initialized(): Promise<void>;
+}
+/**
+ * Generates a (partial) {@link AuthEvent}.
+ */
+export declare function _generateNewEvent(auth: AuthInternal, type: AuthEventType, eventId?: string | null): AuthEvent;
+export declare function _savePartialEvent(auth: AuthInternal, event: AuthEvent): Promise<void>;
+export declare function _getAndRemoveEvent(auth: AuthInternal): Promise<AuthEvent | null>;
+export declare function _eventFromPartialAndUrl(partialEvent: AuthEvent, url: string): AuthEvent | null;
+export declare function _getDeepLinkFromCallback(url: string): string;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/popup_redirect.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/popup_redirect.d.ts
new file mode 100644
index 0000000..2bbf02c
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/popup_redirect.d.ts
@@ -0,0 +1,24 @@
+/**
+ * @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 { PopupRedirectResolver } from '../../model/public_types';
+/**
+ * An implementation of {@link PopupRedirectResolver} suitable for Cordova
+ * based applications.
+ *
+ * @public
+ */
+export declare const cordovaPopupRedirectResolver: PopupRedirectResolver;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/utils.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/utils.d.ts
new file mode 100644
index 0000000..b9feb06
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/popup_redirect/utils.d.ts
@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthProvider } from '../../model/public_types';
+import { AuthInternal } from '../../model/auth';
+import { AuthEvent } from '../../model/popup_redirect';
+import { InAppBrowserRef } from '../plugins';
+/**
+ * Generates the URL for the OAuth handler.
+ */
+export declare function _generateHandlerUrl(auth: AuthInternal, event: AuthEvent, provider: AuthProvider): Promise<string>;
+/**
+ * Validates that this app is valid for this project configuration
+ */
+export declare function _validateOrigin(auth: AuthInternal): Promise<void>;
+export declare function _performRedirect(handlerUrl: string): Promise<InAppBrowserRef | null>;
+interface PassiveAuthEventListener {
+    addPassiveListener(cb: () => void): void;
+    removePassiveListener(cb: () => void): void;
+}
+/**
+ * This function waits for app activity to be seen before resolving. It does
+ * this by attaching listeners to various dom events. Once the app is determined
+ * to be visible, this promise resolves. AFTER that resolution, the listeners
+ * are detached and any browser tabs left open will be closed.
+ */
+export declare function _waitForAppResume(auth: AuthInternal, eventListener: PassiveAuthEventListener, iabRef: InAppBrowserRef | null): Promise<void>;
+/**
+ * Checks the configuration of the Cordova environment. This has no side effect
+ * if the configuration is correct; otherwise it throws an error with the
+ * missing plugin.
+ */
+export declare function _checkCordovaConfiguration(auth: AuthInternal): void;
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/strategies/redirect.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/strategies/redirect.d.ts
new file mode 100644
index 0000000..9dbd547
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_cordova/strategies/redirect.d.ts
@@ -0,0 +1,20 @@
+/**
+ * @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 { Auth, AuthProvider, PopupRedirectResolver, User } from '../../model/public_types';
+export declare function signInWithRedirect(auth: Auth, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<void>;
+export declare function reauthenticateWithRedirect(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<void>;
+export declare function linkWithRedirect(user: User, provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<void>;
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_node/index.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_node/index.d.ts
new file mode 100644
index 0000000..e84ba55
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_node/index.d.ts
@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FirebaseApp } from '@firebase/app';
+import { Auth } from '../model/public_types';
+export declare function getAuth(app?: FirebaseApp): Auth;
+/** Reject with auth/operation-not-supported-in-this-environment */
+declare function fail(): Promise<void>;
+/**
+ * A class which will throw with
+ * auth/operation-not-supported-in-this-environment if instantiated
+ */
+declare class FailClass {
+    constructor();
+}
+export declare const browserLocalPersistence: import("../model/public_types").Persistence;
+export declare const browserSessionPersistence: import("../model/public_types").Persistence;
+export declare const browserCookiePersistence: import("../model/public_types").Persistence;
+export declare const indexedDBLocalPersistence: import("../model/public_types").Persistence;
+export declare const browserPopupRedirectResolver: import("@firebase/app").FirebaseError;
+export declare const PhoneAuthProvider: typeof FailClass;
+export declare const signInWithPhoneNumber: typeof fail;
+export declare const linkWithPhoneNumber: typeof fail;
+export declare const reauthenticateWithPhoneNumber: typeof fail;
+export declare const updatePhoneNumber: typeof fail;
+export declare const signInWithPopup: typeof fail;
+export declare const linkWithPopup: typeof fail;
+export declare const reauthenticateWithPopup: typeof fail;
+export declare const signInWithRedirect: typeof fail;
+export declare const linkWithRedirect: typeof fail;
+export declare const reauthenticateWithRedirect: typeof fail;
+export declare const getRedirectResult: typeof fail;
+export declare const RecaptchaVerifier: typeof FailClass;
+export declare const initializeRecaptchaConfig: typeof fail;
+export declare class PhoneMultiFactorGenerator {
+    static assertion(): unknown;
+}
+export {};
diff --git a/frontend-old/node_modules/@firebase/auth/dist/src/platform_react_native/persistence/react_native.d.ts b/frontend-old/node_modules/@firebase/auth/dist/src/platform_react_native/persistence/react_native.d.ts
new file mode 100644
index 0000000..fed8b9f
--- /dev/null
+++ b/frontend-old/node_modules/@firebase/auth/dist/src/platform_react_native/persistence/react_native.d.ts
@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Persistence, ReactNativeAsyncStorage } from '../../model/public_types';
+/**
+ * Returns a persistence object that wraps `AsyncStorage` imported from
+ * `react-native` or `@react-native-community/async-storage`, and can
+ * be used in the persistence dependency field in {@link initializeAuth}.
+ *
+ * @public
+ */
+export declare function getReactNativePersistence(storage: ReactNativeAsyncStorage): Persistence;