react-query-firebase 1.3.3 → 2.0.0-rc1

package/src/auth/useIdToken.ts

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useState } from "react";
 import { useCurrentUser } from "./useCurrentUser";
-import { onIdTokenChanged } from "firebase/auth";
+import { onIdTokenChanged, FirebaseAuthTypes } from "@react-native-firebase/auth";
 import { useAuth } from "./useAuth";
 
 /**
@@ -63,7 +63,7 @@ export const useIdToken = (): UseIdTokenResult => {
     }, [currentUser?.uid ?? ""]);
 
     useEffect(() => {
-        const unsubscribe = onIdTokenChanged(auth, (user) => {
+        const unsubscribe = onIdTokenChanged(auth, (user: FirebaseAuthTypes.User) => {
             if (user) {
                 user.getIdToken().then((idToken) => {
                     setIdToken(idToken);

package/src/auth/useReauthenticateWitCredentialMutation.ts

@@ -1,11 +1,11 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { reauthenticateWithCredential, User, AuthCredential, UserCredential } from "firebase/auth";
+import { reauthenticateWithCredential, FirebaseAuthTypes } from "@react-native-firebase/auth";
 import { REAUTHENTICATE_WITH_CREDENTIAL_MUTATION_KEY } from "./mutation-keys";
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 
 export type UseReauthenticateWitCredentialMutationVariables = {
-    credential: AuthCredential;
-    user: User;
+    credential: FirebaseAuthTypes.AuthCredential;
+    user: FirebaseAuthTypes.User;
 };
 
 /**
@@ -13,12 +13,17 @@ export type UseReauthenticateWitCredentialMutationVariables = {
  * This hook utilizes useMutation from React Query to manage the asynchronous re-authentication
  * process with Firebase credentials. It omits the default "mutationKey" and "mutationFn" options.
  *
- * @param {Omit<UseMutationOptions<UserCredential, FirebaseError, UseReauthenticateWitCredentialMutationVariables, TContext>, "mutationKey" | "mutationFn">}  options - Optional mutation options excluding "mutationKey" and "mutationFn".
- * @returns {UseMutationResult<UserCredential, FirebaseError, UseReauthenticateWitCredentialMutationVariables, TContext>} A useMutation result object managing the loading, error, and result state of the re-authentication mutation.
+ * @param {Omit<UseMutationOptions<FirebaseAuthTypes.UserCredential, ReactNativeFirebase.NativeFirebaseError, UseReauthenticateWitCredentialMutationVariables, TContext>, "mutationKey" | "mutationFn">}  options - Optional mutation options excluding "mutationKey" and "mutationFn".
+ * @returns {UseMutationResult<FirebaseAuthTypes.UserCredential, ReactNativeFirebase.NativeFirebaseError, UseReauthenticateWitCredentialMutationVariables, TContext>} A useMutation result object managing the loading, error, and result state of the re-authentication mutation.
  */
 export const useReauthenticateWitCredentialMutation = <TContext = unknown>(
     options: Omit<
-        UseMutationOptions<UserCredential, FirebaseError, UseReauthenticateWitCredentialMutationVariables, TContext>,
+        UseMutationOptions<
+            FirebaseAuthTypes.UserCredential,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseReauthenticateWitCredentialMutationVariables,
+            TContext
+        >,
         "mutationKey" | "mutationFn"
     > = {}
 ) => {

package/src/auth/useReauthenticateWitRedirectMutation.ts

@@ -1,26 +1,31 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { reauthenticateWithRedirect, AuthProvider, PopupRedirectResolver, User } from "firebase/auth";
+import { reauthenticateWithRedirect, FirebaseAuthTypes, PopupRedirectResolver } from "@react-native-firebase/auth";
 
 import { REAUTHENTICATE_WITH_REDIRECT_MUTATION_KEY } from "./mutation-keys";
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 
 export type UseReauthenticateWitRedirectMutationVariables = {
-    authProvider: AuthProvider;
+    authProvider: FirebaseAuthTypes.AuthProvider;
     popupRedirectResolver?: PopupRedirectResolver;
-    user: User;
+    user: FirebaseAuthTypes.User;
 };
 
 /**
  * Custom hook that provides a mutation to reauthenticate a user with a given authentication provider using redirection.
  * This hook uses the `useMutation` hook from the React Query library to handle async mutation logic.
  *
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseReauthenticateWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Optional configuration object for the mutation. It provides the ability to pass options to customize the behavior of the mutation.
+ * @param {Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, UseReauthenticateWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Optional configuration object for the mutation. It provides the ability to pass options to customize the behavior of the mutation.
  * @template TContext - The type of any additional context you wish to pass to the mutation.
- * @returns {UseMutationResult<void, FirebaseError, UseReauthenticateWitRedirectMutationVariables, TContext>} A mutation result object containing methods and state of the mutation.
+ * @returns {UseMutationResult<void, ReactNativeFirebase.NativeFirebaseError, UseReauthenticateWitRedirectMutationVariables, TContext>} A mutation result object containing methods and state of the mutation.
  */
 export const useReauthenticateWitRedirectMutation = <TContext = unknown>(
     options: Omit<
-        UseMutationOptions<void, FirebaseError, UseReauthenticateWitRedirectMutationVariables, TContext>,
+        UseMutationOptions<
+            void,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseReauthenticateWitRedirectMutationVariables,
+            TContext
+        >,
         "mutationKey" | "mutationFn"
     > = {}
 ) => {

package/src/auth/useSendEmailVerificationMutation.ts

@@ -1,22 +1,27 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { sendEmailVerification, User } from "firebase/auth";
+import { sendEmailVerification, FirebaseAuthTypes } from "@react-native-firebase/auth";
 
 import { SEND_EMAIL_VERIFICATION_MUTATION_KEY } from "./mutation-keys";
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 
 export type UseSendEmailVerificationMutationVariables = {
-    user: User;
+    user: FirebaseAuthTypes.User;
 };
 
 /**
  * A custom hook to create a mutation for sending an email verification to a user using Firebase.
  * This uses the `useMutation` hook from a query library and wraps it with specific configuration options.
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseSendEmailVerificationMutationVariables, TContext>, "queryKey" | "queryFn">} options - Configuration options for the mutation, excluding `queryKey` and `queryFn`.
- * @returns {UseMutationResult<void, FirebaseError, UseSendEmailVerificationMutationVariables, TContext>} An object containing mutation state and functions for managing the mutation lifecycle.
+ * @param {Omit<UseMutationOptions<void, ReactNativeFirebase.NativeReactNativeFirebase.NativeFirebaseError, UseSendEmailVerificationMutationVariables, TContext>, "queryKey" | "queryFn">} options - Configuration options for the mutation, excluding `queryKey` and `queryFn`.
+ * @returns {UseMutationResult<void, NativeReactNativeFirebase.NativeFirebaseError, UseSendEmailVerificationMutationVariables, TContext>} An object containing mutation state and functions for managing the mutation lifecycle.
  */
 export const useSendEmailVerificationMutation = <TContext = unknown>(
     options: Omit<
-        UseMutationOptions<void, FirebaseError, UseSendEmailVerificationMutationVariables, TContext>,
+        UseMutationOptions<
+            void,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseSendEmailVerificationMutationVariables,
+            TContext
+        >,
         "queryKey" | "queryFn"
     > = {}
 ) => {

package/src/auth/useSignInWitEmailAndPasswordMutation.ts

@@ -1,9 +1,9 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { signInWithEmailAndPassword, UserCredential } from "firebase/auth";
+import { signInWithEmailAndPassword, FirebaseAuthTypes } from "@react-native-firebase/auth";
 
 import { useAuth } from "./useAuth";
 import { SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY } from "./mutation-keys";
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 
 export type UseSignInWitEmailAndPasswordMutationVariables = {
     email: string;
@@ -14,12 +14,17 @@ export type UseSignInWitEmailAndPasswordMutationVariables = {
  * Custom hook to perform a sign-in operation using email and password with Firebase Authentication.
  * It utilizes the `useMutation` hook to manage the asynchronous operation and its state.
  *
- * @param {Omit<UseMutationOptions<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>, 'mutationKey' | 'mutationFn'>} options - Options to configure the mutation, excluding 'mutationKey' and 'mutationFn'.
+ * @param {Omit<UseMutationOptions<FirebaseAuthTypes.UserCredential, ReactNativeFirebase.NativeFirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>, 'mutationKey' | 'mutationFn'>} options - Options to configure the mutation, excluding 'mutationKey' and 'mutationFn'.
  * @returns {MutationResult} A mutation object containing the result of the sign-in process and helper functions.
  */
 export const useSignInWitEmailAndPasswordMutation = <TContext = unknown>(
     options: Omit<
-        UseMutationOptions<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>,
+        UseMutationOptions<
+            FirebaseAuthTypes.UserCredential,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseSignInWitEmailAndPasswordMutationVariables,
+            TContext
+        >,
         "mutationKey" | "mutationFn"
     > = {}
 ) => {

package/src/auth/useSignInWitRedirectMutation.ts

@@ -1,24 +1,29 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { signInWithRedirect, AuthProvider, PopupRedirectResolver } from "firebase/auth";
+import { signInWithRedirect, FirebaseAuthTypes, PopupRedirectResolver } from "@react-native-firebase/auth";
 
 import { useAuth } from "./useAuth";
 import { SIGN_IN_WITH_REDIRECT_MUTATION_KEY } from "./mutation-keys";
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 
 export type UseSignInWitRedirectMutationVariables = {
-    authProvider: AuthProvider;
+    authProvider: FirebaseAuthTypes.AuthProvider;
     popupRedirectResolver?: PopupRedirectResolver;
 };
 
 /**
  * Custom hook for handling Firebase authentication using sign-in with redirect functionality.
  * This hook utilizes the `useMutation` mechanism to perform the sign-in operation.
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Optional configurations for the mutation, omitting the mutationKey and mutationFn properties.
- * @returns {UseMutationResult<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>} The result object from the useMutation hook, containing the mutation function and its current state.
+ * @param {Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, UseSignInWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Optional configurations for the mutation, omitting the mutationKey and mutationFn properties.
+ * @returns {UseMutationResult<void, ReactNativeFirebase.NativeFirebaseError, UseSignInWitRedirectMutationVariables, TContext>} The result object from the useMutation hook, containing the mutation function and its current state.
  */
 export const useSignInWitRedirectMutation = <TContext = unknown>(
     options: Omit<
-        UseMutationOptions<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>,
+        UseMutationOptions<
+            void,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseSignInWitRedirectMutationVariables,
+            TContext
+        >,
         "mutationKey" | "mutationFn"
     > = {}
 ) => {

package/src/auth/useSignOutMutation.ts

@@ -1,19 +1,19 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { signOut } from "firebase/auth";
+import { signOut } from "@react-native-firebase/auth";
 
 import { SIGN_OUT_MUTATION_KEY } from "./mutation-keys";
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useAuth } from "./useAuth";
 
 /**
  * Custom hook for handling the sign-out mutation using Firebase authentication.
  * It wraps the useMutation hook to provide a sign-out function with Firebase.
  *
- * @param {Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "queryKey" | "queryFn">} options - Configuration options for the mutation, excluding "queryKey" and "queryFn".
- * @returns {UseMutationResult<void, FirebaseError, void, TContext>} A mutation object for handling the sign-out process, including methods for mutating and state tracking.
+ * @param {Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, void, TContext>, "queryKey" | "queryFn">} options - Configuration options for the mutation, excluding "queryKey" and "queryFn".
+ * @returns {UseMutationResult<void, ReactNativeFirebase.NativeFirebaseError, void, TContext>} A mutation object for handling the sign-out process, including methods for mutating and state tracking.
  */
 export const useSignOutMutation = <TContext = unknown>(
-    options: Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "queryKey" | "queryFn"> = {}
+    options: Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, void, TContext>, "queryKey" | "queryFn"> = {}
 ) => {
     const firebaseAuth = useAuth();
 

package/src/auth/useUpdateProfileMutation.ts

@@ -1,23 +1,23 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { updateProfile, User } from "firebase/auth";
-import { FirebaseError } from "firebase/app";
+import { updateProfile, FirebaseAuthTypes } from "@react-native-firebase/auth";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY } from "./mutation-keys";
 
 export type UseUpdateProfileMutationVariables = {
     displayName?: string;
-    user: User;
+    user: FirebaseAuthTypes.User;
 };
 
 /**
  * Custom hook to manage the mutation for updating a user's profile.
  * Utilizes Firebase for updating the user's display name.
  *
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Configuration options for the mutation, excluding mutationKey and mutationFn.
- * @returns {UseMutationResult<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>} The result of the mutation operation including statuses, data, and error information.
+ * @param {Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, UseUpdateProfileMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Configuration options for the mutation, excluding mutationKey and mutationFn.
+ * @returns {UseMutationResult<void, ReactNativeFirebase.NativeFirebaseError, UseUpdateProfileMutationVariables, TContext>} The result of the mutation operation including statuses, data, and error information.
  */
 export const useUpdateProfileMutation = <TContext = unknown>(
     options: Omit<
-        UseMutationOptions<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>,
+        UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, UseUpdateProfileMutationVariables, TContext>,
         "mutationKey" | "mutationFn"
     > = {}
 ) => {

package/src/context/FirebaseContext.ts

@@ -2,18 +2,14 @@
 
 import { createContext } from "react";
 
-import { Auth } from "firebase/auth";
-import { Analytics } from "firebase/analytics";
-import { Firestore } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { RemoteConfig } from "firebase/remote-config";
+import { firebase } from "@react-native-firebase/auth";
 
 type FirebaseContextValue = {
-    auth: Auth;
-    analytics: Analytics;
-    firebase: FirebaseApp;
-    remoteConfig: RemoteConfig;
-    firestore: Firestore;
+    auth: ReturnType<typeof firebase.auth>;
+    analytics: ReturnType<typeof firebase.analytics>;
+    firebase: ReturnType<typeof firebase.app>;
+    remoteConfig: ReturnType<typeof firebase.remoteConfig>;
+    firestore: ReturnType<typeof firebase.firestore>;
 };
 
 /**

package/src/context/FirebaseContextProvider.tsx

@@ -1,10 +1,29 @@
 import React, { PropsWithChildren, useEffect, useMemo } from "react";
 import { FirebaseContext } from "./FirebaseContext";
-import { connectAuthEmulator, getAuth } from "firebase/auth";
-import { ConsentSettings, getAnalytics, setAnalyticsCollectionEnabled, setConsent } from "firebase/analytics";
-import { getRemoteConfig, RemoteConfigSettings } from "firebase/remote-config";
-import { connectFirestoreEmulator, FirestoreSettings, initializeFirestore } from "firebase/firestore";
-import { FirebaseOptions, initializeApp } from "firebase/app";
+import { connectAuthEmulator } from "@react-native-firebase/auth";
+import { FirebaseAnalyticsTypes, setAnalyticsCollectionEnabled, setConsent } from "@react-native-firebase/analytics";
+import { FirebaseRemoteConfigTypes } from "@react-native-firebase/remote-config";
+import { connectFirestoreEmulator } from "@react-native-firebase/firestore";
+import firebase, { ReactNativeFirebase, initializeApp } from "@react-native-firebase/app";
+
+/**
+ * @inline
+ * @see https://firebase.google.com/docs/reference/js/firestore_.firestoresettings
+ */
+export type FirestoreSettings = {
+    cacheSizeBytes?: number;
+    experimentalAutoDetectLongPolling?: boolean;
+    experimentalForceLongPolling?: boolean;
+    experimentalLongPollingOptions?: {
+        timeoutSeconds: number;
+    };
+    host?: string;
+    ignoreUndefinedProperties?: boolean;
+    localCache?: {
+        kind: "memory" | "persistent";
+    };
+    ssl?: boolean;
+};
 
 /**
  * @inline
@@ -48,6 +67,7 @@ export type FirebaseContextProviderEmulators = {
  * @inline
  */
 export type FirebaseContextProviderProps = PropsWithChildren & {
+    platform: "Web" | "ReactNative";
     /**
      * Defines configuration for firebase emulators
      */
@@ -55,7 +75,7 @@ export type FirebaseContextProviderProps = PropsWithChildren & {
     /**
      * Configuration options for Firebase initialization. {@link https://firebase.google.com/docs/web/setup#config-object | Learn about the Firebase config object}
      */
-    options: FirebaseOptions;
+    options: ReactNativeFirebase.FirebaseAppOptions;
     /**
      * Flag indicating whether Firebase Auth should be enabled.
      */
@@ -77,7 +97,7 @@ export type FirebaseContextProviderProps = PropsWithChildren & {
      *                  security_storage: "denied"
      *              }
      */
-    consentSettings?: ConsentSettings;
+    consentSettings?: FirebaseAnalyticsTypes.ConsentSettings;
     /**
      * Specifies custom configurations for your Cloud Firestore instance.
      * You must set these before invoking any other methods.
@@ -94,7 +114,7 @@ export type FirebaseContextProviderProps = PropsWithChildren & {
      * Configuration options for Firebase Remote Config Settings. {@link https://firebase.google.com/docs/reference/js/remote-config.remoteconfigsettings | Learn about the Firebase Remote COnfig Settings object}
      * @defaultValue `true`
      */
-    remoteConfigSettings?: RemoteConfigSettings;
+    remoteConfigSettings?: FirebaseRemoteConfigTypes.ConfigSettings;
     /**
      * Configuration options for Firebase Remote Config Defaults.
      */
@@ -130,6 +150,7 @@ export type FirebaseContextProviderProps = PropsWithChildren & {
  * ```
  */
 export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = ({
+    platform,
     emulators,
     options,
     children,
@@ -142,40 +163,42 @@ export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = (
     remoteConfigDefaults = {},
     firestoreSettings
 }) => {
-    const firebase = useMemo(() => {
-        return initializeApp(options);
+    const internalFirebase = useMemo(() => {
+        return platform === "Web" ? initializeApp(options) : firebase;
     }, [options]);
 
     useEffect(() => {
-        setConsent({
-            ad_personalization: "denied",
-            ad_storage: "denied",
-            ad_user_data: "denied",
-            analytics_storage: "denied",
-            functionality_storage: "denied",
-            personalization_storage: "denied",
-            security_storage: "denied",
+        setConsent(firebase.analytics(), {
+            ad_personalization: false,
+            ad_storage: false,
+            ad_user_data: false,
+            analytics_storage: false,
+            functionality_storage: false,
+            personalization_storage: false,
+            security_storage: false,
             ...consentSettings
         });
-    }, [consentSettings]);
+    }, [consentSettings, firebase]);
 
-    const firestore = useMemo(() => {
+    const internalFirestore = useMemo(() => {
         if (firestoreEnabled) {
-            const localFirestore = initializeFirestore(firebase, firestoreSettings || {});
-
             if (emulators?.firestore?.host && emulators?.firestore?.port) {
-                connectFirestoreEmulator(localFirestore, emulators.firestore.host, emulators.firestore.port);
+                connectFirestoreEmulator(
+                    internalFirebase.firestore(),
+                    emulators.firestore.host,
+                    emulators.firestore.port
+                );
             }
 
-            return localFirestore;
+            return internalFirebase.firestore();
         }
 
         return null;
-    }, [firestoreSettings, emulators?.firestore, firestoreEnabled]);
+    }, [firestoreSettings, emulators?.firestore, firestoreEnabled, internalFirebase]);
 
-    const auth = useMemo(() => {
+    const internalAuth = useMemo(() => {
         if (authEnabled) {
-            const localAuth = getAuth(firebase);
+            const localAuth = internalFirebase.auth();
             if (emulators?.auth?.host) {
                 connectAuthEmulator(localAuth, emulators?.auth?.host, {
                     disableWarnings: true
@@ -184,42 +207,46 @@ export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = (
             return localAuth;
         }
         return null;
-    }, [emulators?.auth, authEnabled]);
+    }, [emulators?.auth, authEnabled, internalFirebase]);
 
-    const analytics = useMemo(() => {
-        if (analyticsEnabled && options.measurementId && typeof window !== "undefined") {
-            return getAnalytics(firebase);
+    const internalAnalytics = useMemo(() => {
+        if (
+            analyticsEnabled &&
+            options.measurementId &&
+            (typeof window !== "undefined" || platform === "ReactNative")
+        ) {
+            return internalFirebase.analytics();
         }
         return null;
-    }, [analyticsEnabled, options.measurementId]);
+    }, [analyticsEnabled, options.measurementId, internalFirebase]);
 
-    const remoteConfig = useMemo(() => {
-        if (remoteConfigEnabled && typeof window !== "undefined") {
-            const localRemoteConfig = getRemoteConfig(firebase);
+    const internalRemoteConfig = useMemo(() => {
+        if (remoteConfigEnabled && (typeof window !== "undefined" || platform === "ReactNative")) {
+            const localRemoteConfig = internalFirebase.remoteConfig();
             if (remoteConfigSettings) {
-                localRemoteConfig.settings.fetchTimeoutMillis = remoteConfigSettings.fetchTimeoutMillis;
+                localRemoteConfig.settings.fetchTimeMillis = remoteConfigSettings.fetchTimeMillis;
                 localRemoteConfig.settings.minimumFetchIntervalMillis = remoteConfigSettings.minimumFetchIntervalMillis;
                 localRemoteConfig.defaultConfig = remoteConfigDefaults;
             }
             return localRemoteConfig;
         }
         return null;
-    }, [remoteConfigEnabled]);
+    }, [remoteConfigEnabled, remoteConfigSettings, internalFirebase]);
 
     const contextValue = useMemo(
         () => ({
-            firebase,
-            auth,
-            analytics,
-            firestore,
-            remoteConfig
+            firebase: internalFirebase,
+            auth: internalAuth,
+            analytics: internalAnalytics,
+            firestore: internalFirestore,
+            remoteConfig: internalRemoteConfig
         }),
-        [firebase, auth, analytics, firestore, remoteConfig]
+        [internalFirebase, internalAuth, internalAnalytics, internalFirestore, internalRemoteConfig]
     );
 
     useEffect(() => {
         if (contextValue.analytics) {
-            setAnalyticsCollectionEnabled(contextValue.analytics, consentSettings?.analytics_storage === "granted");
+            setAnalyticsCollectionEnabled(contextValue.analytics, !!consentSettings?.analytics_storage);
         }
     }, [consentSettings]);
 

package/src/firestore/useAddDocMutation.ts

@@ -1,14 +1,7 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import {
-    DocumentData,
-    addDoc,
-    WithFieldValue,
-    CollectionReference,
-    getDoc,
-    FirestoreDataConverter
-} from "firebase/firestore";
+import { FirebaseFirestoreTypes, addDoc, WithFieldValue, getDoc } from "@react-native-firebase/firestore";
 
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useMemo } from "react";
 
 export type UseAddDocMutationValues<AppModelType> = {
@@ -16,14 +9,17 @@ export type UseAddDocMutationValues<AppModelType> = {
 };
 
 export type UseAddDocMutationOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 > = {
-    reference: CollectionReference<AppModelType, DbModelType>;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+    reference: FirebaseFirestoreTypes.CollectionReference<AppModelType>;
     options?: Omit<
-        UseMutationOptions<AppModelType, FirebaseError, UseAddDocMutationValues<AppModelType>, TContext>,
+        UseMutationOptions<
+            AppModelType,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseAddDocMutationValues<AppModelType>,
+            TContext
+        >,
         "mutationFn" | "mutationKey"
     >;
 };
@@ -33,28 +29,25 @@ export type UseAddDocMutationOptions<
  * It handles addition and optional conversion of the document data in Firestore.
  *
  * @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 {FirebaseFirestore.FirebaseFirestoreTypes.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
  * @param {UseMutationOptions<AppModelType, Error, { data: DbModelType }, TContext>} [options.options={}] - Optional configuration for the mutation.
  *
  * @returns {UseMutationResult<AppModelType, Error, { data: DbModelType }, TContext>} The mutation hook result containing status, error, and data of the mutation process.
  */
 export const useAddDocMutation = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 >({
     reference,
-    converter,
     options = {}
-}: UseAddDocMutationOptions<AppModelType, DbModelType, TContext>) => {
+}: UseAddDocMutationOptions<AppModelType, TContext>) => {
     const mutationKey = useMemo(() => [reference.path], [reference.path]);
 
     return useMutation({
         ...options,
         mutationFn: async ({ data }) => {
-            const docRef = await addDoc<AppModelType, DbModelType>(reference, data);
-            const docSnap = await getDoc(converter ? docRef.withConverter(converter) : docRef);
+            const docRef = await addDoc<AppModelType>(reference, data);
+            const docSnap = await getDoc(docRef);
             return docSnap.data() as AppModelType;
         },
         mutationKey

package/src/firestore/useBatchWrite.ts

@@ -1,13 +1,16 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { writeBatch, WriteBatch } from "firebase/firestore";
+import { writeBatch, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useFirestore } from "./useFirestore";
 
-export type UseBatchWriteVariables = (batch: WriteBatch) => Promise<void> | void;
+export type UseBatchWriteVariables = (batch: FirebaseFirestoreTypes.WriteBatch) => Promise<void> | void;
 
 export type UseBatchWriteOptions<TContext = unknown> = {
-    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
+    options?: Omit<
+        UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, UseBatchWriteVariables, TContext>,
+        "mutationFn"
+    >;
 };
 
 /**

package/src/firestore/useCollectionReference.ts

@@ -1,10 +1,14 @@
-import { collection, CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+import { collection, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
 import { useMemo } from "react";
 import { useFirestore } from "./useFirestore";
 
-export type UseCollectionReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+export type UseCollectionReferenceOptions<
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+> = {
+    reference?:
+        | FirebaseFirestoreTypes.CollectionReference<AppModelType>
+        | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
     path: string;
     pathSegments?: string[];
 };
@@ -14,24 +18,24 @@ export type UseCollectionReferenceOptions<AppModelType, DbModelType extends Docu
  *
  * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
  *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
+ * @param {UseCollectionReferenceOptions<AppModelType>} 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.
  */
-export const useCollectionReference = <AppModelType, DbModelType extends DocumentData = DocumentData>({
+export const useCollectionReference = <
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+>({
     path,
     reference,
     pathSegments
-}: UseCollectionReferenceOptions<AppModelType, DbModelType>) => {
+}: UseCollectionReferenceOptions<AppModelType>) => {
     const db = useFirestore();
 
     return useMemo(() => {
         return !reference
             ? collection(db, path || "", ...(pathSegments || []))
-            : reference.type === "collection"
-              ? collection(reference, path, ...(pathSegments || []))
-              : collection(reference, path, ...(pathSegments || []));
+            : collection(reference, path, ...(pathSegments || []));
     }, [path, reference?.path, pathSegments]);
 };