@relking-elements/vue-firebase 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,605 @@
+import { FirebaseApp } from 'firebase/app';
+import * as vue from 'vue';
+import { Ref, ShallowRef, MaybeRefOrGetter, App } from 'vue';
+import * as firebase_database from 'firebase/database';
+import { DataSnapshot, DatabaseReference, Query } from 'firebase/database';
+import * as firebase_firestore from 'firebase/firestore';
+import { FirestoreDataConverter, SnapshotOptions, SnapshotListenOptions, DocumentData, FirestoreError, CollectionReference, Query as Query$1, DocumentReference } from 'firebase/firestore';
+import * as firebase_auth from 'firebase/auth';
+import { User, Dependencies, Auth } from 'firebase/auth';
+import { AppCheckOptions, AppCheck } from 'firebase/app-check';
+import * as firebase_storage from 'firebase/storage';
+import { StorageReference, FullMetadata, SettableMetadata, UploadTaskSnapshot, UploadTask, StorageError, UploadMetadata } from 'firebase/storage';
+
+/**
+ * Allow resetting a subscription vue ref when the source changes or is removed. `false` keeps the value as is while
+ * true resets it to `null` for objects and `[]` for arrays. A function allows to specify a custom reset value.
+ */
+type ResetOption = boolean | (() => unknown);
+/**
+ * Flattens out a type.
+ *
+ * @internal
+ */
+type _Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};
+/**
+ * @internal
+ */
+type _Nullable<T> = T | null | undefined;
+/**
+ * @internal
+ */
+interface _RefWithState<T, E = Error> extends Ref<T> {
+    /**
+     * Realtime data wrapped in a Vue `ref`
+     */
+    get data(): Ref<T>;
+    /**
+     * Reactive Error if the firebase operation fails
+     */
+    get error(): Ref<E | undefined>;
+    /**
+     * Reactive loading state
+     */
+    get pending(): Ref<boolean>;
+    /**
+     * Reactive promise that resolves when the data is loaded or rejects if there is an error
+     */
+    get promise(): ShallowRef<Promise<T>>;
+    /**
+     * Stops listening to the data changes and stops the Vue watcher.
+     */
+    stop: (reset?: ResetOption) => void;
+}
+/**
+ * Base options for the data source options in both Firestore and Realtime Database.
+ *
+ * @internal
+ */
+interface _DataSourceOptions<DataT = unknown> {
+    /**
+     * Use the `target` ref instead of creating one.
+     */
+    target?: Ref<DataT>;
+    /**
+     * If true, the data will be reset when the data source is unbound. Pass a function to specify a custom reset value.
+     */
+    reset?: ResetOption;
+    /**
+     * If true, wait until the data is loaded before setting the data for the first time. For Firestore, this includes
+     * nested refs. This is only useful for lists and collections. Objects and documents do not need this.
+     */
+    wait?: boolean;
+    /**
+     * Should the data be fetched once rather than subscribing to changes.
+     */
+    once?: boolean;
+}
+
+/**
+ * Convert firebase Database snapshot of a ref **that exists** into a bindable data record.
+ *
+ * @param snapshot
+ * @return
+ */
+declare function createRecordFromDatabaseSnapshot(snapshot: DataSnapshot): VueDatabaseDocumentData<unknown>;
+interface DatabaseSnapshotSerializer<T = unknown> {
+    (snapshot: DataSnapshot): VueDatabaseDocumentData<T>;
+}
+interface _RefDatabase<T> extends _RefWithState<T, Error> {
+}
+/**
+ * Type used by default by the `serialize` option.
+ */
+type VueDatabaseDocumentData<T = unknown> = null | (T & {
+    /**
+     * id of the document
+     */
+    readonly id: string;
+});
+/**
+ * Same as VueDatabaseDocumentData but for a query.
+ */
+type VueDatabaseQueryData<T = unknown> = Array<_Simplify<NonNullable<VueDatabaseDocumentData<T>>>>;
+
+/**
+ * Global option type when binding one database reference
+ * @internal
+ */
+interface _DatabaseRefOptions<DataT = unknown> extends _DataSourceOptions<DataT> {
+    /**
+     * Function to transform snapshots into data. **Make sure to reuse the original serializer to add the object `id`**.
+     * See https://vuefire.vuejs.org/guide/global-options.html
+     */
+    serialize?: DatabaseSnapshotSerializer;
+}
+/**
+ * Global defaults type override options for all database bindings. This type remove make some optional values required.
+ * @internal
+ */
+interface _DatabaseRefOptionsWithDefaults extends _DatabaseRefOptions<unknown> {
+    /**
+     * @defaultValue `false`
+     */
+    reset: ResetOption;
+    /**
+     * @defaultValue `true`
+     */
+    wait: boolean;
+    serialize: DatabaseSnapshotSerializer;
+}
+declare const DEFAULT_OPTIONS$1: _DatabaseRefOptionsWithDefaults;
+
+/**
+ * Options when calling `useDatabaseList()` and `useDatabaseObject()`.
+ */
+interface UseDatabaseRefOptions<DataT = unknown> extends _DatabaseRefOptions<DataT> {
+}
+
+type UseListOptions<DataT = unknown> = UseDatabaseRefOptions<DataT>;
+/**
+ * Creates a reactive variable connected to the database as an array. Each element in the array will contain an `id`
+ * property. Note that if you override the `serialize` option, it should **also set an `id` property** in order for this
+ * to work.
+ *
+ * @param reference - Reference or query to the database
+ * @param options - optional options
+ */
+declare function useDatabaseList<T = unknown>(reference: MaybeRefOrGetter<_Nullable<DatabaseReference | Query>>, options?: UseListOptions<T>): _RefDatabase<VueDatabaseQueryData<T>>;
+/**
+ * @deprecated use `useDatabaseList()` instead
+ */
+declare const useList: typeof useDatabaseList;
+type UseObjectOptions<DataT = unknown> = UseDatabaseRefOptions<DataT>;
+/**
+ * Creates a reactive variable connected to the database as an object. If the reference is a primitive, it will be
+ * converted to an object containing a `$value` property with the primitive value and an `id` property with the
+ * reference's key.
+ *
+ * @param reference - Reference or query to the database
+ * @param options - optional options
+ */
+declare function useDatabaseObject<T = unknown>(reference: MaybeRefOrGetter<_Nullable<DatabaseReference>>, options?: UseObjectOptions<T>): _RefDatabase<VueDatabaseDocumentData<T> | undefined>;
+/**
+ * @deprecated use `useDatabaseObject()` instead
+ */
+declare const useObject: typeof useDatabaseObject;
+/**
+ * Retrieves the Database instance.
+ *
+ * @param name - name of the application
+ * @param databaseUrl - URL for a named Realtime Database instance
+ * @returns the Database instance
+ */
+declare function useDatabase(name?: string, databaseUrl?: string): firebase_database.Database;
+
+/**
+ * Options when binding a Firestore document or collection.
+ */
+interface FirestoreRefOptions<TData = unknown> extends _DataSourceOptions<TData> {
+    /**
+     * The maximum depth to bind nested refs. A nested ref that isn't bound will stay as the ref path while a bound ref
+     * will contain the same data as if the ref was bound directly.
+     */
+    maxRefDepth?: number;
+    /**
+     * @inheritDoc {SnapshotOptions}
+     */
+    snapshotOptions?: SnapshotOptions;
+    /**
+     * @inheritDoc {SnapshotListenOptions}
+     */
+    snapshotListenOptions?: SnapshotListenOptions;
+    /**
+     * Default Firestore converter to use with snapshots.
+     */
+    converter?: FirestoreDataConverter<unknown>;
+}
+/**
+ * Type of the global options for firestore refs. Some values cannot be `undefined`.
+ * @internal
+ */
+interface _FirestoreRefOptionsWithDefaults extends FirestoreRefOptions {
+    /**
+     * @defaultValue `false`
+     */
+    reset: ResetOption;
+    /**
+     * @defaultValue `true`
+     */
+    wait: boolean;
+    /**
+     * @defaultValue `2`
+     */
+    maxRefDepth: number;
+    /**
+     * Default Firestore converter to use with snapshots. Make sure to reuse the original serializer to add the object id.
+     * See https://vuefire.vuejs.org/guide/global-options.html
+     */
+    converter: FirestoreDataConverter<unknown>;
+    /**
+     * @defaultValue `{ serverTimestamps: 'estimate' }` to avoid `null` values
+     */
+    snapshotOptions: SnapshotOptions;
+}
+/**
+ * Global default options
+ */
+declare const DEFAULT_OPTIONS: _FirestoreRefOptionsWithDefaults;
+
+interface _UseFirestoreRefOptions<TData = unknown> extends FirestoreRefOptions<TData> {
+    /**
+     * @deprecated: use `.withConverter()` instead
+     */
+    converter?: FirestoreDataConverter<unknown>;
+}
+/**
+ * Infers the type from a firestore reference. If it is not a reference, it returns the type as is.
+ *
+ * @internal
+ */
+type _InferReferenceType<R> = R extends CollectionReference<infer T> | Query$1<infer T> | DocumentReference<infer T> ? T : R;
+/**
+ * Type used by default by the `firestoreDefaultConverter`.
+ */
+type VueFirestoreDocumentData<T = DocumentData> = null | (T & {
+    /**
+     * id of the document
+     */
+    readonly id: string;
+});
+type VueFirestoreQueryData<T = DocumentData> = Array<_Simplify<NonNullable<VueFirestoreDocumentData<T>>>>;
+/**
+ * @internal
+ */
+interface _RefFirestore<T> extends _RefWithState<T, FirestoreError> {
+}
+
+interface UseCollectionOptions<TData = unknown> extends _UseFirestoreRefOptions<TData> {
+}
+
+/**
+ * Creates a reactive collection (usually an array) of documents from a collection ref or a query from Firestore. Extracts the type of the
+ * query or converter.
+ *
+ * @param collectionRef - query or collection
+ * @param options - optional options
+ */
+declare function useCollection<R extends CollectionReference<unknown> | Query$1<unknown>>(collectionRef: MaybeRefOrGetter<_Nullable<R>>, options?: UseCollectionOptions<_InferReferenceType<R>[]>): _RefFirestore<_InferReferenceType<R>[]>;
+/**
+ * Creates a reactive collection (usually an array) of documents from a collection ref or a query from Firestore.
+ * Accepts a generic to **enforce the type** of the returned Ref. Note you can (and probably should) use
+ * `.withConverter()` to have stricter type safe version of a collection reference.
+ *
+ * @param collectionRef - query or collection
+ * @param options - optional options
+ */
+declare function useCollection<T>(collectionRef: MaybeRefOrGetter<_Nullable<CollectionReference<unknown> | Query$1<unknown>>>, options?: UseCollectionOptions<T[]>): _RefFirestore<VueFirestoreQueryData<T>>;
+interface UseDocumentOptions<TData = unknown> extends _UseFirestoreRefOptions<TData> {
+}
+/**
+ * Creates a reactive document from a document ref from Firestore. Automatically extracts the type of the converter or
+ * the document.
+ *
+ * @param documentRef - document reference
+ * @param options - optional options
+ */
+declare function useDocument<R extends DocumentReference<unknown>>(documentRef: MaybeRefOrGetter<_Nullable<R>>, options?: UseDocumentOptions<_InferReferenceType<R>>): _RefFirestore<_InferReferenceType<R> | undefined>;
+/**
+ * Creates a reactive collection (usually an array) of documents from a collection ref or a query from Firestore.
+ * Accepts a generic to **enforce the type** of the returned Ref. Note you can (and probably should) use
+ * `.withConverter()` to have stricter type safe version of a collection reference.
+ *
+ * @param documentRef - query or collection
+ * @param options - optional options
+ */
+declare function useDocument<T>(documentRef: MaybeRefOrGetter<_Nullable<DocumentReference>>, options?: UseDocumentOptions<T>): _RefFirestore<VueFirestoreDocumentData<T> | undefined>;
+/**
+ * Retrieves the Firestore instance.
+ *
+ * @param name - name of the application
+ * @param databaseId - database ID for named Firestore databases
+ * @returns the Firestore instance
+ */
+declare function useFirestore(name?: string, databaseId?: string): firebase_firestore.Firestore;
+
+/**
+ * Default converter for Firestore data. Can be overridden globally by setting `globalFirestoreOptions.converter`.
+ */
+declare const firestoreDefaultConverter: FirestoreDataConverter<VueFirestoreDocumentData>;
+
+/**
+ * Gets the firebase app instance.
+ *
+ * @param name - optional firebase app name
+ * @returns the firebase app
+ */
+declare function useFirebaseApp(name?: string): FirebaseApp;
+
+/**
+ * Returns a reactive variable of the currently authenticated user in the firebase app. The ref is null if no user is
+ * authenticated or when the user logs out. The ref is undefined until the user is initially loaded.
+ * @param name - name of the application
+ */
+declare function useCurrentUser(name?: string): Ref<_Nullable<User>, _Nullable<User>>;
+/**
+ * Helper that returns a computed boolean that becomes `true` as soon as the current user is no longer `undefined`. Note
+ * this doesn't ensure the user is logged in, only if the initial signing process has run.
+ *
+ * @param name - name of the application
+ */
+declare function useIsCurrentUserLoaded(name?: string): vue.ComputedRef<boolean>;
+/**
+ * Updates the current user profile and updates the current user state. This function internally calls `updateProfile()`
+ * from 'firebase/auth' and then updates the current user state.
+ *
+ * @param profile - the new profile information
+ */
+declare function updateCurrentUserProfile(profile: {
+    displayName?: _Nullable<string>;
+    photoURL?: _Nullable<string>;
+}): Promise<void>;
+/**
+ * Returns a promise that resolves the current user once the user is loaded. Must be called after the firebase app is
+ * initialized.
+ * @param name - name of the firebase application
+ */
+declare function getCurrentUser(name?: string): Promise<_Nullable<User>>;
+
+/**
+ * Options for VueFire Auth module.
+ */
+interface VueFireAuthOptions {
+    /**
+     * Options to pass to `initializeAuth()`.
+     */
+    dependencies: Dependencies;
+}
+/**
+ * VueFire Auth Module to be added to the `VueFire` Vue plugin options. This calls the `VueFireAuthWithDependencies()`
+ * with **all** the dependencies, increasing bundle size. Consider using `VueFireAuthWithDependencies()` instead to
+ * better control the bundle size.
+ *
+ * @see https://firebase.google.com/docs/auth/web/custom-dependencies
+ *
+ * @example
+ *
+ *```ts
+ *import { createApp } from 'vue'
+ *import { VueFire, VueFireAuth } from 'vuefire'
+ *
+ *const app = createApp(App)
+ *app.use(VueFire, {
+ *  modules: [VueFireAuth()],
+ *})
+ *```
+ *
+ */
+declare function VueFireAuth(): VueFireModule;
+/**
+ * Key to be used to inject the auth instance into components. It allows avoiding to call `getAuth()`, which isn't tree
+ * shakable.
+ * @internal
+ */
+declare const _VueFireAuthKey: unique symbol;
+/**
+ * Options for VueFire Auth module when passing the auth instance directly.
+ */
+interface VueFireAuthOptionsFromAuth {
+    /**
+     * Auth instance to use.
+     */
+    auth: Auth;
+}
+/**
+ * VueFire Auth Module to be added to the `VueFire` Vue plugin options. It accepts an auth instance rather than the
+ * dependencies. It allows manually calling emulators and other advanced use cases. Prefer using
+ * `VueFireAuthWithDependencies()` and `VueFireAuth()` for most use cases.
+ *
+ * @param options - auth instance and initial user
+ */
+declare function VueFireAuthOptionsFromAuth({ auth, }: VueFireAuthOptionsFromAuth): VueFireModule;
+/**
+ * VueFire Auth Module to be added to the `VueFire` Vue plugin options. It accepts dependencies to pass to
+ * `initializeAuth()` to better control the bundle size.
+ *
+ * @param options - user and options to pass to `initializeAuth()`.
+ */
+declare function VueFireAuthWithDependencies({ dependencies, }: VueFireAuthOptions): VueFireModule;
+/**
+ * Initializes auth.
+ * @internal
+ */
+declare function _VueFireAuthInit(firebaseApp: FirebaseApp, app: App, dependencies?: Dependencies, auth?: Auth): readonly [vue.Ref<{
+    readonly emailVerified: boolean;
+    readonly isAnonymous: boolean;
+    readonly metadata: {
+        readonly creationTime?: string | undefined;
+        readonly lastSignInTime?: string | undefined;
+    };
+    readonly providerData: {
+        readonly displayName: string | null;
+        readonly email: string | null;
+        readonly phoneNumber: string | null;
+        readonly photoURL: string | null;
+        readonly providerId: string;
+        readonly uid: string;
+    }[];
+    readonly refreshToken: string;
+    readonly tenantId: string | null;
+    delete: () => Promise<void>;
+    getIdToken: (forceRefresh?: boolean) => Promise<string>;
+    getIdTokenResult: (forceRefresh?: boolean) => Promise<firebase_auth.IdTokenResult>;
+    reload: () => Promise<void>;
+    toJSON: () => object;
+    readonly displayName: string | null;
+    readonly email: string | null;
+    readonly phoneNumber: string | null;
+    readonly photoURL: string | null;
+    readonly providerId: string;
+    readonly uid: string;
+} | null | undefined, _Nullable<User> | {
+    readonly emailVerified: boolean;
+    readonly isAnonymous: boolean;
+    readonly metadata: {
+        readonly creationTime?: string | undefined;
+        readonly lastSignInTime?: string | undefined;
+    };
+    readonly providerData: {
+        readonly displayName: string | null;
+        readonly email: string | null;
+        readonly phoneNumber: string | null;
+        readonly photoURL: string | null;
+        readonly providerId: string;
+        readonly uid: string;
+    }[];
+    readonly refreshToken: string;
+    readonly tenantId: string | null;
+    delete: () => Promise<void>;
+    getIdToken: (forceRefresh?: boolean) => Promise<string>;
+    getIdTokenResult: (forceRefresh?: boolean) => Promise<firebase_auth.IdTokenResult>;
+    reload: () => Promise<void>;
+    toJSON: () => object;
+    readonly displayName: string | null;
+    readonly email: string | null;
+    readonly phoneNumber: string | null;
+    readonly photoURL: string | null;
+    readonly providerId: string;
+    readonly uid: string;
+}>, Auth];
+/**
+ * Retrieves the Firebase Auth instance. **Returns `null` on the server**. When using this function on the client in
+ * TypeScript, you can force the type with `useFirebaseAuth()!`.
+ *
+ * @returns the Auth instance
+ */
+declare function useFirebaseAuth(): Auth | null;
+
+/**
+ * The current app-check token as a `Ref`. Note this ref is always undefined on the server.
+ */
+declare function useAppCheckToken(): Ref<string | undefined, string | undefined>;
+interface VueFireAppCheckOptions extends AppCheckOptions {
+    /**
+     * Setups the debug token global. See https://firebase.google.com/docs/app-check/web/debug-provider. Note you should
+     * set to false in production (or not set it at all). It can be set to a string to force a specific debug token.
+     */
+    debug?: boolean | string;
+}
+/**
+ * VueFire AppCheck Module to be added to the `VueFire` Vue plugin options. This module **is client only** and shouldn't be added on server.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { VueFire, VueFireAppCheck } from 'vuefire'
+ *
+ * const app = createApp(App)
+ * app.use(VueFire, {
+ *   modules: [VueFireAppCheck()],
+ * })
+ * ```
+ */
+declare function VueFireAppCheck(options: VueFireAppCheckOptions): (firebaseApp: FirebaseApp, app: App) => void;
+/**
+ * Retrieves the Firebase App Check instance.
+ *
+ * @param name - name of the application
+ */
+declare function useAppCheck(name?: string): AppCheck;
+
+/**
+ * Retrieves the Storage instance.
+ *
+ * @param name - name of the application
+ * @returns the Database instance
+ */
+declare function useFirebaseStorage(name?: string): firebase_storage.FirebaseStorage;
+/**
+ * Retrieves a reactive download URL of a `StorageReference`. Updates automatically if the `StorageReference` changes.
+ *
+ * @param storageRef - StorageReference
+ */
+declare function useStorageFileUrl(storageRef: MaybeRefOrGetter<_Nullable<StorageReference>>): {
+    url: vue.Ref<string | null | undefined, string | null | undefined>;
+    refresh: () => Promise<string | null>;
+    promise: vue.ShallowRef<Promise<string | null>, Promise<string | null>>;
+};
+/**
+ * Returns a reactive version of the metadata of a `StorageReference`. Updates automatically if the `StorageReference`
+ * changes.
+ *
+ * @param storageRef - StorageReference
+ */
+declare function useStorageFileMetadata(storageRef: MaybeRefOrGetter<_Nullable<StorageReference>>): {
+    metadata: vue.ShallowRef<FullMetadata | null | undefined, FullMetadata | null | undefined>;
+    update: (newMetadata: SettableMetadata) => Promise<FullMetadata | null>;
+    refresh: () => Promise<FullMetadata | null>;
+    promise: vue.ShallowRef<Promise<FullMetadata | null>, Promise<FullMetadata | null>>;
+};
+/**
+ * Reactive information (url, metadata) of a `StorageReference`. Allows updating and deleting the storage object.
+ *
+ * @param storageRef - StorageReference
+ */
+declare function useStorageFile(storageRef: MaybeRefOrGetter<_Nullable<StorageReference>>): {
+    url: vue.Ref<string | null | undefined, string | null | undefined>;
+    metadata: vue.ShallowRef<FullMetadata | null | undefined, FullMetadata | null | undefined>;
+    snapshot: vue.ShallowRef<UploadTaskSnapshot | null | undefined, UploadTaskSnapshot | null | undefined>;
+    uploadTask: vue.ShallowRef<UploadTask | null | undefined, UploadTask | null | undefined>;
+    uploadError: vue.ShallowRef<StorageError | null | undefined, StorageError | null | undefined>;
+    uploadProgress: vue.ComputedRef<number | null>;
+    upload: (newData: Blob | Uint8Array | ArrayBuffer, newMetadata?: UploadMetadata) => Promise<unknown> | undefined;
+    updateMetadata: (newMetadata: SettableMetadata) => Promise<FullMetadata | null>;
+    refresh: () => Promise<[string | null, FullMetadata | null]>;
+};
+/**
+ * @deprecated use `useFirebaseStorage()` instead
+ */
+declare const useStorage: typeof useFirebaseStorage;
+/**
+ * @deprecated use `useStorageFileUrl()` instead
+ */
+declare const useStorageUrl: typeof useStorageFileUrl;
+/**
+ * @deprecated use `useStorageFileMetadata()` instead
+ */
+declare const useStorageMetadata: typeof useStorageFileMetadata;
+/**
+ * @deprecated use `useStorageFile()` instead
+ */
+declare const useStorageObject: typeof useStorageFile;
+
+/**
+ * @module vuefire
+ */
+
+/**
+ * Options for VueFire Vue plugin.
+ */
+interface VueFireOptions {
+    /**
+     * The firebase app used by VueFire and associated with the different modules.
+     */
+    firebaseApp: FirebaseApp;
+    /**
+     * Array of VueFire modules that should be added to the application. e.g. `[VueFireAuth, VueFireDatabase]`. Remember
+     * to import them from `vuefire`.
+     */
+    modules?: VueFireModule[];
+}
+/**
+ * A VueFire module that can be passed to the VueFire Vue plugin in the `modules` option.
+ */
+interface VueFireModule {
+    (firebaseApp: FirebaseApp, app: App): void;
+}
+/**
+ * VueFire Vue plugin.
+ */
+declare function VueFire(app: App, { firebaseApp, modules }: VueFireOptions): void;
+
+export { type DatabaseSnapshotSerializer, type UseCollectionOptions, type UseDatabaseRefOptions, type UseDocumentOptions, type UseListOptions, type UseObjectOptions, type VueDatabaseDocumentData, type VueDatabaseQueryData, VueFire, VueFireAppCheck, type VueFireAppCheckOptions, VueFireAuth, type VueFireAuthOptions, VueFireAuthOptionsFromAuth, VueFireAuthWithDependencies, type VueFireModule, type VueFireOptions, type VueFirestoreDocumentData, type VueFirestoreQueryData, type _RefDatabase, type _RefFirestore, _VueFireAuthInit, _VueFireAuthKey, createRecordFromDatabaseSnapshot as databaseDefaultSerializer, firestoreDefaultConverter, getCurrentUser, DEFAULT_OPTIONS$1 as globalDatabaseOptions, DEFAULT_OPTIONS as globalFirestoreOptions, updateCurrentUserProfile, useAppCheck, useAppCheckToken, useCollection, useCurrentUser, useDatabase, useDatabaseList, useDatabaseObject, useDocument, useFirebaseApp, useFirebaseAuth, useFirebaseStorage, useFirestore, useIsCurrentUserLoaded, useList, useObject, useStorage, useStorageFile, useStorageFileMetadata, useStorageFileUrl, useStorageMetadata, useStorageObject, useStorageUrl };