@growsober/sdk 1.0.0

package/dist/api/mutations/ambassadors.d.ts

@@ -0,0 +1,52 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { AmbassadorResponse, ApplyAmbassadorRequest, UpdateAmbassadorRequest } from '../types';
+/**
+ * Apply to become an ambassador
+ */
+export declare function useApplyAmbassador(options?: Omit<UseMutationOptions<AmbassadorResponse, Error, ApplyAmbassadorRequest>, 'mutationFn'>): UseMutationResult<AmbassadorResponse, Error, ApplyAmbassadorRequest>;
+/**
+ * Update own ambassador profile
+ */
+export declare function useUpdateMyAmbassador(options?: Omit<UseMutationOptions<AmbassadorResponse, Error, Partial<UpdateAmbassadorRequest>>, 'mutationFn'>): UseMutationResult<AmbassadorResponse, Error, Partial<UpdateAmbassadorRequest>>;
+/**
+ * Update ambassador (admin)
+ */
+export declare function useUpdateAmbassador(options?: Omit<UseMutationOptions<AmbassadorResponse, Error, {
+    id: string;
+    data: UpdateAmbassadorRequest;
+}>, 'mutationFn'>): UseMutationResult<AmbassadorResponse, Error, {
+    id: string;
+    data: UpdateAmbassadorRequest;
+}>;
+/**
+ * Approve ambassador application (admin)
+ */
+export declare function useApproveAmbassador(options?: Omit<UseMutationOptions<AmbassadorResponse, Error, string>, 'mutationFn'>): UseMutationResult<AmbassadorResponse, Error, string>;
+/**
+ * Reject ambassador application (admin)
+ */
+export declare function useRejectAmbassador(options?: Omit<UseMutationOptions<{
+    success: boolean;
+}, Error, string>, 'mutationFn'>): UseMutationResult<{
+    success: boolean;
+}, Error, string>;
+/**
+ * Deactivate ambassador (admin)
+ */
+export declare function useDeactivateAmbassador(options?: Omit<UseMutationOptions<AmbassadorResponse, Error, string>, 'mutationFn'>): UseMutationResult<AmbassadorResponse, Error, string>;
+/**
+ * Add reward points to ambassador (admin)
+ */
+export declare function useAddAmbassadorReward(options?: Omit<UseMutationOptions<{
+    success: boolean;
+}, Error, {
+    id: string;
+    points: number;
+    reason?: string;
+}>, 'mutationFn'>): UseMutationResult<{
+    success: boolean;
+}, Error, {
+    id: string;
+    points: number;
+    reason?: string;
+}>;

package/dist/api/mutations/ambassadors.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useApplyAmbassador = useApplyAmbassador;
+exports.useUpdateMyAmbassador = useUpdateMyAmbassador;
+exports.useUpdateAmbassador = useUpdateAmbassador;
+exports.useApproveAmbassador = useApproveAmbassador;
+exports.useRejectAmbassador = useRejectAmbassador;
+exports.useDeactivateAmbassador = useDeactivateAmbassador;
+exports.useAddAmbassadorReward = useAddAmbassadorReward;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const ambassadors_1 = require("../queries/ambassadors");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Apply to become an ambassador
+ */
+function useApplyAmbassador(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/ambassadors/apply', data);
+            return response.data;
+        },
+        onSuccess: (ambassador) => {
+            queryClient.setQueryData(ambassadors_1.ambassadorKeys.me(), ambassador);
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.lists() });
+        },
+        ...options,
+    });
+}
+/**
+ * Update own ambassador profile
+ */
+function useUpdateMyAmbassador(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put('/api/v1/ambassadors/me', data);
+            return response.data;
+        },
+        onSuccess: (ambassador) => {
+            queryClient.setQueryData(ambassadors_1.ambassadorKeys.me(), ambassador);
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.lists() });
+        },
+        ...options,
+    });
+}
+/**
+ * Update ambassador (admin)
+ */
+function useUpdateAmbassador(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ id, data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/ambassadors/${id}`, data);
+            return response.data;
+        },
+        onSuccess: (ambassador, { id }) => {
+            queryClient.setQueryData(ambassadors_1.ambassadorKeys.detail(id), ambassador);
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.pending() });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.leaderboard() });
+        },
+        ...options,
+    });
+}
+/**
+ * Approve ambassador application (admin)
+ */
+function useApproveAmbassador(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (id) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/ambassadors/${id}/approve`);
+            return response.data;
+        },
+        onSuccess: (ambassador, id) => {
+            queryClient.setQueryData(ambassadors_1.ambassadorKeys.detail(id), ambassador);
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.pending() });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.leaderboard() });
+        },
+        ...options,
+    });
+}
+/**
+ * Reject ambassador application (admin)
+ */
+function useRejectAmbassador(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (id) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/ambassadors/${id}/reject`);
+            return response.data;
+        },
+        onSuccess: (_, id) => {
+            queryClient.removeQueries({ queryKey: ambassadors_1.ambassadorKeys.detail(id) });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.pending() });
+        },
+        ...options,
+    });
+}
+/**
+ * Deactivate ambassador (admin)
+ */
+function useDeactivateAmbassador(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (id) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/ambassadors/${id}/deactivate`);
+            return response.data;
+        },
+        onSuccess: (ambassador, id) => {
+            queryClient.setQueryData(ambassadors_1.ambassadorKeys.detail(id), ambassador);
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.leaderboard() });
+        },
+        ...options,
+    });
+}
+/**
+ * Add reward points to ambassador (admin)
+ */
+function useAddAmbassadorReward(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ id, points, reason }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/ambassadors/${id}/reward`, { points, reason });
+            return response.data;
+        },
+        onSuccess: (_, { id }) => {
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.detail(id) });
+            queryClient.invalidateQueries({ queryKey: ambassadors_1.ambassadorKeys.leaderboard() });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ambassadors.js","sourceRoot":"","sources":["../../../src/api/mutations/ambassadors.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  useMutation,\n  useQueryClient,\n  UseMutationOptions,\n  UseMutationResult,\n} from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport type { AmbassadorResponse, ApplyAmbassadorRequest, UpdateAmbassadorRequest } from '../types';\nimport { ambassadorKeys } from '../queries/ambassadors';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Apply to become an ambassador\n */\nexport function useApplyAmbassador(\n  options?: Omit<\n    UseMutationOptions<AmbassadorResponse, Error, ApplyAmbassadorRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<AmbassadorResponse, Error, ApplyAmbassadorRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: ApplyAmbassadorRequest): Promise<AmbassadorResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/ambassadors/apply', data);\n      return response.data;\n    },\n    onSuccess: (ambassador) => {\n      queryClient.setQueryData(ambassadorKeys.me(), ambassador);\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.lists() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update own ambassador profile\n */\nexport function useUpdateMyAmbassador(\n  options?: Omit<\n    UseMutationOptions<AmbassadorResponse, Error, Partial<UpdateAmbassadorRequest>>,\n    'mutationFn'\n  >\n): UseMutationResult<AmbassadorResponse, Error, Partial<UpdateAmbassadorRequest>> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: Partial<UpdateAmbassadorRequest>): Promise<AmbassadorResponse> => {\n      const client = getApiClient();\n      const response = await client.put('/api/v1/ambassadors/me', data);\n      return response.data;\n    },\n    onSuccess: (ambassador) => {\n      queryClient.setQueryData(ambassadorKeys.me(), ambassador);\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.lists() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update ambassador (admin)\n */\nexport function useUpdateAmbassador(\n  options?: Omit<\n    UseMutationOptions<AmbassadorResponse, Error, { id: string; data: UpdateAmbassadorRequest }>,\n    'mutationFn'\n  >\n): UseMutationResult<AmbassadorResponse, Error, { id: string; data: UpdateAmbassadorRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ id, data }): Promise<AmbassadorResponse> => {\n      const client = getApiClient();\n      const response = await client.put(`/api/v1/ambassadors/${id}`, data);\n      return response.data;\n    },\n    onSuccess: (ambassador, { id }) => {\n      queryClient.setQueryData(ambassadorKeys.detail(id), ambassador);\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.lists() });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.pending() });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.leaderboard() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Approve ambassador application (admin)\n */\nexport function useApproveAmbassador(\n  options?: Omit<UseMutationOptions<AmbassadorResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<AmbassadorResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<AmbassadorResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/ambassadors/${id}/approve`);\n      return response.data;\n    },\n    onSuccess: (ambassador, id) => {\n      queryClient.setQueryData(ambassadorKeys.detail(id), ambassador);\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.lists() });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.pending() });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.leaderboard() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Reject ambassador application (admin)\n */\nexport function useRejectAmbassador(\n  options?: Omit<UseMutationOptions<{ success: boolean }, Error, string>, 'mutationFn'>\n): UseMutationResult<{ success: boolean }, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<{ success: boolean }> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/ambassadors/${id}/reject`);\n      return response.data;\n    },\n    onSuccess: (_, id) => {\n      queryClient.removeQueries({ queryKey: ambassadorKeys.detail(id) });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.lists() });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.pending() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Deactivate ambassador (admin)\n */\nexport function useDeactivateAmbassador(\n  options?: Omit<UseMutationOptions<AmbassadorResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<AmbassadorResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<AmbassadorResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/ambassadors/${id}/deactivate`);\n      return response.data;\n    },\n    onSuccess: (ambassador, id) => {\n      queryClient.setQueryData(ambassadorKeys.detail(id), ambassador);\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.lists() });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.leaderboard() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Add reward points to ambassador (admin)\n */\nexport function useAddAmbassadorReward(\n  options?: Omit<\n    UseMutationOptions<{ success: boolean }, Error, { id: string; points: number; reason?: string }>,\n    'mutationFn'\n  >\n): UseMutationResult<{ success: boolean }, Error, { id: string; points: number; reason?: string }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ id, points, reason }): Promise<{ success: boolean }> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/ambassadors/${id}/reward`, { points, reason });\n      return response.data;\n    },\n    onSuccess: (_, { id }) => {\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.detail(id) });\n      queryClient.invalidateQueries({ queryKey: ambassadorKeys.leaderboard() });\n    },\n    ...options,\n  });\n}\n"]}

package/dist/api/mutations/auth.d.ts

@@ -0,0 +1,267 @@
+/**
+ * Auth Mutation Hooks
+ *
+ * TanStack Query mutation hooks for authentication-related write operations.
+ * These hooks handle user registration, login, token refresh, and Firebase authentication.
+ *
+ * @module api/mutations/auth
+ */
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { RegisterRequest, LoginRequest, RefreshTokenRequest, FirebaseAuthRequest, AuthResponse, TokenResponse } from '../types';
+/**
+ * Register a new user account
+ *
+ * @description
+ * Creates a new user account with email/phone and password.
+ * Returns authentication tokens and user information upon successful registration.
+ *
+ * @endpoint POST /auth/register
+ *
+ * @example
+ * ```tsx
+ * import { useRegister } from '@growsober/sdk';
+ *
+ * function RegisterForm() {
+ *   const { mutate: register, isPending, error } = useRegister({
+ *     onSuccess: (data) => {
+ *       // Store tokens securely
+ *       await SecureStore.setItemAsync('accessToken', data.accessToken);
+ *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);
+ *       navigation.navigate('Onboarding');
+ *     },
+ *     onError: (error) => {
+ *       Alert.alert('Registration failed', error.message);
+ *     },
+ *   });
+ *
+ *   const handleSubmit = () => {
+ *     register({
+ *       email: 'user@example.com',
+ *       password: 'SecurePassword123!',
+ *       name: 'John Doe',
+ *     });
+ *   };
+ *
+ *   return <Button onPress={handleSubmit} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useRegister(options?: Omit<UseMutationOptions<AuthResponse, Error, RegisterRequest>, 'mutationFn'>): UseMutationResult<AuthResponse, Error, RegisterRequest>;
+/**
+ * Login with email/phone and password
+ *
+ * @description
+ * Authenticates an existing user with their credentials.
+ * Returns authentication tokens and user information upon successful login.
+ *
+ * @endpoint POST /auth/login
+ *
+ * @example
+ * ```tsx
+ * import { useLogin } from '@growsober/sdk';
+ *
+ * function LoginForm() {
+ *   const { mutate: login, isPending, error } = useLogin({
+ *     onSuccess: (data) => {
+ *       // Store tokens securely
+ *       await SecureStore.setItemAsync('accessToken', data.accessToken);
+ *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);
+ *       navigation.navigate('Home');
+ *     },
+ *   });
+ *
+ *   const handleSubmit = () => {
+ *     login({
+ *       email: 'user@example.com',
+ *       password: 'SecurePassword123!',
+ *     });
+ *   };
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       <input type="email" name="email" />
+ *       <input type="password" name="password" />
+ *       <button type="submit" disabled={isPending}>
+ *         {isPending ? 'Logging in...' : 'Login'}
+ *       </button>
+ *       {error && <p className="error">{error.message}</p>}
+ *     </form>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Login with phone number:
+ * ```tsx
+ * login({
+ *   phone: '+1234567890',
+ *   password: 'SecurePassword123!',
+ * });
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useLogin(options?: Omit<UseMutationOptions<AuthResponse, Error, LoginRequest>, 'mutationFn'>): UseMutationResult<AuthResponse, Error, LoginRequest>;
+/**
+ * Refresh access token using refresh token
+ *
+ * @description
+ * Obtains a new access token using a valid refresh token.
+ * Should be called when the access token expires.
+ *
+ * @endpoint POST /auth/refresh
+ *
+ * @example
+ * ```tsx
+ * import { useRefreshAuthToken } from '@growsober/sdk';
+ *
+ * function useTokenRefresh() {
+ *   const { mutateAsync: refreshToken } = useRefreshAuthToken();
+ *
+ *   const handleTokenExpired = async () => {
+ *     const storedRefreshToken = await SecureStore.getItemAsync('refreshToken');
+ *
+ *     if (!storedRefreshToken) {
+ *       navigation.navigate('Login');
+ *       return;
+ *     }
+ *
+ *     try {
+ *       const { accessToken, refreshToken: newRefreshToken } = await refreshToken({
+ *         refreshToken: storedRefreshToken,
+ *       });
+ *
+ *       // Store new tokens
+ *       await SecureStore.setItemAsync('accessToken', accessToken);
+ *       await SecureStore.setItemAsync('refreshToken', newRefreshToken);
+ *     } catch (error) {
+ *       // Refresh token is invalid or expired
+ *       navigation.navigate('Login');
+ *     }
+ *   };
+ *
+ *   return { handleTokenExpired };
+ * }
+ * ```
+ *
+ * @example
+ * Integrate with SDK configuration:
+ * ```tsx
+ * import { configureSDK } from '@growsober/sdk';
+ *
+ * configureSDK({
+ *   baseURL: 'https://api.growsober.app',
+ *   getAccessToken: async () => {
+ *     return await SecureStore.getItemAsync('accessToken');
+ *   },
+ *   refreshAccessToken: async () => {
+ *     const refreshToken = await SecureStore.getItemAsync('refreshToken');
+ *     const { accessToken, refreshToken: newRefreshToken } = await fetch('/auth/refresh', {
+ *       method: 'POST',
+ *       body: JSON.stringify({ refreshToken }),
+ *     }).then(r => r.json());
+ *
+ *     await SecureStore.setItemAsync('accessToken', accessToken);
+ *     await SecureStore.setItemAsync('refreshToken', newRefreshToken);
+ *
+ *     return accessToken;
+ *   },
+ *   onUnauthorized: () => {
+ *     navigation.navigate('Login');
+ *   },
+ * });
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useRefreshAuthToken(options?: Omit<UseMutationOptions<TokenResponse, Error, RefreshTokenRequest>, 'mutationFn'>): UseMutationResult<TokenResponse, Error, RefreshTokenRequest>;
+/**
+ * Authenticate with Firebase ID token
+ *
+ * @description
+ * Authenticates a user using a Firebase ID token.
+ * Creates a new user account if one doesn't exist, or logs in an existing user.
+ * Returns GrowSober authentication tokens and user information.
+ *
+ * @endpoint POST /auth/firebase
+ *
+ * @example
+ * ```tsx
+ * import { useFirebaseAuth } from '@growsober/sdk';
+ * import { signInWithPhoneNumber } from 'firebase/auth';
+ *
+ * function PhoneAuthScreen() {
+ *   const { mutate: firebaseAuth, isPending } = useFirebaseAuth({
+ *     onSuccess: (data) => {
+ *       // Store GrowSober tokens
+ *       await SecureStore.setItemAsync('accessToken', data.accessToken);
+ *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);
+ *
+ *       if (data.user.onboardingCompleted) {
+ *         navigation.navigate('Home');
+ *       } else {
+ *         navigation.navigate('Onboarding');
+ *       }
+ *     },
+ *     onError: (error) => {
+ *       Alert.alert('Authentication failed', error.message);
+ *     },
+ *   });
+ *
+ *   const handlePhoneAuth = async (phoneNumber: string) => {
+ *     try {
+ *       // Firebase authentication flow
+ *       const confirmation = await signInWithPhoneNumber(auth, phoneNumber);
+ *       const code = await promptUserForCode(); // Your UI to get verification code
+ *       const credential = await confirmation.confirm(code);
+ *
+ *       // Get Firebase ID token
+ *       const idToken = await credential.user.getIdToken();
+ *
+ *       // Authenticate with GrowSober backend
+ *       firebaseAuth({ idToken });
+ *     } catch (error) {
+ *       console.error('Phone auth error:', error);
+ *     }
+ *   };
+ *
+ *   return <PhoneInput onSubmit={handlePhoneAuth} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @example
+ * With Google Sign-In:
+ * ```tsx
+ * import { GoogleSignin } from '@react-native-google-signin/google-signin';
+ *
+ * const handleGoogleSignIn = async () => {
+ *   const { idToken } = await GoogleSignin.signIn();
+ *   firebaseAuth({ idToken });
+ * };
+ * ```
+ *
+ * @example
+ * With Apple Sign-In:
+ * ```tsx
+ * import * as AppleAuthentication from 'expo-apple-authentication';
+ *
+ * const handleAppleSignIn = async () => {
+ *   const credential = await AppleAuthentication.signInAsync({
+ *     requestedScopes: [
+ *       AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
+ *       AppleAuthentication.AppleAuthenticationScope.EMAIL,
+ *     ],
+ *   });
+ *   firebaseAuth({ idToken: credential.identityToken });
+ * };
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useFirebaseAuth(options?: Omit<UseMutationOptions<AuthResponse, Error, FirebaseAuthRequest>, 'mutationFn'>): UseMutationResult<AuthResponse, Error, FirebaseAuthRequest>;