react-query-firebase 2.3.2 → 2.4.0

package/web/firestore/useAddDocMutation.ts

@@ -1,62 +1,74 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import {
-    DocumentData,
-    addDoc,
-    WithFieldValue,
-    CollectionReference,
-    getDoc,
-    FirestoreDataConverter
-} from "firebase/firestore";
+import { addDoc, WithFieldValue, CollectionReference, getDoc } from "firebase/firestore";
 
 import { FirebaseError } from "firebase/app";
 import { useMemo } from "react";
+import { AppModel } from "../../types";
 
+/**
+ * @inline
+ */
 export type UseAddDocMutationValues<AppModelType> = {
+    /**
+     * Data to write
+     */
     data: WithFieldValue<AppModelType>;
 };
 
-export type UseAddDocMutationOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
-    TContext = unknown
-> = {
-    reference: CollectionReference<AppModelType, DbModelType>;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+/**
+ * @inline
+ */
+export type UseAddDocMutationOptions<AppModelType extends AppModel = AppModel, TContext = unknown> = {
+    /**
+     * Reference to a collection where document must be added
+     */
+    collectionReference: CollectionReference<AppModelType, AppModelType>;
+    /**
+     * Options for useMutation hook excluding mutationFn. MutationKey will be equal to reference.path by default.
+     */
     options?: Omit<
         UseMutationOptions<AppModelType, FirebaseError, UseAddDocMutationValues<AppModelType>, TContext>,
-        "mutationFn" | "mutationKey"
+        "mutationFn"
     >;
 };
 
 /**
- * Provides a mutation hook to add a document to a Firestore collection utilizing React Query's `useMutation`.
- * It handles addition and optional conversion of the document data in Firestore.
+ * Executes a mutation and returns added document
+ *
+ * @group Hook
+ *
+ * @param {UseAddDocMutationOptions<AppModelType>} options - Configuration options for the mutation.
+ *
+ * @returns {UseMutationResult<AppModelType, Error, UseAddDocMutationValues<AppModelType>, TContext>}  A mutation result
  *
- * @param {Object} options - Options for the mutation hook
- * @param {FirebaseFirestore.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
- * @param {FirebaseFirestore.FirestoreDataConverter<DbModelType>} [options.converter] - Optional data converter for reading and writing Firestore documents.
- * @param {UseMutationOptions<AppModelType, Error, { data: DbModelType }, TContext>} [options.options={}] - Optional configuration for the mutation.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {mutate} = useAddDocMutation({
+ *      options: {
+ *      },
+ *      reference: collection(),
+ *  });
  *
- * @returns {UseMutationResult<AppModelType, Error, { data: DbModelType }, TContext>} The mutation hook result containing status, error, and data of the mutation process.
+ *  // ....
+ *  mutate({data: {test: 'value'}});
+ *  // ....
+ * };
+ * ```
  */
-export const useAddDocMutation = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
-    TContext = unknown
->({
-    reference,
-    converter,
+export const useAddDocMutation = <AppModelType extends AppModel = AppModel, TContext = unknown>({
+    collectionReference,
     options = {}
-}: UseAddDocMutationOptions<AppModelType, DbModelType, TContext>) => {
-    const mutationKey = useMemo(() => [reference.path], [reference.path]);
+}: UseAddDocMutationOptions<AppModelType, TContext>) => {
+    const mutationKey = useMemo(() => [collectionReference.path], [collectionReference.path]);
 
     return useMutation({
+        mutationKey,
         ...options,
         mutationFn: async ({ data }) => {
-            const docRef = await addDoc<AppModelType, DbModelType>(reference, data);
-            const docSnap = await getDoc(converter ? docRef.withConverter(converter) : docRef);
-            return docSnap.data() as AppModelType;
-        },
-        mutationKey
+            const docRef = await addDoc<AppModelType, AppModelType>(collectionReference, data);
+            const docSnap = await getDoc(docRef);
+            return { ...docSnap.data(), uid: docSnap.id } as AppModelType;
+        }
     });
 };

package/web/firestore/useBatchWrite.d.ts

@@ -1,15 +1,42 @@
 import { UseMutationOptions } from "@tanstack/react-query";
 import { WriteBatch } from "firebase/firestore";
 import { FirebaseError } from "firebase/app";
+/**
+ * @inline
+ */
 export type UseBatchWriteVariables = (batch: WriteBatch) => Promise<void> | void;
-export type UseBatchWriteOptions<TContext = unknown> = {
-    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
+/**
+ * @inline
+ */
+export type UseBatchWriteOptions = {
+    /**
+     * Options for useMutation hook excluding mutationFn. MutationKey will be equal to reference.path by default.
+     */
+    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables>, "mutationFn">;
 };
 /**
  * Custom hook to perform batch write operations using Firestore.
- * Utilizes a mutation to carry out the batch write transaction.
- * @template TContext - The type of context that can be passed into the hook, defaults to unknown.
- * @param {Object} options - The configuration options for the mutation operation.
- * @returns {Object} Returns an object composed of elements returned by useMutation, including properties such as status, and functions to trigger and control the mutation process.
+ *
+ * @group Hook
+ *
+ * @param {UseBatchWriteOptions} options - Configuration options for the query.
+ *
+ * @returns {UseMutationResult<void, Error, UseAddDocMutationValues<AppModelType>>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {mutate} = useBatchWrite({
+ *      options: {
+ *      },
+ *  });
+ *
+ *  // ....
+ *  mutate(() => {
+ *      ref.update({...})
+ *  });
+ *  // ....
+ * };
+ * ```
  */
-export declare const useBatchWrite: <TContext = unknown>({ options }?: UseBatchWriteOptions<TContext>) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseBatchWriteVariables, TContext>;
+export declare const useBatchWrite: ({ options }?: UseBatchWriteOptions) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseBatchWriteVariables, unknown>;

package/web/firestore/useBatchWrite.js

@@ -3,10 +3,28 @@ import { writeBatch } from "firebase/firestore";
 import { useFirestore } from "./useFirestore";
 /**
  * Custom hook to perform batch write operations using Firestore.
- * Utilizes a mutation to carry out the batch write transaction.
- * @template TContext - The type of context that can be passed into the hook, defaults to unknown.
- * @param {Object} options - The configuration options for the mutation operation.
- * @returns {Object} Returns an object composed of elements returned by useMutation, including properties such as status, and functions to trigger and control the mutation process.
+ *
+ * @group Hook
+ *
+ * @param {UseBatchWriteOptions} options - Configuration options for the query.
+ *
+ * @returns {UseMutationResult<void, Error, UseAddDocMutationValues<AppModelType>>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {mutate} = useBatchWrite({
+ *      options: {
+ *      },
+ *  });
+ *
+ *  // ....
+ *  mutate(() => {
+ *      ref.update({...})
+ *  });
+ *  // ....
+ * };
+ * ```
  */
 export const useBatchWrite = ({ options = {} } = {}) => {
     const db = useFirestore();

package/web/firestore/useBatchWrite.ts

@@ -4,20 +4,47 @@ import { writeBatch, WriteBatch } from "firebase/firestore";
 import { FirebaseError } from "firebase/app";
 import { useFirestore } from "./useFirestore";
 
+/**
+ * @inline
+ */
 export type UseBatchWriteVariables = (batch: WriteBatch) => Promise<void> | void;
 
-export type UseBatchWriteOptions<TContext = unknown> = {
-    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
+/**
+ * @inline
+ */
+export type UseBatchWriteOptions = {
+    /**
+     * Options for useMutation hook excluding mutationFn. MutationKey will be equal to reference.path by default.
+     */
+    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables>, "mutationFn">;
 };
 
 /**
  * Custom hook to perform batch write operations using Firestore.
- * Utilizes a mutation to carry out the batch write transaction.
- * @template TContext - The type of context that can be passed into the hook, defaults to unknown.
- * @param {Object} options - The configuration options for the mutation operation.
- * @returns {Object} Returns an object composed of elements returned by useMutation, including properties such as status, and functions to trigger and control the mutation process.
+ *
+ * @group Hook
+ *
+ * @param {UseBatchWriteOptions} options - Configuration options for the query.
+ *
+ * @returns {UseMutationResult<void, Error, UseAddDocMutationValues<AppModelType>>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {mutate} = useBatchWrite({
+ *      options: {
+ *      },
+ *  });
+ *
+ *  // ....
+ *  mutate(() => {
+ *      ref.update({...})
+ *  });
+ *  // ....
+ * };
+ * ```
  */
-export const useBatchWrite = <TContext = unknown>({ options = {} }: UseBatchWriteOptions<TContext> = {}) => {
+export const useBatchWrite = ({ options = {} }: UseBatchWriteOptions = {}) => {
     const db = useFirestore();
 
     return useMutation({

package/web/firestore/useCollectionReference.d.ts

@@ -1,18 +1,39 @@
-import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
-export type UseCollectionReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+import { CollectionReference, DocumentReference } from "firebase/firestore";
+import { AppModel } from "../../types";
+/**
+ * @inline
+ */
+export type UseCollectionReferenceOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * CollectionReference or DocumentReference that is used as a root to lookup a sub-collection
+     */
+    reference?: CollectionReference<AppModelType, AppModelType> | DocumentReference<AppModelType, AppModelType>;
+    /**
+     * A slash-separated path to a collection.
+     */
     path: string;
+    /**
+     * Additional path segments that will be applied relative
+     */
     pathSegments?: string[];
 };
 /**
- * Creates a reference to a Firestore collection based on the provided path, reference, and path segments.
+ * Gets a `CollectionReference` instance that refers to a subcollection of
+ * `reference` at the specified relative path.
+ *
+ * @group Hook
+ *
+ * @param {UseCollectionReferenceOptions<AppModelType>} options - Options
  *
- * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
+ * @returns {CollectionReference<AppModelType, AppModelType>} A reference to a Firestore collection
  *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
- * @param {string} options.path - The base path for the collection.
- * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
- * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
- * @returns {CollectionReference} A Firestore collection reference constructed using the specified path, reference, and path segments.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const ref = useCollectionReference({
+ *      path: 'todos'
+ *  });
+ * };
+ * ```
  */
-export declare const useCollectionReference: <AppModelType, DbModelType extends DocumentData = DocumentData>({ path, reference, pathSegments }: UseCollectionReferenceOptions<AppModelType, DbModelType>) => CollectionReference<DocumentData, DocumentData>;
+export declare const useCollectionReference: <AppModelType extends AppModel = AppModel>({ path, reference, pathSegments }: UseCollectionReferenceOptions<AppModelType>) => CollectionReference<AppModelType, AppModelType>;

package/web/firestore/useCollectionReference.js

@@ -2,15 +2,23 @@ import { collection } from "firebase/firestore";
 import { useMemo } from "react";
 import { useFirestore } from "./useFirestore";
 /**
- * Creates a reference to a Firestore collection based on the provided path, reference, and path segments.
+ * Gets a `CollectionReference` instance that refers to a subcollection of
+ * `reference` at the specified relative path.
  *
- * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
+ * @group Hook
  *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
- * @param {string} options.path - The base path for the collection.
- * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
- * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
- * @returns {CollectionReference} A Firestore collection reference constructed using the specified path, reference, and path segments.
+ * @param {UseCollectionReferenceOptions<AppModelType>} options - Options
+ *
+ * @returns {CollectionReference<AppModelType, AppModelType>} A reference to a Firestore collection
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const ref = useCollectionReference({
+ *      path: 'todos'
+ *  });
+ * };
+ * ```
  */
 export const useCollectionReference = ({ path, reference, pathSegments }) => {
     const db = useFirestore();

package/web/firestore/useCollectionReference.ts

@@ -1,30 +1,51 @@
-import { collection, CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+import { collection, CollectionReference, DocumentReference } from "firebase/firestore";
 
 import { useMemo } from "react";
 import { useFirestore } from "./useFirestore";
+import { AppModel } from "../../types";
 
-export type UseCollectionReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+/**
+ * @inline
+ */
+export type UseCollectionReferenceOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * CollectionReference or DocumentReference that is used as a root to lookup a sub-collection
+     */
+    reference?: CollectionReference<AppModelType, AppModelType> | DocumentReference<AppModelType, AppModelType>;
+    /**
+     * A slash-separated path to a collection.
+     */
     path: string;
+    /**
+     * Additional path segments that will be applied relative
+     */
     pathSegments?: string[];
 };
 
 /**
- * Creates a reference to a Firestore collection based on the provided path, reference, and path segments.
+ * Gets a `CollectionReference` instance that refers to a subcollection of
+ * `reference` at the specified relative path.
+ *
+ * @group Hook
+ *
+ * @param {UseCollectionReferenceOptions<AppModelType>} options - Options
  *
- * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
+ * @returns {CollectionReference<AppModelType, AppModelType>} A reference to a Firestore collection
  *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
- * @param {string} options.path - The base path for the collection.
- * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
- * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
- * @returns {CollectionReference} A Firestore collection reference constructed using the specified path, reference, and path segments.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const ref = useCollectionReference({
+ *      path: 'todos'
+ *  });
+ * };
+ * ```
  */
-export const useCollectionReference = <AppModelType, DbModelType extends DocumentData = DocumentData>({
+export const useCollectionReference = <AppModelType extends AppModel = AppModel>({
     path,
     reference,
     pathSegments
-}: UseCollectionReferenceOptions<AppModelType, DbModelType>) => {
+}: UseCollectionReferenceOptions<AppModelType>) => {
     const db = useFirestore();
 
     return useMemo(() => {
@@ -33,5 +54,5 @@ export const useCollectionReference = <AppModelType, DbModelType extends Documen
             : reference.type === "collection"
               ? collection(reference, path, ...(pathSegments || []))
               : collection(reference, path, ...(pathSegments || []));
-    }, [path, reference, pathSegments, db]);
+    }, [path, reference, pathSegments, db]) as CollectionReference<AppModelType, AppModelType>;
 };

package/web/firestore/useCompositeFilter.d.ts

@@ -1,56 +1,11 @@
-import { QueryFilterConstraint as FBQueryFilterConstraint, QueryCompositeFilterConstraint as FBQueryCompositeFilterConstraint, WhereFilterOp } from "firebase/firestore";
 import { AppModel } from "../../types";
-export type QueryFilterConstraint = FBQueryFilterConstraint | FBQueryCompositeFilterConstraint;
-export type QueryElement<AppModelType extends AppModel = AppModel> = {
-    operator?: "OR" | "AND";
-    children?: QueryElement[];
-    field?: keyof (AppModelType & {
-        documentId?: string[];
-    });
-    value?: AppModelType[keyof AppModelType];
-    op?: WhereFilterOp;
-};
-export type CompositeFilter<AppModelType extends AppModel = AppModel> = {
-    operator: "OR" | "AND";
-    children: QueryElement<AppModelType & {
-        documentId?: string[];
-    }>[];
-};
+import { CompositeFilter } from "./utils/buildCompositeFilter";
 /**
  * @inline
  */
 export type UseCompositeFilter<AppModelType extends AppModel = AppModel> = {
     query?: CompositeFilter<AppModelType>;
 };
-/**
- * Constructs a composite or where query filter based on the provided query structure.
- * It recursively builds query constraints using logical "or" or "and" operators.
- *
- * @group Utility
- *
- * @param {QueryElement<AppModelType>} query
- *
- * @returns {QueryFilterConstraint | null}
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const filter = buildCompositeFilter({
- *      operator: "AND",
- *      children: [
- *          {
- *              field: "field",
- *              value: "value",
- *              op: "=="
- *          },
- *          ...(query ? [query] : [])
- *      ]
- *  });
- *  console.log(filter);
- * };
- * ```
- */
-export declare const buildCompositeFilter: <AppModelType extends AppModel = AppModel>(query: QueryElement<AppModelType>) => QueryFilterConstraint | null;
 /**
  * A custom hook that constructs a composite or where query filter based on the provided query structure.
  * It recursively builds query constraints using logical "or" or "and" operators.
@@ -79,4 +34,4 @@ export declare const buildCompositeFilter: <AppModelType extends AppModel = AppM
  * };
  * ```
  */
-export declare const useCompositeFilter: <AppModelType extends AppModel = AppModel>({ query }: UseCompositeFilter<AppModelType>) => FBQueryCompositeFilterConstraint | undefined;
+export declare const useCompositeFilter: <AppModelType extends AppModel = AppModel>({ query }: UseCompositeFilter<AppModelType>) => import("@firebase/firestore").QueryCompositeFilterConstraint | undefined;

package/web/firestore/useCompositeFilter.js

@@ -1,46 +1,6 @@
-import { documentId, and, or, where } from "firebase/firestore";
+import { and, or } from "firebase/firestore";
 import { useMemo } from "react";
-/**
- * Constructs a composite or where query filter based on the provided query structure.
- * It recursively builds query constraints using logical "or" or "and" operators.
- *
- * @group Utility
- *
- * @param {QueryElement<AppModelType>} query
- *
- * @returns {QueryFilterConstraint | null}
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const filter = buildCompositeFilter({
- *      operator: "AND",
- *      children: [
- *          {
- *              field: "field",
- *              value: "value",
- *              op: "=="
- *          },
- *          ...(query ? [query] : [])
- *      ]
- *  });
- *  console.log(filter);
- * };
- * ```
- */
-export const buildCompositeFilter = (query) => {
-    if (query.children) {
-        const queryConstraints = query.children.map(buildCompositeFilter).filter((constraint) => !!constraint);
-        if (queryConstraints.length <= 0) {
-            return null;
-        }
-        return query.operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
-    }
-    if (query.field && query.op) {
-        return where(query.field === "documentId" ? documentId() : query.field, query.op, query.value);
-    }
-    return null;
-};
+import { buildCompositeFilter } from "./utils/buildCompositeFilter";
 /**
  * A custom hook that constructs a composite or where query filter based on the provided query structure.
  * It recursively builds query constraints using logical "or" or "and" operators.

package/web/firestore/useCompositeFilter.ts

@@ -1,29 +1,7 @@
-import {
-    QueryFilterConstraint as FBQueryFilterConstraint,
-    QueryCompositeFilterConstraint as FBQueryCompositeFilterConstraint,
-    WhereFilterOp,
-    documentId,
-    and,
-    or,
-    where
-} from "firebase/firestore";
+import { and, or } from "firebase/firestore";
 import { useMemo } from "react";
 import { AppModel } from "../../types";
-
-export type QueryFilterConstraint = FBQueryFilterConstraint | FBQueryCompositeFilterConstraint;
-
-export type QueryElement<AppModelType extends AppModel = AppModel> = {
-    operator?: "OR" | "AND";
-    children?: QueryElement[];
-    field?: keyof (AppModelType & { documentId?: string[] });
-    value?: AppModelType[keyof AppModelType];
-    op?: WhereFilterOp;
-};
-
-export type CompositeFilter<AppModelType extends AppModel = AppModel> = {
-    operator: "OR" | "AND";
-    children: QueryElement<AppModelType & { documentId?: string[] }>[];
-};
+import { CompositeFilter, buildCompositeFilter, QueryFilterConstraint } from "./utils/buildCompositeFilter";
 
 /**
  * @inline
@@ -32,54 +10,6 @@ export type UseCompositeFilter<AppModelType extends AppModel = AppModel> = {
     query?: CompositeFilter<AppModelType>;
 };
 
-/**
- * Constructs a composite or where query filter based on the provided query structure.
- * It recursively builds query constraints using logical "or" or "and" operators.
- *
- * @group Utility
- *
- * @param {QueryElement<AppModelType>} query
- *
- * @returns {QueryFilterConstraint | null}
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const filter = buildCompositeFilter({
- *      operator: "AND",
- *      children: [
- *          {
- *              field: "field",
- *              value: "value",
- *              op: "=="
- *          },
- *          ...(query ? [query] : [])
- *      ]
- *  });
- *  console.log(filter);
- * };
- * ```
- */
-export const buildCompositeFilter = <AppModelType extends AppModel = AppModel>(
-    query: QueryElement<AppModelType>
-): QueryFilterConstraint | null => {
-    if (query.children) {
-        const queryConstraints = query.children.map(buildCompositeFilter).filter((constraint) => !!constraint);
-
-        if (queryConstraints.length <= 0) {
-            return null;
-        }
-
-        return (query as CompositeFilter).operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
-    }
-
-    if (query.field && query.op) {
-        return where(query.field === "documentId" ? documentId() : (query.field as string), query.op, query.value);
-    }
-
-    return null;
-};
-
 /**
  * A custom hook that constructs a composite or where query filter based on the provided query structure.
  * It recursively builds query constraints using logical "or" or "and" operators.

package/web/firestore/useCountQuery.d.ts

@@ -1,11 +1,11 @@
 import { CollectionReference, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
 import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
-import { QueryFilterConstraint } from "./useCompositeFilter";
+import { QueryFilterConstraint } from "./utils/buildCompositeFilter";
 import { AppModel } from "../../types";
 /**
  * @inline
  */
-type UseCountQueryOptions<AppModelType extends AppModel = AppModel, DbModelType extends AppModel = AppModel> = {
+type UseCountQueryOptions<AppModelType extends AppModel = AppModel> = {
     /**
      * Reqct-query options that must include queryKey and shall not define queryFn
      */
@@ -13,7 +13,7 @@ type UseCountQueryOptions<AppModelType extends AppModel = AppModel, DbModelType
     /**
      * Reference to a Firestore collection
      */
-    collectionReference: CollectionReference<AppModelType, DbModelType>;
+    collectionReference: CollectionReference<AppModelType, AppModelType>;
     /**
      * Non composite filter constraints such as limit, order, where
      */
@@ -45,5 +45,5 @@ type UseCountQueryOptions<AppModelType extends AppModel = AppModel, DbModelType
  * };
  * ```
  */
-export declare const useCountQuery: <AppModelType extends AppModel = AppModel, DbModelType extends AppModel = AppModel>({ options, collectionReference, queryConstraints, compositeFilter }: UseCountQueryOptions<AppModelType, DbModelType>) => UseQueryResult<number>;
+export declare const useCountQuery: <AppModelType extends AppModel = AppModel>({ options, collectionReference, queryConstraints, compositeFilter }: UseCountQueryOptions<AppModelType>) => UseQueryResult<number>;
 export {};