@growsober/sdk 1.0.1 → 1.0.2

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

@@ -7,7 +7,7 @@
  * @module api/mutations/auth
  */
 import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import type { RegisterRequest, LoginRequest, RefreshTokenRequest, FirebaseAuthRequest, AuthResponse, TokenResponse } from '../types';
+import type { RegisterRequest, LoginRequest, RefreshTokenRequest, FirebaseAuthRequest, AuthResponse, TokenResponse, SendOtpRequest, OtpSentResponse, VerifyOtpRequest } from '../types';
 /**
  * Register a new user account
  *
@@ -265,3 +265,85 @@ export declare function useRefreshAuthToken(options?: Omit<UseMutationOptions<To
  * @returns TanStack Query mutation result
  */
 export declare function useFirebaseAuth(options?: Omit<UseMutationOptions<AuthResponse, Error, FirebaseAuthRequest>, 'mutationFn'>): UseMutationResult<AuthResponse, Error, FirebaseAuthRequest>;
+/**
+ * Response type for verify OTP including isNewUser flag
+ */
+export type VerifyOtpResponse = AuthResponse & {
+    isNewUser: boolean;
+};
+/**
+ * Send OTP to phone number
+ *
+ * @description
+ * Sends a verification code to the specified phone number via SMS or voice call.
+ * Used for passwordless authentication.
+ *
+ * @endpoint POST /auth/phone/send-otp
+ *
+ * @example
+ * ```tsx
+ * import { useSendOtp } from '@growsober/sdk';
+ *
+ * function PhoneInputScreen() {
+ *   const { mutate: sendOtp, isPending, error } = useSendOtp({
+ *     onSuccess: (data) => {
+ *       console.log('OTP sent to:', data.phone);
+ *       navigation.navigate('VerifyOtp', { phone });
+ *     },
+ *     onError: (error) => {
+ *       Alert.alert('Error', error.message);
+ *     },
+ *   });
+ *
+ *   const handleSend = () => {
+ *     sendOtp({ phone: '+1234567890', channel: 'sms' });
+ *   };
+ *
+ *   return <Button onPress={handleSend} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useSendOtp(options?: Omit<UseMutationOptions<OtpSentResponse, Error, SendOtpRequest>, 'mutationFn'>): UseMutationResult<OtpSentResponse, Error, SendOtpRequest>;
+/**
+ * Verify OTP and authenticate
+ *
+ * @description
+ * Verifies the OTP code sent to the phone number and authenticates the user.
+ * If the user doesn't exist, a new account is created automatically.
+ * Returns authentication tokens and user information.
+ *
+ * @endpoint POST /auth/phone/verify-otp
+ *
+ * @example
+ * ```tsx
+ * import { useVerifyOtp } from '@growsober/sdk';
+ *
+ * function VerifyOtpScreen({ phone }) {
+ *   const { mutate: verifyOtp, isPending, error } = useVerifyOtp({
+ *     onSuccess: async (data) => {
+ *       await SecureStore.setItemAsync('accessToken', data.accessToken);
+ *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);
+ *
+ *       if (data.isNewUser) {
+ *         navigation.navigate('Onboarding');
+ *       } else {
+ *         navigation.navigate('Home');
+ *       }
+ *     },
+ *   });
+ *
+ *   const handleVerify = (code: string) => {
+ *     verifyOtp({ phone, code });
+ *   };
+ *
+ *   return <OtpInput onComplete={handleVerify} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useVerifyOtp(options?: Omit<UseMutationOptions<VerifyOtpResponse, Error, VerifyOtpRequest>, 'mutationFn'>): UseMutationResult<VerifyOtpResponse, Error, VerifyOtpRequest>;

package/dist/api/mutations/auth.js

@@ -12,6 +12,8 @@ exports.useRegister = useRegister;
 exports.useLogin = useLogin;
 exports.useRefreshAuthToken = useRefreshAuthToken;
 exports.useFirebaseAuth = useFirebaseAuth;
+exports.useSendOtp = useSendOtp;
+exports.useVerifyOtp = useVerifyOtp;
 const react_query_1 = require("@tanstack/react-query");
 const client_1 = require("../client");
 const users_1 = require("../queries/users");
@@ -329,4 +331,103 @@ function useFirebaseAuth(options) {
         ...options,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../src/api/mutations/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Auth Mutation Hooks\n *\n * TanStack Query mutation hooks for authentication-related write operations.\n * These hooks handle user registration, login, token refresh, and Firebase authentication.\n *\n * @module api/mutations/auth\n */\n\nimport { useMutation, UseMutationOptions, UseMutationResult, useQueryClient } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { userKeys } from '../queries/users';\nimport type {\n  RegisterRequest,\n  LoginRequest,\n  RefreshTokenRequest,\n  FirebaseAuthRequest,\n  AuthResponse,\n  TokenResponse,\n} from '../types';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Register a new user account\n *\n * @description\n * Creates a new user account with email/phone and password.\n * Returns authentication tokens and user information upon successful registration.\n *\n * @endpoint POST /auth/register\n *\n * @example\n * ```tsx\n * import { useRegister } from '@growsober/sdk';\n *\n * function RegisterForm() {\n *   const { mutate: register, isPending, error } = useRegister({\n *     onSuccess: (data) => {\n *       // Store tokens securely\n *       await SecureStore.setItemAsync('accessToken', data.accessToken);\n *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);\n *       navigation.navigate('Onboarding');\n *     },\n *     onError: (error) => {\n *       Alert.alert('Registration failed', error.message);\n *     },\n *   });\n *\n *   const handleSubmit = () => {\n *     register({\n *       email: 'user@example.com',\n *       password: 'SecurePassword123!',\n *       name: 'John Doe',\n *     });\n *   };\n *\n *   return <Button onPress={handleSubmit} disabled={isPending} />;\n * }\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useRegister(\n  options?: Omit<UseMutationOptions<AuthResponse, Error, RegisterRequest>, 'mutationFn'>\n): UseMutationResult<AuthResponse, Error, RegisterRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: RegisterRequest): Promise<AuthResponse> => {\n      const client = getApiClient();\n      const response = await client.post<AuthResponse>('/auth/register', data);\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate current user query to trigger refetch with new token\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Login with email/phone and password\n *\n * @description\n * Authenticates an existing user with their credentials.\n * Returns authentication tokens and user information upon successful login.\n *\n * @endpoint POST /auth/login\n *\n * @example\n * ```tsx\n * import { useLogin } from '@growsober/sdk';\n *\n * function LoginForm() {\n *   const { mutate: login, isPending, error } = useLogin({\n *     onSuccess: (data) => {\n *       // Store tokens securely\n *       await SecureStore.setItemAsync('accessToken', data.accessToken);\n *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);\n *       navigation.navigate('Home');\n *     },\n *   });\n *\n *   const handleSubmit = () => {\n *     login({\n *       email: 'user@example.com',\n *       password: 'SecurePassword123!',\n *     });\n *   };\n *\n *   return (\n *     <form onSubmit={handleSubmit}>\n *       <input type=\"email\" name=\"email\" />\n *       <input type=\"password\" name=\"password\" />\n *       <button type=\"submit\" disabled={isPending}>\n *         {isPending ? 'Logging in...' : 'Login'}\n *       </button>\n *       {error && <p className=\"error\">{error.message}</p>}\n *     </form>\n *   );\n * }\n * ```\n *\n * @example\n * Login with phone number:\n * ```tsx\n * login({\n *   phone: '+1234567890',\n *   password: 'SecurePassword123!',\n * });\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useLogin(\n  options?: Omit<UseMutationOptions<AuthResponse, Error, LoginRequest>, 'mutationFn'>\n): UseMutationResult<AuthResponse, Error, LoginRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: LoginRequest): Promise<AuthResponse> => {\n      const client = getApiClient();\n      const response = await client.post<AuthResponse>('/auth/login', data);\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate current user query to trigger refetch with new token\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Refresh access token using refresh token\n *\n * @description\n * Obtains a new access token using a valid refresh token.\n * Should be called when the access token expires.\n *\n * @endpoint POST /auth/refresh\n *\n * @example\n * ```tsx\n * import { useRefreshAuthToken } from '@growsober/sdk';\n *\n * function useTokenRefresh() {\n *   const { mutateAsync: refreshToken } = useRefreshAuthToken();\n *\n *   const handleTokenExpired = async () => {\n *     const storedRefreshToken = await SecureStore.getItemAsync('refreshToken');\n *\n *     if (!storedRefreshToken) {\n *       navigation.navigate('Login');\n *       return;\n *     }\n *\n *     try {\n *       const { accessToken, refreshToken: newRefreshToken } = await refreshToken({\n *         refreshToken: storedRefreshToken,\n *       });\n *\n *       // Store new tokens\n *       await SecureStore.setItemAsync('accessToken', accessToken);\n *       await SecureStore.setItemAsync('refreshToken', newRefreshToken);\n *     } catch (error) {\n *       // Refresh token is invalid or expired\n *       navigation.navigate('Login');\n *     }\n *   };\n *\n *   return { handleTokenExpired };\n * }\n * ```\n *\n * @example\n * Integrate with SDK configuration:\n * ```tsx\n * import { configureSDK } from '@growsober/sdk';\n *\n * configureSDK({\n *   baseURL: 'https://api.growsober.app',\n *   getAccessToken: async () => {\n *     return await SecureStore.getItemAsync('accessToken');\n *   },\n *   refreshAccessToken: async () => {\n *     const refreshToken = await SecureStore.getItemAsync('refreshToken');\n *     const { accessToken, refreshToken: newRefreshToken } = await fetch('/auth/refresh', {\n *       method: 'POST',\n *       body: JSON.stringify({ refreshToken }),\n *     }).then(r => r.json());\n *\n *     await SecureStore.setItemAsync('accessToken', accessToken);\n *     await SecureStore.setItemAsync('refreshToken', newRefreshToken);\n *\n *     return accessToken;\n *   },\n *   onUnauthorized: () => {\n *     navigation.navigate('Login');\n *   },\n * });\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useRefreshAuthToken(\n  options?: Omit<UseMutationOptions<TokenResponse, Error, RefreshTokenRequest>, 'mutationFn'>\n): UseMutationResult<TokenResponse, Error, RefreshTokenRequest> {\n  return useMutation({\n    mutationFn: async (data: RefreshTokenRequest): Promise<TokenResponse> => {\n      const client = getApiClient();\n      const response = await client.post<TokenResponse>('/auth/refresh', data);\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Authenticate with Firebase ID token\n *\n * @description\n * Authenticates a user using a Firebase ID token.\n * Creates a new user account if one doesn't exist, or logs in an existing user.\n * Returns GrowSober authentication tokens and user information.\n *\n * @endpoint POST /auth/firebase\n *\n * @example\n * ```tsx\n * import { useFirebaseAuth } from '@growsober/sdk';\n * import { signInWithPhoneNumber } from 'firebase/auth';\n *\n * function PhoneAuthScreen() {\n *   const { mutate: firebaseAuth, isPending } = useFirebaseAuth({\n *     onSuccess: (data) => {\n *       // Store GrowSober tokens\n *       await SecureStore.setItemAsync('accessToken', data.accessToken);\n *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);\n *\n *       if (data.user.onboardingCompleted) {\n *         navigation.navigate('Home');\n *       } else {\n *         navigation.navigate('Onboarding');\n *       }\n *     },\n *     onError: (error) => {\n *       Alert.alert('Authentication failed', error.message);\n *     },\n *   });\n *\n *   const handlePhoneAuth = async (phoneNumber: string) => {\n *     try {\n *       // Firebase authentication flow\n *       const confirmation = await signInWithPhoneNumber(auth, phoneNumber);\n *       const code = await promptUserForCode(); // Your UI to get verification code\n *       const credential = await confirmation.confirm(code);\n *\n *       // Get Firebase ID token\n *       const idToken = await credential.user.getIdToken();\n *\n *       // Authenticate with GrowSober backend\n *       firebaseAuth({ idToken });\n *     } catch (error) {\n *       console.error('Phone auth error:', error);\n *     }\n *   };\n *\n *   return <PhoneInput onSubmit={handlePhoneAuth} disabled={isPending} />;\n * }\n * ```\n *\n * @example\n * With Google Sign-In:\n * ```tsx\n * import { GoogleSignin } from '@react-native-google-signin/google-signin';\n *\n * const handleGoogleSignIn = async () => {\n *   const { idToken } = await GoogleSignin.signIn();\n *   firebaseAuth({ idToken });\n * };\n * ```\n *\n * @example\n * With Apple Sign-In:\n * ```tsx\n * import * as AppleAuthentication from 'expo-apple-authentication';\n *\n * const handleAppleSignIn = async () => {\n *   const credential = await AppleAuthentication.signInAsync({\n *     requestedScopes: [\n *       AppleAuthentication.AppleAuthenticationScope.FULL_NAME,\n *       AppleAuthentication.AppleAuthenticationScope.EMAIL,\n *     ],\n *   });\n *   firebaseAuth({ idToken: credential.identityToken });\n * };\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useFirebaseAuth(\n  options?: Omit<UseMutationOptions<AuthResponse, Error, FirebaseAuthRequest>, 'mutationFn'>\n): UseMutationResult<AuthResponse, Error, FirebaseAuthRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: FirebaseAuthRequest): Promise<AuthResponse> => {\n      const client = getApiClient();\n      const response = await client.post<AuthResponse>('/auth/firebase', data);\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate current user query to trigger refetch with new token\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n"]}
+/**
+ * Send OTP to phone number
+ *
+ * @description
+ * Sends a verification code to the specified phone number via SMS or voice call.
+ * Used for passwordless authentication.
+ *
+ * @endpoint POST /auth/phone/send-otp
+ *
+ * @example
+ * ```tsx
+ * import { useSendOtp } from '@growsober/sdk';
+ *
+ * function PhoneInputScreen() {
+ *   const { mutate: sendOtp, isPending, error } = useSendOtp({
+ *     onSuccess: (data) => {
+ *       console.log('OTP sent to:', data.phone);
+ *       navigation.navigate('VerifyOtp', { phone });
+ *     },
+ *     onError: (error) => {
+ *       Alert.alert('Error', error.message);
+ *     },
+ *   });
+ *
+ *   const handleSend = () => {
+ *     sendOtp({ phone: '+1234567890', channel: 'sms' });
+ *   };
+ *
+ *   return <Button onPress={handleSend} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+function useSendOtp(options) {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/auth/phone/send-otp', data);
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Verify OTP and authenticate
+ *
+ * @description
+ * Verifies the OTP code sent to the phone number and authenticates the user.
+ * If the user doesn't exist, a new account is created automatically.
+ * Returns authentication tokens and user information.
+ *
+ * @endpoint POST /auth/phone/verify-otp
+ *
+ * @example
+ * ```tsx
+ * import { useVerifyOtp } from '@growsober/sdk';
+ *
+ * function VerifyOtpScreen({ phone }) {
+ *   const { mutate: verifyOtp, isPending, error } = useVerifyOtp({
+ *     onSuccess: async (data) => {
+ *       await SecureStore.setItemAsync('accessToken', data.accessToken);
+ *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);
+ *
+ *       if (data.isNewUser) {
+ *         navigation.navigate('Onboarding');
+ *       } else {
+ *         navigation.navigate('Home');
+ *       }
+ *     },
+ *   });
+ *
+ *   const handleVerify = (code: string) => {
+ *     verifyOtp({ phone, code });
+ *   };
+ *
+ *   return <OtpInput onComplete={handleVerify} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+function useVerifyOtp(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('/auth/phone/verify-otp', data);
+            return response.data;
+        },
+        onSuccess: (data, variables, context) => {
+            // Invalidate current user query to trigger refetch with new token
+            queryClient.invalidateQueries({ queryKey: users_1.userKeys.me() });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../src/api/mutations/auth.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Auth Mutation Hooks\n *\n * TanStack Query mutation hooks for authentication-related write operations.\n * These hooks handle user registration, login, token refresh, and Firebase authentication.\n *\n * @module api/mutations/auth\n */\n\nimport { useMutation, UseMutationOptions, UseMutationResult, useQueryClient } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { userKeys } from '../queries/users';\nimport type {\n  RegisterRequest,\n  LoginRequest,\n  RefreshTokenRequest,\n  FirebaseAuthRequest,\n  AuthResponse,\n  TokenResponse,\n  SendOtpRequest,\n  OtpSentResponse,\n  VerifyOtpRequest,\n} from '../types';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Register a new user account\n *\n * @description\n * Creates a new user account with email/phone and password.\n * Returns authentication tokens and user information upon successful registration.\n *\n * @endpoint POST /auth/register\n *\n * @example\n * ```tsx\n * import { useRegister } from '@growsober/sdk';\n *\n * function RegisterForm() {\n *   const { mutate: register, isPending, error } = useRegister({\n *     onSuccess: (data) => {\n *       // Store tokens securely\n *       await SecureStore.setItemAsync('accessToken', data.accessToken);\n *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);\n *       navigation.navigate('Onboarding');\n *     },\n *     onError: (error) => {\n *       Alert.alert('Registration failed', error.message);\n *     },\n *   });\n *\n *   const handleSubmit = () => {\n *     register({\n *       email: 'user@example.com',\n *       password: 'SecurePassword123!',\n *       name: 'John Doe',\n *     });\n *   };\n *\n *   return <Button onPress={handleSubmit} disabled={isPending} />;\n * }\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useRegister(\n  options?: Omit<UseMutationOptions<AuthResponse, Error, RegisterRequest>, 'mutationFn'>\n): UseMutationResult<AuthResponse, Error, RegisterRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: RegisterRequest): Promise<AuthResponse> => {\n      const client = getApiClient();\n      const response = await client.post<AuthResponse>('/auth/register', data);\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate current user query to trigger refetch with new token\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Login with email/phone and password\n *\n * @description\n * Authenticates an existing user with their credentials.\n * Returns authentication tokens and user information upon successful login.\n *\n * @endpoint POST /auth/login\n *\n * @example\n * ```tsx\n * import { useLogin } from '@growsober/sdk';\n *\n * function LoginForm() {\n *   const { mutate: login, isPending, error } = useLogin({\n *     onSuccess: (data) => {\n *       // Store tokens securely\n *       await SecureStore.setItemAsync('accessToken', data.accessToken);\n *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);\n *       navigation.navigate('Home');\n *     },\n *   });\n *\n *   const handleSubmit = () => {\n *     login({\n *       email: 'user@example.com',\n *       password: 'SecurePassword123!',\n *     });\n *   };\n *\n *   return (\n *     <form onSubmit={handleSubmit}>\n *       <input type=\"email\" name=\"email\" />\n *       <input type=\"password\" name=\"password\" />\n *       <button type=\"submit\" disabled={isPending}>\n *         {isPending ? 'Logging in...' : 'Login'}\n *       </button>\n *       {error && <p className=\"error\">{error.message}</p>}\n *     </form>\n *   );\n * }\n * ```\n *\n * @example\n * Login with phone number:\n * ```tsx\n * login({\n *   phone: '+1234567890',\n *   password: 'SecurePassword123!',\n * });\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useLogin(\n  options?: Omit<UseMutationOptions<AuthResponse, Error, LoginRequest>, 'mutationFn'>\n): UseMutationResult<AuthResponse, Error, LoginRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: LoginRequest): Promise<AuthResponse> => {\n      const client = getApiClient();\n      const response = await client.post<AuthResponse>('/auth/login', data);\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate current user query to trigger refetch with new token\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Refresh access token using refresh token\n *\n * @description\n * Obtains a new access token using a valid refresh token.\n * Should be called when the access token expires.\n *\n * @endpoint POST /auth/refresh\n *\n * @example\n * ```tsx\n * import { useRefreshAuthToken } from '@growsober/sdk';\n *\n * function useTokenRefresh() {\n *   const { mutateAsync: refreshToken } = useRefreshAuthToken();\n *\n *   const handleTokenExpired = async () => {\n *     const storedRefreshToken = await SecureStore.getItemAsync('refreshToken');\n *\n *     if (!storedRefreshToken) {\n *       navigation.navigate('Login');\n *       return;\n *     }\n *\n *     try {\n *       const { accessToken, refreshToken: newRefreshToken } = await refreshToken({\n *         refreshToken: storedRefreshToken,\n *       });\n *\n *       // Store new tokens\n *       await SecureStore.setItemAsync('accessToken', accessToken);\n *       await SecureStore.setItemAsync('refreshToken', newRefreshToken);\n *     } catch (error) {\n *       // Refresh token is invalid or expired\n *       navigation.navigate('Login');\n *     }\n *   };\n *\n *   return { handleTokenExpired };\n * }\n * ```\n *\n * @example\n * Integrate with SDK configuration:\n * ```tsx\n * import { configureSDK } from '@growsober/sdk';\n *\n * configureSDK({\n *   baseURL: 'https://api.growsober.app',\n *   getAccessToken: async () => {\n *     return await SecureStore.getItemAsync('accessToken');\n *   },\n *   refreshAccessToken: async () => {\n *     const refreshToken = await SecureStore.getItemAsync('refreshToken');\n *     const { accessToken, refreshToken: newRefreshToken } = await fetch('/auth/refresh', {\n *       method: 'POST',\n *       body: JSON.stringify({ refreshToken }),\n *     }).then(r => r.json());\n *\n *     await SecureStore.setItemAsync('accessToken', accessToken);\n *     await SecureStore.setItemAsync('refreshToken', newRefreshToken);\n *\n *     return accessToken;\n *   },\n *   onUnauthorized: () => {\n *     navigation.navigate('Login');\n *   },\n * });\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useRefreshAuthToken(\n  options?: Omit<UseMutationOptions<TokenResponse, Error, RefreshTokenRequest>, 'mutationFn'>\n): UseMutationResult<TokenResponse, Error, RefreshTokenRequest> {\n  return useMutation({\n    mutationFn: async (data: RefreshTokenRequest): Promise<TokenResponse> => {\n      const client = getApiClient();\n      const response = await client.post<TokenResponse>('/auth/refresh', data);\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Authenticate with Firebase ID token\n *\n * @description\n * Authenticates a user using a Firebase ID token.\n * Creates a new user account if one doesn't exist, or logs in an existing user.\n * Returns GrowSober authentication tokens and user information.\n *\n * @endpoint POST /auth/firebase\n *\n * @example\n * ```tsx\n * import { useFirebaseAuth } from '@growsober/sdk';\n * import { signInWithPhoneNumber } from 'firebase/auth';\n *\n * function PhoneAuthScreen() {\n *   const { mutate: firebaseAuth, isPending } = useFirebaseAuth({\n *     onSuccess: (data) => {\n *       // Store GrowSober tokens\n *       await SecureStore.setItemAsync('accessToken', data.accessToken);\n *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);\n *\n *       if (data.user.onboardingCompleted) {\n *         navigation.navigate('Home');\n *       } else {\n *         navigation.navigate('Onboarding');\n *       }\n *     },\n *     onError: (error) => {\n *       Alert.alert('Authentication failed', error.message);\n *     },\n *   });\n *\n *   const handlePhoneAuth = async (phoneNumber: string) => {\n *     try {\n *       // Firebase authentication flow\n *       const confirmation = await signInWithPhoneNumber(auth, phoneNumber);\n *       const code = await promptUserForCode(); // Your UI to get verification code\n *       const credential = await confirmation.confirm(code);\n *\n *       // Get Firebase ID token\n *       const idToken = await credential.user.getIdToken();\n *\n *       // Authenticate with GrowSober backend\n *       firebaseAuth({ idToken });\n *     } catch (error) {\n *       console.error('Phone auth error:', error);\n *     }\n *   };\n *\n *   return <PhoneInput onSubmit={handlePhoneAuth} disabled={isPending} />;\n * }\n * ```\n *\n * @example\n * With Google Sign-In:\n * ```tsx\n * import { GoogleSignin } from '@react-native-google-signin/google-signin';\n *\n * const handleGoogleSignIn = async () => {\n *   const { idToken } = await GoogleSignin.signIn();\n *   firebaseAuth({ idToken });\n * };\n * ```\n *\n * @example\n * With Apple Sign-In:\n * ```tsx\n * import * as AppleAuthentication from 'expo-apple-authentication';\n *\n * const handleAppleSignIn = async () => {\n *   const credential = await AppleAuthentication.signInAsync({\n *     requestedScopes: [\n *       AppleAuthentication.AppleAuthenticationScope.FULL_NAME,\n *       AppleAuthentication.AppleAuthenticationScope.EMAIL,\n *     ],\n *   });\n *   firebaseAuth({ idToken: credential.identityToken });\n * };\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useFirebaseAuth(\n  options?: Omit<UseMutationOptions<AuthResponse, Error, FirebaseAuthRequest>, 'mutationFn'>\n): UseMutationResult<AuthResponse, Error, FirebaseAuthRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: FirebaseAuthRequest): Promise<AuthResponse> => {\n      const client = getApiClient();\n      const response = await client.post<AuthResponse>('/auth/firebase', data);\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate current user query to trigger refetch with new token\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Response type for verify OTP including isNewUser flag\n */\nexport type VerifyOtpResponse = AuthResponse & { isNewUser: boolean };\n\n/**\n * Send OTP to phone number\n *\n * @description\n * Sends a verification code to the specified phone number via SMS or voice call.\n * Used for passwordless authentication.\n *\n * @endpoint POST /auth/phone/send-otp\n *\n * @example\n * ```tsx\n * import { useSendOtp } from '@growsober/sdk';\n *\n * function PhoneInputScreen() {\n *   const { mutate: sendOtp, isPending, error } = useSendOtp({\n *     onSuccess: (data) => {\n *       console.log('OTP sent to:', data.phone);\n *       navigation.navigate('VerifyOtp', { phone });\n *     },\n *     onError: (error) => {\n *       Alert.alert('Error', error.message);\n *     },\n *   });\n *\n *   const handleSend = () => {\n *     sendOtp({ phone: '+1234567890', channel: 'sms' });\n *   };\n *\n *   return <Button onPress={handleSend} disabled={isPending} />;\n * }\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useSendOtp(\n  options?: Omit<UseMutationOptions<OtpSentResponse, Error, SendOtpRequest>, 'mutationFn'>\n): UseMutationResult<OtpSentResponse, Error, SendOtpRequest> {\n  return useMutation({\n    mutationFn: async (data: SendOtpRequest): Promise<OtpSentResponse> => {\n      const client = getApiClient();\n      const response = await client.post<OtpSentResponse>('/auth/phone/send-otp', data);\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Verify OTP and authenticate\n *\n * @description\n * Verifies the OTP code sent to the phone number and authenticates the user.\n * If the user doesn't exist, a new account is created automatically.\n * Returns authentication tokens and user information.\n *\n * @endpoint POST /auth/phone/verify-otp\n *\n * @example\n * ```tsx\n * import { useVerifyOtp } from '@growsober/sdk';\n *\n * function VerifyOtpScreen({ phone }) {\n *   const { mutate: verifyOtp, isPending, error } = useVerifyOtp({\n *     onSuccess: async (data) => {\n *       await SecureStore.setItemAsync('accessToken', data.accessToken);\n *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);\n *\n *       if (data.isNewUser) {\n *         navigation.navigate('Onboarding');\n *       } else {\n *         navigation.navigate('Home');\n *       }\n *     },\n *   });\n *\n *   const handleVerify = (code: string) => {\n *     verifyOtp({ phone, code });\n *   };\n *\n *   return <OtpInput onComplete={handleVerify} disabled={isPending} />;\n * }\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useVerifyOtp(\n  options?: Omit<UseMutationOptions<VerifyOtpResponse, Error, VerifyOtpRequest>, 'mutationFn'>\n): UseMutationResult<VerifyOtpResponse, Error, VerifyOtpRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: VerifyOtpRequest): Promise<VerifyOtpResponse> => {\n      const client = getApiClient();\n      const response = await client.post<VerifyOtpResponse>('/auth/phone/verify-otp', data);\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate current user query to trigger refetch with new token\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n    },\n    ...options,\n  });\n}\n"]}

package/dist/api/queries/cities.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Cities Query Hooks
+ *
+ * TanStack Query hooks for fetching city data.
+ * Cities are used for location-based features and user onboarding.
+ *
+ * @module api/queries/cities
+ */
+import { UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+export declare const cityKeys: {
+    all: readonly ["cities"];
+    lists: () => readonly ["cities", "list"];
+    list: (filters?: CityFilters) => readonly ["cities", "list", CityFilters | undefined];
+    details: () => readonly ["cities", "detail"];
+    detail: (id: string) => readonly ["cities", "detail", string];
+    featured: () => readonly ["cities", "featured"];
+};
+export interface CityResponse {
+    id: string;
+    name: string;
+    country: string;
+    countryCode: string | null;
+    timezone: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    memberCount: number;
+    isFeatured: boolean;
+    region: string | null;
+}
+export interface CityFilters {
+    search?: string;
+    countryCode?: string;
+    isFeatured?: boolean;
+}
+export declare function useCities(filters?: CityFilters, options?: Omit<UseQueryOptions<CityResponse[]>, 'queryKey' | 'queryFn'>): UseQueryResult<CityResponse[]>;
+/**
+ * Get featured cities
+ *
+ * @description
+ * Fetches only cities marked as featured.
+ * Useful for showing popular/recommended cities.
+ *
+ * @example
+ * ```tsx
+ * const { data: featuredCities } = useFeaturedCities();
+ * ```
+ *
+ * @param options - TanStack Query options
+ * @returns TanStack Query result with array of featured cities
+ */
+export declare function useFeaturedCities(options?: Omit<UseQueryOptions<CityResponse[]>, 'queryKey' | 'queryFn'>): UseQueryResult<CityResponse[]>;
+export declare function useCity(id: string, options?: Omit<UseQueryOptions<CityResponse>, 'queryKey' | 'queryFn'>): UseQueryResult<CityResponse>;

package/dist/api/queries/cities.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Cities Query Hooks
+ *
+ * TanStack Query hooks for fetching city data.
+ * Cities are used for location-based features and user onboarding.
+ *
+ * @module api/queries/cities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cityKeys = void 0;
+exports.useCities = useCities;
+exports.useFeaturedCities = useFeaturedCities;
+exports.useCity = useCity;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+// ============================================================================
+// QUERY KEY FACTORY
+// ============================================================================
+exports.cityKeys = {
+    all: ['cities'],
+    lists: () => [...exports.cityKeys.all, 'list'],
+    list: (filters) => [...exports.cityKeys.lists(), filters],
+    details: () => [...exports.cityKeys.all, 'detail'],
+    detail: (id) => [...exports.cityKeys.details(), id],
+    featured: () => [...exports.cityKeys.all, 'featured'],
+};
+function useCities(filters, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.cityKeys.list(filters),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const params = new URLSearchParams();
+            if (filters?.search)
+                params.append('search', filters.search);
+            if (filters?.countryCode)
+                params.append('countryCode', filters.countryCode);
+            if (filters?.isFeatured !== undefined)
+                params.append('isFeatured', String(filters.isFeatured));
+            const queryString = params.toString();
+            const url = `/api/v1/cities${queryString ? `?${queryString}` : ''}`;
+            const response = await client.get(url);
+            // Handle both wrapped and unwrapped response formats
+            return Array.isArray(response.data) ? response.data : response.data.data;
+        },
+        staleTime: 5 * 60 * 1000, // Cities don't change often, cache for 5 minutes
+        ...options,
+    });
+}
+/**
+ * Get featured cities
+ *
+ * @description
+ * Fetches only cities marked as featured.
+ * Useful for showing popular/recommended cities.
+ *
+ * @example
+ * ```tsx
+ * const { data: featuredCities } = useFeaturedCities();
+ * ```
+ *
+ * @param options - TanStack Query options
+ * @returns TanStack Query result with array of featured cities
+ */
+function useFeaturedCities(options) {
+    return useCities({ isFeatured: true }, options);
+}
+function useCity(id, options) {
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.cityKeys.detail(id),
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get(`/api/v1/cities/${id}`);
+            // Handle both wrapped and unwrapped response formats
+            return response.data.data || response.data;
+        },
+        enabled: !!id,
+        staleTime: 5 * 60 * 1000,
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cities.js","sourceRoot":"","sources":["../../../src/api/queries/cities.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAmGH,8BAwBC;AAiBD,8CAIC;AA0BD,0BAgBC;AAxLD,uDAAkF;AAClF,sCAAyC;AAEzC,+EAA+E;AAC/E,oBAAoB;AACpB,+EAA+E;AAElE,QAAA,QAAQ,GAAG;IACtB,GAAG,EAAE,CAAC,QAAQ,CAAU;IACxB,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,gBAAQ,CAAC,GAAG,EAAE,MAAM,CAAU;IAC/C,IAAI,EAAE,CAAC,OAAqB,EAAE,EAAE,CAAC,CAAC,GAAG,gBAAQ,CAAC,KAAK,EAAE,EAAE,OAAO,CAAU;IACxE,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,gBAAQ,CAAC,GAAG,EAAE,QAAQ,CAAU;IACnD,MAAM,EAAE,CAAC,EAAU,EAAE,EAAE,CAAC,CAAC,GAAG,gBAAQ,CAAC,OAAO,EAAE,EAAE,EAAE,CAAU;IAC5D,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,gBAAQ,CAAC,GAAG,EAAE,UAAU,CAAU;CACvD,CAAC;AAmFF,SAAgB,SAAS,CACvB,OAAqB,EACrB,OAAuE;IAEvE,OAAO,IAAA,sBAAQ,EAAC;QACd,QAAQ,EAAE,gBAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;QAChC,OAAO,EAAE,KAAK,IAA6B,EAAE;YAC3C,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;YAErC,IAAI,OAAO,EAAE,MAAM;gBAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;YAC7D,IAAI,OAAO,EAAE,WAAW;gBAAE,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;YAC5E,IAAI,OAAO,EAAE,UAAU,KAAK,SAAS;gBAAE,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;YAE/F,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;YACtC,MAAM,GAAG,GAAG,iBAAiB,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;YAEpE,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAAoB,GAAG,CAAC,CAAC;YAC1D,qDAAqD;YACrD,OAAO,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;QAC3E,CAAC;QACD,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,EAAE,iDAAiD;QAC3E,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,iBAAiB,CAC/B,OAAuE;IAEvE,OAAO,SAAS,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,OAAO,CAAC,CAAC;AAClD,CAAC;AA0BD,SAAgB,OAAO,CACrB,EAAU,EACV,OAAqE;IAErE,OAAO,IAAA,sBAAQ,EAAC;QACd,QAAQ,EAAE,gBAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,OAAO,EAAE,KAAK,IAA2B,EAAE;YACzC,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAAkB,kBAAkB,EAAE,EAAE,CAAC,CAAC;YAC3E,qDAAqD;YACrD,OAAQ,QAAQ,CAAC,IAAY,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC;QACtD,CAAC;QACD,OAAO,EAAE,CAAC,CAAC,EAAE;QACb,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI;QACxB,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Cities Query Hooks\n *\n * TanStack Query hooks for fetching city data.\n * Cities are used for location-based features and user onboarding.\n *\n * @module api/queries/cities\n */\n\nimport { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\n\n// ============================================================================\n// QUERY KEY FACTORY\n// ============================================================================\n\nexport const cityKeys = {\n  all: ['cities'] as const,\n  lists: () => [...cityKeys.all, 'list'] as const,\n  list: (filters?: CityFilters) => [...cityKeys.lists(), filters] as const,\n  details: () => [...cityKeys.all, 'detail'] as const,\n  detail: (id: string) => [...cityKeys.details(), id] as const,\n  featured: () => [...cityKeys.all, 'featured'] as const,\n};\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport interface CityResponse {\n  id: string;\n  name: string;\n  country: string;\n  countryCode: string | null;\n  timezone: string | null;\n  latitude: number | null;\n  longitude: number | null;\n  memberCount: number;\n  isFeatured: boolean;\n  region: string | null;\n}\n\nexport interface CityFilters {\n  search?: string;\n  countryCode?: string;\n  isFeatured?: boolean;\n}\n\n// ============================================================================\n// QUERY HOOKS\n// ============================================================================\n\n/**\n * Get list of cities with optional filters\n *\n * @description\n * Fetches available cities for location selection.\n * Can be filtered by name search, country code, or featured status.\n * Results are ordered by featured status, member count, and name.\n *\n * @endpoint GET /api/v1/cities\n *\n * @example\n * ```tsx\n * import { useCities } from '@growsober/sdk';\n *\n * function CityPicker() {\n *   const { data: cities, isLoading } = useCities();\n *\n *   if (isLoading) return <Spinner />;\n *\n *   return (\n *     <select>\n *       {cities?.map(city => (\n *         <option key={city.id} value={city.id}>\n *           {city.name}, {city.country}\n *         </option>\n *       ))}\n *     </select>\n *   );\n * }\n * ```\n *\n * @example\n * With search filter:\n * ```tsx\n * const { data: cities } = useCities({ search: 'London' });\n * ```\n *\n * @example\n * Filter by country:\n * ```tsx\n * const { data: ukCities } = useCities({ countryCode: 'GB' });\n * ```\n *\n * @param filters - Optional filters for city search\n * @param options - TanStack Query options\n * @returns TanStack Query result with array of cities\n */\ninterface CitiesApiResponse {\n  data: CityResponse[];\n  meta: {\n    timestamp: string;\n  };\n}\n\nexport function useCities(\n  filters?: CityFilters,\n  options?: Omit<UseQueryOptions<CityResponse[]>, 'queryKey' | 'queryFn'>\n): UseQueryResult<CityResponse[]> {\n  return useQuery({\n    queryKey: cityKeys.list(filters),\n    queryFn: async (): Promise<CityResponse[]> => {\n      const client = getApiClient();\n      const params = new URLSearchParams();\n\n      if (filters?.search) params.append('search', filters.search);\n      if (filters?.countryCode) params.append('countryCode', filters.countryCode);\n      if (filters?.isFeatured !== undefined) params.append('isFeatured', String(filters.isFeatured));\n\n      const queryString = params.toString();\n      const url = `/api/v1/cities${queryString ? `?${queryString}` : ''}`;\n\n      const response = await client.get<CitiesApiResponse>(url);\n      // Handle both wrapped and unwrapped response formats\n      return Array.isArray(response.data) ? response.data : response.data.data;\n    },\n    staleTime: 5 * 60 * 1000, // Cities don't change often, cache for 5 minutes\n    ...options,\n  });\n}\n\n/**\n * Get featured cities\n *\n * @description\n * Fetches only cities marked as featured.\n * Useful for showing popular/recommended cities.\n *\n * @example\n * ```tsx\n * const { data: featuredCities } = useFeaturedCities();\n * ```\n *\n * @param options - TanStack Query options\n * @returns TanStack Query result with array of featured cities\n */\nexport function useFeaturedCities(\n  options?: Omit<UseQueryOptions<CityResponse[]>, 'queryKey' | 'queryFn'>\n): UseQueryResult<CityResponse[]> {\n  return useCities({ isFeatured: true }, options);\n}\n\n/**\n * Get a single city by ID\n *\n * @description\n * Fetches details for a specific city.\n *\n * @endpoint GET /api/v1/cities/{id}\n *\n * @example\n * ```tsx\n * const { data: city } = useCity('city-uuid');\n * ```\n *\n * @param id - City ID\n * @param options - TanStack Query options\n * @returns TanStack Query result with city data\n */\ninterface CityApiResponse {\n  data: CityResponse;\n  meta: {\n    timestamp: string;\n  };\n}\n\nexport function useCity(\n  id: string,\n  options?: Omit<UseQueryOptions<CityResponse>, 'queryKey' | 'queryFn'>\n): UseQueryResult<CityResponse> {\n  return useQuery({\n    queryKey: cityKeys.detail(id),\n    queryFn: async (): Promise<CityResponse> => {\n      const client = getApiClient();\n      const response = await client.get<CityApiResponse>(`/api/v1/cities/${id}`);\n      // Handle both wrapped and unwrapped response formats\n      return (response.data as any).data || response.data;\n    },\n    enabled: !!id,\n    staleTime: 5 * 60 * 1000,\n    ...options,\n  });\n}\n"]}

package/dist/api/queries/index.d.ts

@@ -7,6 +7,7 @@ export * from './admin';
 export * from './auth';
 export * from './bookings';
 export * from './businesses';
+export * from './cities';
 export * from './events';
 export * from './hubs';
 export * from './library';

package/dist/api/queries/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./admin"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./bookings"), exports);
 __exportStar(require("./businesses"), exports);
+__exportStar(require("./cities"), exports);
 __exportStar(require("./events"), exports);
 __exportStar(require("./hubs"), exports);
 __exportStar(require("./library"), exports);
@@ -37,4 +38,4 @@ __exportStar(require("./ambassadors"), exports);
 __exportStar(require("./grow90"), exports);
 __exportStar(require("./matching"), exports);
 __exportStar(require("./event-chat"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL3F1ZXJpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCwwQ0FBd0I7QUFDeEIseUNBQXVCO0FBQ3ZCLDZDQUEyQjtBQUMzQiwrQ0FBNkI7QUFDN0IsMkNBQXlCO0FBQ3pCLHlDQUF1QjtBQUN2Qiw0Q0FBMEI7QUFDMUIsd0NBQXNCO0FBQ3RCLGtEQUFnQztBQUNoQywyQ0FBeUI7QUFDekIsa0RBQWdDO0FBQ2hDLDRDQUEwQjtBQUMxQiwwQ0FBd0I7QUFDeEIseUNBQXVCO0FBQ3ZCLGdEQUE4QjtBQUM5QiwyQ0FBeUI7QUFDekIsNkNBQTJCO0FBQzNCLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUXVlcnkgSG9va3NcbiAqXG4gKiBSZS1leHBvcnRzIGFsbCBxdWVyeSBob29rcyBmb3IgQVBJIGVuZHBvaW50cy5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2FkbWluJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aCc7XG5leHBvcnQgKiBmcm9tICcuL2Jvb2tpbmdzJztcbmV4cG9ydCAqIGZyb20gJy4vYnVzaW5lc3Nlcyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2h1YnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWJyYXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vbWFwJztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL29mZmVycyc7XG5leHBvcnQgKiBmcm9tICcuL3N1YnNjcmlwdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdXBwb3J0JztcbmV4cG9ydCAqIGZyb20gJy4vdXNlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9qYWNrJztcbmV4cG9ydCAqIGZyb20gJy4vYW1iYXNzYWRvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9ncm93OTAnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXRjaGluZyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50LWNoYXQnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL3F1ZXJpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCwwQ0FBd0I7QUFDeEIseUNBQXVCO0FBQ3ZCLDZDQUEyQjtBQUMzQiwrQ0FBNkI7QUFDN0IsMkNBQXlCO0FBQ3pCLDJDQUF5QjtBQUN6Qix5Q0FBdUI7QUFDdkIsNENBQTBCO0FBQzFCLHdDQUFzQjtBQUN0QixrREFBZ0M7QUFDaEMsMkNBQXlCO0FBQ3pCLGtEQUFnQztBQUNoQyw0Q0FBMEI7QUFDMUIsMENBQXdCO0FBQ3hCLHlDQUF1QjtBQUN2QixnREFBOEI7QUFDOUIsMkNBQXlCO0FBQ3pCLDZDQUEyQjtBQUMzQiwrQ0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFF1ZXJ5IEhvb2tzXG4gKlxuICogUmUtZXhwb3J0cyBhbGwgcXVlcnkgaG9va3MgZm9yIEFQSSBlbmRwb2ludHMuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9hZG1pbic7XG5leHBvcnQgKiBmcm9tICcuL2F1dGgnO1xuZXhwb3J0ICogZnJvbSAnLi9ib29raW5ncyc7XG5leHBvcnQgKiBmcm9tICcuL2J1c2luZXNzZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9jaXRpZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9ldmVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9odWJzJztcbmV4cG9ydCAqIGZyb20gJy4vbGlicmFyeSc7XG5leHBvcnQgKiBmcm9tICcuL21hcCc7XG5leHBvcnQgKiBmcm9tICcuL25vdGlmaWNhdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9vZmZlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdWJzY3JpcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vc3VwcG9ydCc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vamFjayc7XG5leHBvcnQgKiBmcm9tICcuL2FtYmFzc2Fkb3JzJztcbmV4cG9ydCAqIGZyb20gJy4vZ3JvdzkwJztcbmV4cG9ydCAqIGZyb20gJy4vbWF0Y2hpbmcnO1xuZXhwb3J0ICogZnJvbSAnLi9ldmVudC1jaGF0JztcbiJdfQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growsober/sdk",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Shared TypeScript SDK for GrowSober API - TanStack Query hooks, API client, and utilities",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/src/api/mutations/auth.ts

@@ -17,6 +17,9 @@ import type {
   FirebaseAuthRequest,
   AuthResponse,
   TokenResponse,
+  SendOtpRequest,
+  OtpSentResponse,
+  VerifyOtpRequest,
 } from '../types';
 
 // ============================================================================
@@ -348,3 +351,114 @@ export function useFirebaseAuth(
     ...options,
   });
 }
+
+/**
+ * Response type for verify OTP including isNewUser flag
+ */
+export type VerifyOtpResponse = AuthResponse & { isNewUser: boolean };
+
+/**
+ * Send OTP to phone number
+ *
+ * @description
+ * Sends a verification code to the specified phone number via SMS or voice call.
+ * Used for passwordless authentication.
+ *
+ * @endpoint POST /auth/phone/send-otp
+ *
+ * @example
+ * ```tsx
+ * import { useSendOtp } from '@growsober/sdk';
+ *
+ * function PhoneInputScreen() {
+ *   const { mutate: sendOtp, isPending, error } = useSendOtp({
+ *     onSuccess: (data) => {
+ *       console.log('OTP sent to:', data.phone);
+ *       navigation.navigate('VerifyOtp', { phone });
+ *     },
+ *     onError: (error) => {
+ *       Alert.alert('Error', error.message);
+ *     },
+ *   });
+ *
+ *   const handleSend = () => {
+ *     sendOtp({ phone: '+1234567890', channel: 'sms' });
+ *   };
+ *
+ *   return <Button onPress={handleSend} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export function useSendOtp(
+  options?: Omit<UseMutationOptions<OtpSentResponse, Error, SendOtpRequest>, 'mutationFn'>
+): UseMutationResult<OtpSentResponse, Error, SendOtpRequest> {
+  return useMutation({
+    mutationFn: async (data: SendOtpRequest): Promise<OtpSentResponse> => {
+      const client = getApiClient();
+      const response = await client.post<OtpSentResponse>('/auth/phone/send-otp', data);
+      return response.data;
+    },
+    ...options,
+  });
+}
+
+/**
+ * Verify OTP and authenticate
+ *
+ * @description
+ * Verifies the OTP code sent to the phone number and authenticates the user.
+ * If the user doesn't exist, a new account is created automatically.
+ * Returns authentication tokens and user information.
+ *
+ * @endpoint POST /auth/phone/verify-otp
+ *
+ * @example
+ * ```tsx
+ * import { useVerifyOtp } from '@growsober/sdk';
+ *
+ * function VerifyOtpScreen({ phone }) {
+ *   const { mutate: verifyOtp, isPending, error } = useVerifyOtp({
+ *     onSuccess: async (data) => {
+ *       await SecureStore.setItemAsync('accessToken', data.accessToken);
+ *       await SecureStore.setItemAsync('refreshToken', data.refreshToken);
+ *
+ *       if (data.isNewUser) {
+ *         navigation.navigate('Onboarding');
+ *       } else {
+ *         navigation.navigate('Home');
+ *       }
+ *     },
+ *   });
+ *
+ *   const handleVerify = (code: string) => {
+ *     verifyOtp({ phone, code });
+ *   };
+ *
+ *   return <OtpInput onComplete={handleVerify} disabled={isPending} />;
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export function useVerifyOtp(
+  options?: Omit<UseMutationOptions<VerifyOtpResponse, Error, VerifyOtpRequest>, 'mutationFn'>
+): UseMutationResult<VerifyOtpResponse, Error, VerifyOtpRequest> {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (data: VerifyOtpRequest): Promise<VerifyOtpResponse> => {
+      const client = getApiClient();
+      const response = await client.post<VerifyOtpResponse>('/auth/phone/verify-otp', data);
+      return response.data;
+    },
+    onSuccess: (data, variables, context) => {
+      // Invalidate current user query to trigger refetch with new token
+      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+    },
+    ...options,
+  });
+}

package/src/api/queries/cities.ts

@@ -0,0 +1,194 @@
+/**
+ * Cities Query Hooks
+ *
+ * TanStack Query hooks for fetching city data.
+ * Cities are used for location-based features and user onboarding.
+ *
+ * @module api/queries/cities
+ */
+
+import { useQuery, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { getApiClient } from '../client';
+
+// ============================================================================
+// QUERY KEY FACTORY
+// ============================================================================
+
+export const cityKeys = {
+  all: ['cities'] as const,
+  lists: () => [...cityKeys.all, 'list'] as const,
+  list: (filters?: CityFilters) => [...cityKeys.lists(), filters] as const,
+  details: () => [...cityKeys.all, 'detail'] as const,
+  detail: (id: string) => [...cityKeys.details(), id] as const,
+  featured: () => [...cityKeys.all, 'featured'] as const,
+};
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface CityResponse {
+  id: string;
+  name: string;
+  country: string;
+  countryCode: string | null;
+  timezone: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  memberCount: number;
+  isFeatured: boolean;
+  region: string | null;
+}
+
+export interface CityFilters {
+  search?: string;
+  countryCode?: string;
+  isFeatured?: boolean;
+}
+
+// ============================================================================
+// QUERY HOOKS
+// ============================================================================
+
+/**
+ * Get list of cities with optional filters
+ *
+ * @description
+ * Fetches available cities for location selection.
+ * Can be filtered by name search, country code, or featured status.
+ * Results are ordered by featured status, member count, and name.
+ *
+ * @endpoint GET /api/v1/cities
+ *
+ * @example
+ * ```tsx
+ * import { useCities } from '@growsober/sdk';
+ *
+ * function CityPicker() {
+ *   const { data: cities, isLoading } = useCities();
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <select>
+ *       {cities?.map(city => (
+ *         <option key={city.id} value={city.id}>
+ *           {city.name}, {city.country}
+ *         </option>
+ *       ))}
+ *     </select>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With search filter:
+ * ```tsx
+ * const { data: cities } = useCities({ search: 'London' });
+ * ```
+ *
+ * @example
+ * Filter by country:
+ * ```tsx
+ * const { data: ukCities } = useCities({ countryCode: 'GB' });
+ * ```
+ *
+ * @param filters - Optional filters for city search
+ * @param options - TanStack Query options
+ * @returns TanStack Query result with array of cities
+ */
+interface CitiesApiResponse {
+  data: CityResponse[];
+  meta: {
+    timestamp: string;
+  };
+}
+
+export function useCities(
+  filters?: CityFilters,
+  options?: Omit<UseQueryOptions<CityResponse[]>, 'queryKey' | 'queryFn'>
+): UseQueryResult<CityResponse[]> {
+  return useQuery({
+    queryKey: cityKeys.list(filters),
+    queryFn: async (): Promise<CityResponse[]> => {
+      const client = getApiClient();
+      const params = new URLSearchParams();
+
+      if (filters?.search) params.append('search', filters.search);
+      if (filters?.countryCode) params.append('countryCode', filters.countryCode);
+      if (filters?.isFeatured !== undefined) params.append('isFeatured', String(filters.isFeatured));
+
+      const queryString = params.toString();
+      const url = `/api/v1/cities${queryString ? `?${queryString}` : ''}`;
+
+      const response = await client.get<CitiesApiResponse>(url);
+      // Handle both wrapped and unwrapped response formats
+      return Array.isArray(response.data) ? response.data : response.data.data;
+    },
+    staleTime: 5 * 60 * 1000, // Cities don't change often, cache for 5 minutes
+    ...options,
+  });
+}
+
+/**
+ * Get featured cities
+ *
+ * @description
+ * Fetches only cities marked as featured.
+ * Useful for showing popular/recommended cities.
+ *
+ * @example
+ * ```tsx
+ * const { data: featuredCities } = useFeaturedCities();
+ * ```
+ *
+ * @param options - TanStack Query options
+ * @returns TanStack Query result with array of featured cities
+ */
+export function useFeaturedCities(
+  options?: Omit<UseQueryOptions<CityResponse[]>, 'queryKey' | 'queryFn'>
+): UseQueryResult<CityResponse[]> {
+  return useCities({ isFeatured: true }, options);
+}
+
+/**
+ * Get a single city by ID
+ *
+ * @description
+ * Fetches details for a specific city.
+ *
+ * @endpoint GET /api/v1/cities/{id}
+ *
+ * @example
+ * ```tsx
+ * const { data: city } = useCity('city-uuid');
+ * ```
+ *
+ * @param id - City ID
+ * @param options - TanStack Query options
+ * @returns TanStack Query result with city data
+ */
+interface CityApiResponse {
+  data: CityResponse;
+  meta: {
+    timestamp: string;
+  };
+}
+
+export function useCity(
+  id: string,
+  options?: Omit<UseQueryOptions<CityResponse>, 'queryKey' | 'queryFn'>
+): UseQueryResult<CityResponse> {
+  return useQuery({
+    queryKey: cityKeys.detail(id),
+    queryFn: async (): Promise<CityResponse> => {
+      const client = getApiClient();
+      const response = await client.get<CityApiResponse>(`/api/v1/cities/${id}`);
+      // Handle both wrapped and unwrapped response formats
+      return (response.data as any).data || response.data;
+    },
+    enabled: !!id,
+    staleTime: 5 * 60 * 1000,
+    ...options,
+  });
+}

package/src/api/queries/index.ts

@@ -8,6 +8,7 @@ export * from './admin';
 export * from './auth';
 export * from './bookings';
 export * from './businesses';
+export * from './cities';
 export * from './events';
 export * from './hubs';
 export * from './library';