@angular/fire 19.2.0 → 20.0.0-canary.eb99d8e

package/ai/index.d.ts

@@ -1,5 +1,32 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/ai" />
-export * from './public_api';
+import * as rxjs from 'rxjs';
+import { AI as AI$1, getAI as getAI$1, getGenerativeModel as getGenerativeModel$1, getImagenModel as getImagenModel$1, getVertexAI as getVertexAI$1 } from 'firebase/ai';
+export * from 'firebase/ai';
+import * as i0 from '@angular/core';
+import { Injector, EnvironmentProviders } from '@angular/core';
+
+interface AI extends AI$1 {
+}
+declare class AI {
+    constructor(ai: AI$1);
+}
+interface AIInstances extends Array<AI$1> {
+}
+declare class AIInstances {
+    constructor();
+}
+declare const AIInstance$: rxjs.Observable<AI$1>;
+
+declare class AIModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AIModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AIModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AIModule>;
+}
+declare function provideAI(fn: (injector: Injector) => AI$1, ...deps: any[]): EnvironmentProviders;
+
+declare const getAI: typeof getAI$1;
+declare const getGenerativeModel: typeof getGenerativeModel$1;
+declare const getImagenModel: typeof getImagenModel$1;
+declare const getVertexAI: typeof getVertexAI$1;
+
+export { AI, AIInstance$, AIInstances, AIModule, getAI, getGenerativeModel, getImagenModel, getVertexAI, provideAI };

package/analytics/index.d.ts

@@ -1,5 +1,87 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/analytics" />
-export * from './public_api';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { Analytics as Analytics$1, getAnalytics as getAnalytics$1, getGoogleAnalyticsClientId as getGoogleAnalyticsClientId$1, initializeAnalytics as initializeAnalytics$1, isSupported as isSupported$1, logEvent as logEvent$1, setAnalyticsCollectionEnabled as setAnalyticsCollectionEnabled$1, setConsent as setConsent$1, setCurrentScreen as setCurrentScreen$1, setDefaultEventParameters as setDefaultEventParameters$1, setUserId as setUserId$1, setUserProperties as setUserProperties$1, settings as settings$1 } from 'firebase/analytics';
+export * from 'firebase/analytics';
+import * as i0 from '@angular/core';
+import { OnDestroy, NgZone, Injector, ComponentFactoryResolver, EnvironmentProviders } from '@angular/core';
+import { Title } from '@angular/platform-browser';
+import { Router } from '@angular/router';
+import { Auth } from '@angular/fire/auth';
+
+interface Analytics extends Analytics$1 {
+}
+declare class Analytics {
+    constructor(analytics: Analytics$1);
+}
+interface AnalyticsInstances extends Array<Analytics$1> {
+}
+declare class AnalyticsInstances {
+    constructor();
+}
+declare const analyticInstance$: rxjs.Observable<Analytics$1>;
+
+declare class UserTrackingService implements OnDestroy {
+    readonly initialized: Promise<void>;
+    private disposables;
+    constructor(auth: Auth, zone: NgZone, injector: Injector);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserTrackingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserTrackingService>;
+}
+
+declare const FIREBASE_EVENT_ORIGIN_KEY = "firebase_event_origin";
+declare const FIREBASE_PREVIOUS_SCREEN_CLASS_KEY = "firebase_previous_class";
+declare const FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY = "firebase_previous_id";
+declare const FIREBASE_PREVIOUS_SCREEN_NAME_KEY = "firebase_previous_screen";
+declare const FIREBASE_SCREEN_CLASS_KEY = "firebase_screen_class";
+declare const FIREBASE_SCREEN_INSTANCE_ID_KEY = "firebase_screen_id";
+declare const FIREBASE_SCREEN_NAME_KEY = "firebase_screen";
+declare const OUTLET_KEY = "outlet";
+declare const PAGE_PATH_KEY = "page_path";
+declare const PAGE_TITLE_KEY = "page_title";
+declare const SCREEN_CLASS_KEY = "screen_class";
+declare const SCREEN_NAME_KEY = "screen_name";
+declare const ɵscreenViewEvent: (router: Router, title: Title | null, componentFactoryResolver: ComponentFactoryResolver) => Observable<{
+    [SCREEN_NAME_KEY]: string;
+    [PAGE_PATH_KEY]: string;
+    [FIREBASE_EVENT_ORIGIN_KEY]: "auto";
+    [FIREBASE_SCREEN_NAME_KEY]: string;
+    [OUTLET_KEY]: string;
+    [PAGE_TITLE_KEY]?: string;
+    [SCREEN_CLASS_KEY]: string;
+    [FIREBASE_SCREEN_CLASS_KEY]: string;
+    [FIREBASE_SCREEN_INSTANCE_ID_KEY]: number;
+    [FIREBASE_PREVIOUS_SCREEN_CLASS_KEY]: string;
+    [FIREBASE_PREVIOUS_SCREEN_NAME_KEY]: string;
+    [FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY]: number;
+}>;
+declare class ScreenTrackingService implements OnDestroy {
+    private disposable;
+    constructor(router: Router, title: Title, componentFactoryResolver: ComponentFactoryResolver, zone: NgZone, userTrackingService: UserTrackingService, injector: Injector);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenTrackingService, [{ optional: true; }, { optional: true; }, null, null, { optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenTrackingService>;
+}
+
+declare class AnalyticsModule {
+    constructor(_screenTrackingService: ScreenTrackingService, _userTrackingService: UserTrackingService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsModule, [{ optional: true; }, { optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AnalyticsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AnalyticsModule>;
+}
+declare function provideAnalytics(fn: (injector: Injector) => Analytics$1, ...deps: any[]): EnvironmentProviders;
+
+declare const getAnalytics: typeof getAnalytics$1;
+declare const getGoogleAnalyticsClientId: typeof getGoogleAnalyticsClientId$1;
+declare const initializeAnalytics: typeof initializeAnalytics$1;
+declare const isSupported: typeof isSupported$1;
+declare const logEvent: typeof logEvent$1;
+declare const setAnalyticsCollectionEnabled: typeof setAnalyticsCollectionEnabled$1;
+declare const setConsent: typeof setConsent$1;
+declare const setCurrentScreen: typeof setCurrentScreen$1;
+declare const setDefaultEventParameters: typeof setDefaultEventParameters$1;
+declare const setUserId: typeof setUserId$1;
+declare const setUserProperties: typeof setUserProperties$1;
+declare const settings: typeof settings$1;
+
+export { Analytics, AnalyticsInstances, AnalyticsModule, ScreenTrackingService, UserTrackingService, analyticInstance$, getAnalytics, getGoogleAnalyticsClientId, initializeAnalytics, isSupported, logEvent, provideAnalytics, setAnalyticsCollectionEnabled, setConsent, setCurrentScreen, setDefaultEventParameters, setUserId, setUserProperties, settings, ɵscreenViewEvent };

package/app/index.d.ts

@@ -1,5 +1,36 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/app" />
-export * from './public_api';
+import * as rxjs from 'rxjs';
+import { FirebaseApp as FirebaseApp$1, deleteApp as deleteApp$1, getApp as getApp$1, getApps as getApps$1, initializeApp as initializeApp$1, initializeServerApp as initializeServerApp$1, onLog as onLog$1, registerVersion as registerVersion$1, setLogLevel as setLogLevel$1 } from 'firebase/app';
+export * from 'firebase/app';
+import * as i0 from '@angular/core';
+import { Injector, EnvironmentProviders } from '@angular/core';
+
+interface FirebaseApp extends FirebaseApp$1 {
+}
+declare class FirebaseApp {
+    constructor(app: FirebaseApp$1);
+}
+interface FirebaseApps extends Array<FirebaseApp$1> {
+}
+declare class FirebaseApps {
+    constructor();
+}
+declare const firebaseApp$: rxjs.Observable<FirebaseApp$1>;
+
+declare class FirebaseAppModule {
+    constructor(platformId: Object);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FirebaseAppModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FirebaseAppModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FirebaseAppModule>;
+}
+declare function provideFirebaseApp(fn: (injector: Injector) => FirebaseApp$1, ...deps: any[]): EnvironmentProviders;
+
+declare const deleteApp: typeof deleteApp$1;
+declare const getApp: typeof getApp$1;
+declare const getApps: typeof getApps$1;
+declare const initializeApp: typeof initializeApp$1;
+declare const initializeServerApp: typeof initializeServerApp$1;
+declare const onLog: typeof onLog$1;
+declare const registerVersion: typeof registerVersion$1;
+declare const setLogLevel: typeof setLogLevel$1;
+
+export { FirebaseApp, FirebaseAppModule, FirebaseApps, deleteApp, firebaseApp$, getApp, getApps, initializeApp, initializeServerApp, onLog, provideFirebaseApp, registerVersion, setLogLevel };

package/app-check/index.d.ts

@@ -1,5 +1,33 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/app-check" />
-export * from './public_api';
+import * as rxjs from 'rxjs';
+import { AppCheck as AppCheck$1, getLimitedUseToken as getLimitedUseToken$1, getToken as getToken$1, initializeAppCheck as initializeAppCheck$1, onTokenChanged as onTokenChanged$1, setTokenAutoRefreshEnabled as setTokenAutoRefreshEnabled$1 } from 'firebase/app-check';
+export * from 'firebase/app-check';
+import * as i0 from '@angular/core';
+import { Injector, EnvironmentProviders } from '@angular/core';
+
+interface AppCheck extends AppCheck$1 {
+}
+declare class AppCheck {
+    constructor(appCheck: AppCheck$1);
+}
+interface AppCheckInstances extends Array<AppCheck> {
+}
+declare class AppCheckInstances {
+    constructor();
+}
+declare const appCheckInstance$: rxjs.Observable<AppCheck$1>;
+
+declare class AppCheckModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppCheckModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AppCheckModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AppCheckModule>;
+}
+declare function provideAppCheck(fn: (injector: Injector) => AppCheck$1, ...deps: any[]): EnvironmentProviders;
+
+declare const getLimitedUseToken: typeof getLimitedUseToken$1;
+declare const getToken: typeof getToken$1;
+declare const initializeAppCheck: typeof initializeAppCheck$1;
+declare const onTokenChanged: typeof onTokenChanged$1;
+declare const setTokenAutoRefreshEnabled: typeof setTokenAutoRefreshEnabled$1;
+
+export { AppCheck, AppCheckInstances, AppCheckModule, appCheckInstance$, getLimitedUseToken, getToken, initializeAppCheck, onTokenChanged, provideAppCheck, setTokenAutoRefreshEnabled };

package/auth/index.d.ts

@@ -1,5 +1,86 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/auth" />
-export * from './public_api';
+import * as rxjs from 'rxjs';
+import { Auth as Auth$1, applyActionCode as applyActionCode$1, beforeAuthStateChanged as beforeAuthStateChanged$1, checkActionCode as checkActionCode$1, confirmPasswordReset as confirmPasswordReset$1, connectAuthEmulator as connectAuthEmulator$1, createUserWithEmailAndPassword as createUserWithEmailAndPassword$1, deleteUser as deleteUser$1, fetchSignInMethodsForEmail as fetchSignInMethodsForEmail$1, getAdditionalUserInfo as getAdditionalUserInfo$1, getAuth as getAuth$1, getIdToken as getIdToken$1, getIdTokenResult as getIdTokenResult$1, getMultiFactorResolver as getMultiFactorResolver$1, getRedirectResult as getRedirectResult$1, initializeAuth as initializeAuth$1, initializeRecaptchaConfig as initializeRecaptchaConfig$1, isSignInWithEmailLink as isSignInWithEmailLink$1, linkWithCredential as linkWithCredential$1, linkWithPhoneNumber as linkWithPhoneNumber$1, linkWithPopup as linkWithPopup$1, linkWithRedirect as linkWithRedirect$1, onAuthStateChanged as onAuthStateChanged$1, onIdTokenChanged as onIdTokenChanged$1, parseActionCodeURL as parseActionCodeURL$1, reauthenticateWithCredential as reauthenticateWithCredential$1, reauthenticateWithPhoneNumber as reauthenticateWithPhoneNumber$1, reauthenticateWithPopup as reauthenticateWithPopup$1, reauthenticateWithRedirect as reauthenticateWithRedirect$1, reload as reload$1, revokeAccessToken as revokeAccessToken$1, sendEmailVerification as sendEmailVerification$1, sendPasswordResetEmail as sendPasswordResetEmail$1, sendSignInLinkToEmail as sendSignInLinkToEmail$1, setPersistence as setPersistence$1, signInAnonymously as signInAnonymously$1, signInWithCredential as signInWithCredential$1, signInWithCustomToken as signInWithCustomToken$1, signInWithEmailAndPassword as signInWithEmailAndPassword$1, signInWithEmailLink as signInWithEmailLink$1, signInWithPhoneNumber as signInWithPhoneNumber$1, signInWithPopup as signInWithPopup$1, signInWithRedirect as signInWithRedirect$1, signOut as signOut$1, unlink as unlink$1, updateCurrentUser as updateCurrentUser$1, updateEmail as updateEmail$1, updatePassword as updatePassword$1, updatePhoneNumber as updatePhoneNumber$1, updateProfile as updateProfile$1, useDeviceLanguage as useDeviceLanguage$1, validatePassword as validatePassword$1, verifyBeforeUpdateEmail as verifyBeforeUpdateEmail$1, verifyPasswordResetCode as verifyPasswordResetCode$1 } from 'firebase/auth';
+export * from 'firebase/auth';
+import * as i0 from '@angular/core';
+import { Injector, EnvironmentProviders } from '@angular/core';
+import { authState as authState$1, idToken as idToken$1, user as user$1 } from 'rxfire/auth';
+
+interface Auth extends Auth$1 {
+}
+declare class Auth {
+    constructor(auth: Auth$1);
+}
+interface AuthInstances extends Array<Auth$1> {
+}
+declare class AuthInstances {
+    constructor();
+}
+declare const authInstance$: rxjs.Observable<Auth$1>;
+
+declare class AuthModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AuthModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AuthModule>;
+}
+declare function provideAuth(fn: (injector: Injector) => Auth$1, ...deps: any[]): EnvironmentProviders;
+
+declare const authState: typeof authState$1;
+declare const idToken: typeof idToken$1;
+declare const user: typeof user$1;
+
+declare const applyActionCode: typeof applyActionCode$1;
+declare const beforeAuthStateChanged: typeof beforeAuthStateChanged$1;
+declare const checkActionCode: typeof checkActionCode$1;
+declare const confirmPasswordReset: typeof confirmPasswordReset$1;
+declare const connectAuthEmulator: typeof connectAuthEmulator$1;
+declare const createUserWithEmailAndPassword: typeof createUserWithEmailAndPassword$1;
+declare const deleteUser: typeof deleteUser$1;
+declare const fetchSignInMethodsForEmail: typeof fetchSignInMethodsForEmail$1;
+declare const getAdditionalUserInfo: typeof getAdditionalUserInfo$1;
+declare const getAuth: typeof getAuth$1;
+declare const getIdToken: typeof getIdToken$1;
+declare const getIdTokenResult: typeof getIdTokenResult$1;
+declare const getMultiFactorResolver: typeof getMultiFactorResolver$1;
+declare const getRedirectResult: typeof getRedirectResult$1;
+declare const initializeAuth: typeof initializeAuth$1;
+declare const initializeRecaptchaConfig: typeof initializeRecaptchaConfig$1;
+declare const isSignInWithEmailLink: typeof isSignInWithEmailLink$1;
+declare const linkWithCredential: typeof linkWithCredential$1;
+declare const linkWithPhoneNumber: typeof linkWithPhoneNumber$1;
+declare const linkWithPopup: typeof linkWithPopup$1;
+declare const linkWithRedirect: typeof linkWithRedirect$1;
+declare const onAuthStateChanged: typeof onAuthStateChanged$1;
+declare const onIdTokenChanged: typeof onIdTokenChanged$1;
+declare const parseActionCodeURL: typeof parseActionCodeURL$1;
+declare const reauthenticateWithCredential: typeof reauthenticateWithCredential$1;
+declare const reauthenticateWithPhoneNumber: typeof reauthenticateWithPhoneNumber$1;
+declare const reauthenticateWithPopup: typeof reauthenticateWithPopup$1;
+declare const reauthenticateWithRedirect: typeof reauthenticateWithRedirect$1;
+declare const reload: typeof reload$1;
+declare const revokeAccessToken: typeof revokeAccessToken$1;
+declare const sendEmailVerification: typeof sendEmailVerification$1;
+declare const sendPasswordResetEmail: typeof sendPasswordResetEmail$1;
+declare const sendSignInLinkToEmail: typeof sendSignInLinkToEmail$1;
+declare const setPersistence: typeof setPersistence$1;
+declare const signInAnonymously: typeof signInAnonymously$1;
+declare const signInWithCredential: typeof signInWithCredential$1;
+declare const signInWithCustomToken: typeof signInWithCustomToken$1;
+declare const signInWithEmailAndPassword: typeof signInWithEmailAndPassword$1;
+declare const signInWithEmailLink: typeof signInWithEmailLink$1;
+declare const signInWithPhoneNumber: typeof signInWithPhoneNumber$1;
+declare const signInWithPopup: typeof signInWithPopup$1;
+declare const signInWithRedirect: typeof signInWithRedirect$1;
+declare const signOut: typeof signOut$1;
+declare const unlink: typeof unlink$1;
+declare const updateCurrentUser: typeof updateCurrentUser$1;
+declare const updateEmail: typeof updateEmail$1;
+declare const updatePassword: typeof updatePassword$1;
+declare const updatePhoneNumber: typeof updatePhoneNumber$1;
+declare const updateProfile: typeof updateProfile$1;
+declare const useDeviceLanguage: typeof useDeviceLanguage$1;
+declare const validatePassword: typeof validatePassword$1;
+declare const verifyBeforeUpdateEmail: typeof verifyBeforeUpdateEmail$1;
+declare const verifyPasswordResetCode: typeof verifyPasswordResetCode$1;
+
+export { Auth, AuthInstances, AuthModule, applyActionCode, authInstance$, authState, beforeAuthStateChanged, checkActionCode, confirmPasswordReset, connectAuthEmulator, createUserWithEmailAndPassword, deleteUser, fetchSignInMethodsForEmail, getAdditionalUserInfo, getAuth, getIdToken, getIdTokenResult, getMultiFactorResolver, getRedirectResult, idToken, initializeAuth, initializeRecaptchaConfig, isSignInWithEmailLink, linkWithCredential, linkWithPhoneNumber, linkWithPopup, linkWithRedirect, onAuthStateChanged, onIdTokenChanged, parseActionCodeURL, provideAuth, reauthenticateWithCredential, reauthenticateWithPhoneNumber, reauthenticateWithPopup, reauthenticateWithRedirect, reload, revokeAccessToken, sendEmailVerification, sendPasswordResetEmail, sendSignInLinkToEmail, setPersistence, signInAnonymously, signInWithCredential, signInWithCustomToken, signInWithEmailAndPassword, signInWithEmailLink, signInWithPhoneNumber, signInWithPopup, signInWithRedirect, signOut, unlink, updateCurrentUser, updateEmail, updatePassword, updatePhoneNumber, updateProfile, useDeviceLanguage, user, validatePassword, verifyBeforeUpdateEmail, verifyPasswordResetCode };

package/auth-guard/index.d.ts

@@ -1,5 +1,43 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/auth-guard" />
-export * from './public_api';
+import * as rxjs from 'rxjs';
+import { UnaryFunction, Observable } from 'rxjs';
+import * as _firebase_auth from '@firebase/auth';
+import * as _angular_router from '@angular/router';
+import { ActivatedRouteSnapshot, RouterStateSnapshot, CanActivate, Router } from '@angular/router';
+import { Auth } from '@angular/fire/auth';
+import { User } from 'firebase/auth';
+import * as i0 from '@angular/core';
+
+type AuthPipeGenerator = (next: ActivatedRouteSnapshot, state: RouterStateSnapshot) => AuthPipe;
+type AuthPipe = UnaryFunction<Observable<User | null>, Observable<boolean | string | any[]>>;
+declare const loggedIn: AuthPipe;
+declare class AuthGuard implements CanActivate {
+    private router;
+    private auth;
+    constructor(router: Router, auth: Auth);
+    canActivate: (next: ActivatedRouteSnapshot, state: RouterStateSnapshot) => Observable<boolean | _angular_router.UrlTree>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuard>;
+}
+declare const canActivate: (pipe: AuthPipeGenerator) => {
+    canActivate: (typeof AuthGuard)[];
+    data: {
+        authGuardPipe: AuthPipeGenerator;
+    };
+};
+declare const isNotAnonymous: AuthPipe;
+declare const idTokenResult: rxjs.OperatorFunction<User, _firebase_auth.IdTokenResult>;
+declare const emailVerified: AuthPipe;
+declare const customClaims: UnaryFunction<Observable<User>, Observable<any[] | _firebase_auth.ParsedToken>>;
+declare const hasCustomClaim: (claim: string) => AuthPipe;
+declare const redirectUnauthorizedTo: (redirect: string | any[]) => AuthPipe;
+declare const redirectLoggedInTo: (redirect: string | any[]) => AuthPipe;
+
+declare class AuthGuardModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AuthGuardModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AuthGuardModule>;
+}
+
+export { AuthGuard, AuthGuardModule, canActivate, customClaims, emailVerified, hasCustomClaim, idTokenResult, isNotAnonymous, loggedIn, redirectLoggedInTo, redirectUnauthorizedTo };
+export type { AuthPipe, AuthPipeGenerator };

package/compat/analytics/index.d.ts

@@ -1,5 +1,52 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/compat/analytics" />
-export * from './public_api';
+import * as i0 from '@angular/core';
+import { InjectionToken, NgZone, OnDestroy, ComponentFactoryResolver } from '@angular/core';
+import { ɵAngularFireSchedulers as _AngularFireSchedulers } from '@angular/fire';
+import { ɵPromiseProxy as _PromiseProxy, FirebaseApp } from '@angular/fire/compat';
+import firebase from 'firebase/compat/app';
+import { Title } from '@angular/platform-browser';
+import { Router } from '@angular/router';
+import { AngularFireAuth } from '@angular/fire/compat/auth';
+
+type Config = Record<string, any>;
+declare const COLLECTION_ENABLED: InjectionToken<boolean>;
+declare const APP_VERSION: InjectionToken<string>;
+declare const APP_NAME: InjectionToken<string>;
+declare const DEBUG_MODE: InjectionToken<boolean>;
+declare const CONFIG: InjectionToken<Config>;
+interface AngularFireAnalytics extends _PromiseProxy<firebase.analytics.Analytics> {
+}
+declare class AngularFireAnalytics {
+    private measurementId;
+    private analyticsInitialized;
+    updateConfig(config: Config): Promise<void>;
+    constructor(app: FirebaseApp, analyticsCollectionEnabled: boolean | null, providedAppVersion: string | null, providedAppName: string | null, debugModeEnabled: boolean | null, providedConfig: Config | null, platformId: Object, zone: NgZone, schedulers: _AngularFireSchedulers);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireAnalytics, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFireAnalytics>;
+}
+
+declare class UserTrackingService implements OnDestroy {
+    initialized: Promise<void>;
+    private disposables;
+    constructor(analytics: AngularFireAnalytics, platformId: Object, auth: AngularFireAuth, zone: NgZone);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserTrackingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserTrackingService>;
+}
+
+declare class ScreenTrackingService implements OnDestroy {
+    private disposable;
+    constructor(analytics: AngularFireAnalytics, router: Router, title: Title, componentFactoryResolver: ComponentFactoryResolver, zone: NgZone, userTrackingService: UserTrackingService);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenTrackingService, [null, { optional: true; }, { optional: true; }, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScreenTrackingService>;
+}
+
+declare class AngularFireAnalyticsModule {
+    constructor(analytics: AngularFireAnalytics, screenTracking: ScreenTrackingService, userTracking: UserTrackingService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireAnalyticsModule, [null, { optional: true; }, { optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFireAnalyticsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFireAnalyticsModule>;
+}
+
+export { APP_NAME, APP_VERSION, AngularFireAnalytics, AngularFireAnalyticsModule, COLLECTION_ENABLED, CONFIG, DEBUG_MODE, ScreenTrackingService, UserTrackingService };
+export type { Config };

package/compat/auth/index.d.ts

@@ -1,5 +1,58 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/compat/auth" />
-export * from './public_api';
+import * as i0 from '@angular/core';
+import { NgZone, InjectionToken } from '@angular/core';
+import { ɵAngularFireSchedulers as _AngularFireSchedulers } from '@angular/fire';
+import { AppCheckInstances } from '@angular/fire/app-check';
+import { ɵPromiseProxy as _PromiseProxy, FirebaseApp } from '@angular/fire/compat';
+import { FirebaseOptions } from 'firebase/app';
+import firebase from 'firebase/compat/app';
+import { Observable } from 'rxjs';
+
+type UseEmulatorArguments = Parameters<firebase.auth.Auth['useEmulator']>;
+declare const USE_EMULATOR: InjectionToken<[url: string]>;
+declare const SETTINGS: InjectionToken<firebase.auth.AuthSettings>;
+declare const TENANT_ID: InjectionToken<string>;
+declare const LANGUAGE_CODE: InjectionToken<string>;
+declare const USE_DEVICE_LANGUAGE: InjectionToken<boolean>;
+declare const PERSISTENCE: InjectionToken<string>;
+declare const ɵauthFactory: (app: FirebaseApp, zone: NgZone, useEmulator: UseEmulatorArguments | null, tenantId: string, languageCode: string | null, useDeviceLanguage: boolean | null, settings: firebase.auth.AuthSettings | null, persistence: string | null) => firebase.auth.Auth;
+interface AngularFireAuth extends _PromiseProxy<firebase.auth.Auth> {
+}
+declare class AngularFireAuth {
+    private readonly injector;
+    /**
+     * Observable of authentication state; as of Firebase 4.0 this is only triggered via sign-in/out
+     */
+    readonly authState: Observable<firebase.User | null>;
+    /**
+     * Observable of the currently signed-in user's JWT token used to identify the user to a Firebase service (or null).
+     */
+    readonly idToken: Observable<string | null>;
+    /**
+     * Observable of the currently signed-in user (or null).
+     */
+    readonly user: Observable<firebase.User | null>;
+    /**
+     * Observable of the currently signed-in user's IdTokenResult object which 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
+     * (or null).
+     */
+    readonly idTokenResult: Observable<firebase.auth.IdTokenResult | null>;
+    /**
+     * Observable of the currently signed-in user's credential, or null
+     */
+    readonly credential: Observable<Required<firebase.auth.UserCredential> | null>;
+    constructor(options: FirebaseOptions, name: string | null | undefined, platformId: Object, zone: NgZone, schedulers: _AngularFireSchedulers, useEmulator: any, // can't use the tuple here
+    settings: any, // can't use firebase.auth.AuthSettings here
+    tenantId: string | null, languageCode: string | null, useDeviceLanguage: boolean | null, persistence: string | null, _appCheckInstances: AppCheckInstances);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireAuth, [null, { optional: true; }, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFireAuth>;
+}
+
+declare class AngularFireAuthModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireAuthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFireAuthModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFireAuthModule>;
+}
+
+export { AngularFireAuth, AngularFireAuthModule, LANGUAGE_CODE, PERSISTENCE, SETTINGS, TENANT_ID, USE_DEVICE_LANGUAGE, USE_EMULATOR, ɵauthFactory };

package/compat/auth-guard/index.d.ts

@@ -1,5 +1,44 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@angular/fire/compat/auth-guard" />
-export * from './public_api';
+import * as rxjs from 'rxjs';
+import { UnaryFunction, Observable } from 'rxjs';
+import * as _angular_router from '@angular/router';
+import { ActivatedRouteSnapshot, RouterStateSnapshot, CanActivate, Router } from '@angular/router';
+import { AngularFireAuth } from '@angular/fire/compat/auth';
+import firebase from 'firebase/compat/app';
+import * as i0 from '@angular/core';
+
+type AuthPipeGenerator = (next: ActivatedRouteSnapshot, state: RouterStateSnapshot) => AuthPipe;
+type AuthPipe = UnaryFunction<Observable<firebase.User | null>, Observable<boolean | string | any[]>>;
+declare const loggedIn: AuthPipe;
+declare class AngularFireAuthGuard implements CanActivate {
+    private router;
+    private auth;
+    constructor(router: Router, auth: AngularFireAuth);
+    canActivate: (next: ActivatedRouteSnapshot, state: RouterStateSnapshot) => Observable<boolean | _angular_router.UrlTree>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireAuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFireAuthGuard>;
+}
+declare const canActivate: (pipe: AuthPipeGenerator) => {
+    canActivate: (typeof AngularFireAuthGuard)[];
+    data: {
+        authGuardPipe: AuthPipeGenerator;
+    };
+};
+declare const isNotAnonymous: AuthPipe;
+declare const idTokenResult: rxjs.OperatorFunction<firebase.User, firebase.auth.IdTokenResult>;
+declare const emailVerified: AuthPipe;
+declare const customClaims: UnaryFunction<Observable<firebase.User>, Observable<any[] | {
+    [key: string]: any;
+}>>;
+declare const hasCustomClaim: (claim: string) => AuthPipe;
+declare const redirectUnauthorizedTo: (redirect: string | any[]) => AuthPipe;
+declare const redirectLoggedInTo: (redirect: string | any[]) => AuthPipe;
+
+declare class AngularFireAuthGuardModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireAuthGuardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFireAuthGuardModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFireAuthGuardModule>;
+}
+
+export { AngularFireAuthGuard, AngularFireAuthGuardModule, canActivate, customClaims, emailVerified, hasCustomClaim, idTokenResult, isNotAnonymous, loggedIn, redirectLoggedInTo, redirectUnauthorizedTo };
+export type { AuthPipe, AuthPipeGenerator };

package/compat/database/index.d.ts

@@ -1,5 +1,109 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, NgZone, Injector } from '@angular/core';
+import { ɵAngularFireSchedulers as _AngularFireSchedulers } from '@angular/fire';
+import { AppCheckInstances } from '@angular/fire/app-check';
+import { AngularFireAuth } from '@angular/fire/compat/auth';
+import { FirebaseOptions } from 'firebase/app';
+import firebase from 'firebase/compat/app';
+import * as rxjs from 'rxjs';
+import { Observable, SchedulerLike } from 'rxjs';
+
+type FirebaseOperation = string | firebase.database.Reference | firebase.database.DataSnapshot;
+interface AngularFireList<T> {
+    query: DatabaseQuery;
+    valueChanges(events?: ChildEvent[], options?: unknown): Observable<T[]>;
+    valueChanges<K extends string>(events?: ChildEvent[], options?: {
+        idField: K;
+    }): Observable<(T & {
+        [T in K]?: string;
+    })[]>;
+    snapshotChanges(events?: ChildEvent[]): Observable<SnapshotAction<T>[]>;
+    stateChanges(events?: ChildEvent[]): Observable<SnapshotAction<T>>;
+    auditTrail(events?: ChildEvent[]): Observable<SnapshotAction<T>[]>;
+    update(item: FirebaseOperation, data: Partial<T>): Promise<void>;
+    set(item: FirebaseOperation, data: T): Promise<void>;
+    push(data: T): firebase.database.ThenableReference;
+    remove(item?: FirebaseOperation): Promise<void>;
+}
+interface AngularFireObject<T> {
+    query: DatabaseQuery;
+    valueChanges(): Observable<T | null>;
+    snapshotChanges(): Observable<SnapshotAction<T>>;
+    update(data: Partial<T>): Promise<void>;
+    set(data: T): Promise<void>;
+    remove(): Promise<void>;
+}
+type QueryFn = (ref: DatabaseReference) => DatabaseQuery;
+type ChildEvent = 'child_added' | 'child_removed' | 'child_changed' | 'child_moved';
+type ListenEvent = 'value' | ChildEvent;
+interface Action<T> {
+    type: ListenEvent;
+    payload: T;
+}
+interface AngularFireAction<T> extends Action<T> {
+    prevKey: string | null | undefined;
+    key: string | null;
+}
+type SnapshotAction<T> = AngularFireAction<DatabaseSnapshot<T>>;
+interface DatabaseSnapshotExists<T> extends firebase.database.DataSnapshot {
+    exists(): true;
+    val(): T;
+    forEach(action: (a: DatabaseSnapshot<T>) => boolean): boolean;
+}
+interface DatabaseSnapshotDoesNotExist<T> extends firebase.database.DataSnapshot {
+    exists(): false;
+    val(): null;
+    forEach(action: (a: DatabaseSnapshot<T>) => boolean): boolean;
+}
+type DatabaseSnapshot<T> = DatabaseSnapshotExists<T> | DatabaseSnapshotDoesNotExist<T>;
+type DatabaseReference = firebase.database.Reference;
+type DatabaseQuery = firebase.database.Query;
+type QueryReference = DatabaseReference | DatabaseQuery;
+type PathReference = QueryReference | string;
+
+declare const URL: InjectionToken<string>;
+declare const USE_EMULATOR: InjectionToken<[host: string, port: number, options?: {
+    mockUserToken?: firebase.database.EmulatorMockTokenOptions | string;
+}]>;
+declare class AngularFireDatabase {
+    schedulers: _AngularFireSchedulers;
+    readonly database: firebase.database.Database;
+    private readonly injector;
+    constructor(options: FirebaseOptions, name: string | null | undefined, databaseURL: string | null, platformId: Object, zone: NgZone, schedulers: _AngularFireSchedulers, _useEmulator: any, // tuple isn't working here
+    auth: AngularFireAuth, useAuthEmulator: any, authSettings: any, // can't use firebase.auth.AuthSettings here
+    tenantId: string | null, languageCode: string | null, useDeviceLanguage: boolean | null, persistence: string | null, _appCheckInstances: AppCheckInstances);
+    list<T>(pathOrRef: PathReference, queryFn?: QueryFn): AngularFireList<T>;
+    object<T>(pathOrRef: PathReference): AngularFireObject<T>;
+    createPushId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireDatabase, [null, { optional: true; }, { optional: true; }, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFireDatabase>;
+}
+
+declare function listChanges<T = any>(ref: DatabaseQuery, events: ChildEvent[], scheduler?: SchedulerLike): Observable<SnapshotAction<T>[]>;
+
+declare function createListReference<T = any>(query: DatabaseQuery, afDatabase: AngularFireDatabase, injector?: Injector): AngularFireList<T>;
+
+declare function snapshotChanges<T>(query: DatabaseQuery, events?: ChildEvent[], scheduler?: SchedulerLike): Observable<SnapshotAction<T>[]>;
+
+declare function stateChanges<T>(query: DatabaseQuery, events?: ChildEvent[], scheduler?: SchedulerLike): rxjs.Observable<AngularFireAction<DatabaseSnapshot<T>>>;
+
+declare function auditTrail<T>(query: DatabaseQuery, events?: ChildEvent[], scheduler?: SchedulerLike): Observable<SnapshotAction<T>[]>;
+
 /**
- * Generated bundle index. Do not edit.
+ * Create an observable from a Database Reference or Database Query.
+ * @param ref Database Reference
+ * @param event Listen event type ('value', 'added', 'changed', 'removed', 'moved')
+ * @param listenType 'on' or 'once'
+ * @param scheduler - Rxjs scheduler
  */
-/// <amd-module name="@angular/fire/compat/database" />
-export * from './public_api';
+declare function fromRef<T>(ref: DatabaseQuery, event: ListenEvent, listenType?: string, scheduler?: SchedulerLike): Observable<AngularFireAction<DatabaseSnapshot<T>>>;
+
+declare class AngularFireDatabaseModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AngularFireDatabaseModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularFireDatabaseModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AngularFireDatabaseModule>;
+}
+
+export { AngularFireDatabase, AngularFireDatabaseModule, URL, USE_EMULATOR, auditTrail, createListReference, fromRef, listChanges, snapshotChanges, stateChanges };
+export type { Action, AngularFireAction, AngularFireList, AngularFireObject, ChildEvent, DatabaseSnapshot, ListenEvent, PathReference, QueryFn, SnapshotAction };