@growsober/sdk 1.0.0

package/dist/api/mutations/auth.js

@@ -0,0 +1,332 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRegister = useRegister;
+exports.useLogin = useLogin;
+exports.useRefreshAuthToken = useRefreshAuthToken;
+exports.useFirebaseAuth = useFirebaseAuth;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const users_1 = require("../queries/users");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * 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
+ */
+function useRegister(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/register', 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() });
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * 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
+ */
+function useLogin(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/login', 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() });
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * 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
+ */
+function useRefreshAuthToken(options) {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/auth/refresh', data);
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * 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
+ */
+function useFirebaseAuth(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/firebase', 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() });
+            // User's onSuccess is handled by spreading 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"]}

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

@@ -0,0 +1,59 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { BookingResponse } from '../types';
+/**
+ * Create a new booking for an event
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateBooking();
+ *
+ * // Simple usage - just pass eventId
+ * mutate({ eventId: 'event-123' });
+ *
+ * // With optional data
+ * mutate({
+ *   eventId: 'event-123',
+ *   ticketCount: 2,
+ *   notes: 'Vegetarian meal preferred'
+ * });
+ * ```
+ */
+export declare function useCreateBooking(options?: Omit<UseMutationOptions<BookingResponse, Error, {
+    eventId: string;
+    ticketCount?: number;
+    notes?: string;
+}>, 'mutationFn'>): UseMutationResult<BookingResponse, Error, {
+    eventId: string;
+    ticketCount?: number;
+    notes?: string;
+}>;
+/**
+ * Cancel a booking
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCancelBooking();
+ *
+ * mutate('booking-123');
+ * ```
+ */
+export declare function useCancelBooking(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
+/**
+ * Check in a booking
+ *
+ * Note: This is typically used by event hosts/ambassadors to check in attendees
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCheckInBooking();
+ *
+ * mutate('booking-123');
+ * ```
+ */
+export declare function useCheckInBooking(options?: Omit<UseMutationOptions<BookingResponse, Error, string>, 'mutationFn'>): UseMutationResult<BookingResponse, Error, string>;

package/dist/api/mutations/bookings.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateBooking = useCreateBooking;
+exports.useCancelBooking = useCancelBooking;
+exports.useCheckInBooking = useCheckInBooking;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const bookings_1 = require("../queries/bookings");
+const events_1 = require("../queries/events");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Create a new booking for an event
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateBooking();
+ *
+ * // Simple usage - just pass eventId
+ * mutate({ eventId: 'event-123' });
+ *
+ * // With optional data
+ * mutate({
+ *   eventId: 'event-123',
+ *   ticketCount: 2,
+ *   notes: 'Vegetarian meal preferred'
+ * });
+ * ```
+ */
+function useCreateBooking(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ eventId, ticketCount, notes, }) => {
+            const client = (0, client_1.getApiClient)();
+            const data = {};
+            if (ticketCount)
+                data.ticketCount = ticketCount;
+            if (notes)
+                data.notes = notes;
+            const response = await client.post(`/api/v1/events/${eventId}/book`, data);
+            return response.data;
+        },
+        onSuccess: (newBooking, variables, context) => {
+            // Invalidate user's bookings list
+            queryClient.invalidateQueries({ queryKey: bookings_1.bookingKeys.mine() });
+            // Invalidate all booking lists
+            queryClient.invalidateQueries({ queryKey: bookings_1.bookingKeys.lists() });
+            // Invalidate the event to reflect updated booking count
+            queryClient.invalidateQueries({
+                queryKey: events_1.eventKeys.detail(variables.eventId)
+            });
+            // Invalidate event bookings if applicable
+            queryClient.invalidateQueries({
+                queryKey: events_1.eventKeys.bookings(variables.eventId)
+            });
+            // Invalidate ambient events
+            queryClient.invalidateQueries({ queryKey: events_1.eventKeys.ambient() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Cancel a booking
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCancelBooking();
+ *
+ * mutate('booking-123');
+ * ```
+ */
+function useCancelBooking(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (id) => {
+            const client = (0, client_1.getApiClient)();
+            await client.delete(`/api/v1/bookings/${id}`);
+        },
+        onSuccess: (data, bookingId, context) => {
+            // Remove the booking from cache
+            queryClient.removeQueries({ queryKey: bookings_1.bookingKeys.detail(bookingId) });
+            // Invalidate user's bookings list
+            queryClient.invalidateQueries({ queryKey: bookings_1.bookingKeys.mine() });
+            // Invalidate all booking lists
+            queryClient.invalidateQueries({ queryKey: bookings_1.bookingKeys.lists() });
+            // Invalidate QR code cache
+            queryClient.removeQueries({ queryKey: bookings_1.bookingKeys.qrCode(bookingId) });
+            // Invalidate events to reflect updated booking counts
+            queryClient.invalidateQueries({ queryKey: events_1.eventKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: events_1.eventKeys.upcoming() });
+            queryClient.invalidateQueries({ queryKey: events_1.eventKeys.ambient() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Check in a booking
+ *
+ * Note: This is typically used by event hosts/ambassadors to check in attendees
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCheckInBooking();
+ *
+ * mutate('booking-123');
+ * ```
+ */
+function useCheckInBooking(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/bookings/${id}/check-in`);
+            return response.data;
+        },
+        onSuccess: (checkedInBooking, bookingId, context) => {
+            // Update the booking in cache
+            queryClient.setQueryData(bookings_1.bookingKeys.detail(bookingId), checkedInBooking);
+            // Invalidate user's bookings list to reflect check-in status
+            queryClient.invalidateQueries({ queryKey: bookings_1.bookingKeys.mine() });
+            // Invalidate all booking lists
+            queryClient.invalidateQueries({ queryKey: bookings_1.bookingKeys.lists() });
+            // Invalidate event bookings if applicable
+            if (checkedInBooking.eventId) {
+                queryClient.invalidateQueries({
+                    queryKey: events_1.eventKeys.bookings(checkedInBooking.eventId)
+                });
+            }
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bookings.js","sourceRoot":"","sources":["../../../src/api/mutations/bookings.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 { BookingResponse } from '../types';\nimport { bookingKeys } from '../queries/bookings';\nimport { eventKeys } from '../queries/events';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Create a new booking for an event\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCreateBooking();\n *\n * // Simple usage - just pass eventId\n * mutate({ eventId: 'event-123' });\n *\n * // With optional data\n * mutate({\n *   eventId: 'event-123',\n *   ticketCount: 2,\n *   notes: 'Vegetarian meal preferred'\n * });\n * ```\n */\nexport function useCreateBooking(\n  options?: Omit<\n    UseMutationOptions<\n      BookingResponse,\n      Error,\n      { eventId: string; ticketCount?: number; notes?: string }\n    >,\n    'mutationFn'\n  >\n): UseMutationResult<\n  BookingResponse,\n  Error,\n  { eventId: string; ticketCount?: number; notes?: string }\n> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      eventId,\n      ticketCount,\n      notes,\n    }: {\n      eventId: string;\n      ticketCount?: number;\n      notes?: string;\n    }): Promise<BookingResponse> => {\n      const client = getApiClient();\n      const data: any = {};\n      if (ticketCount) data.ticketCount = ticketCount;\n      if (notes) data.notes = notes;\n      const response = await client.post(`/api/v1/events/${eventId}/book`, data);\n      return response.data;\n    },\n    onSuccess: (newBooking, variables, context) => {\n      // Invalidate user's bookings list\n      queryClient.invalidateQueries({ queryKey: bookingKeys.mine() });\n\n      // Invalidate all booking lists\n      queryClient.invalidateQueries({ queryKey: bookingKeys.lists() });\n\n      // Invalidate the event to reflect updated booking count\n      queryClient.invalidateQueries({\n        queryKey: eventKeys.detail(variables.eventId)\n      });\n\n      // Invalidate event bookings if applicable\n      queryClient.invalidateQueries({\n        queryKey: eventKeys.bookings(variables.eventId)\n      });\n\n      // Invalidate ambient events\n      queryClient.invalidateQueries({ queryKey: eventKeys.ambient() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Cancel a booking\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCancelBooking();\n *\n * mutate('booking-123');\n * ```\n */\nexport function useCancelBooking(\n  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>\n): UseMutationResult<void, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<void> => {\n      const client = getApiClient();\n      await client.delete(`/api/v1/bookings/${id}`);\n    },\n    onSuccess: (data, bookingId, context) => {\n      // Remove the booking from cache\n      queryClient.removeQueries({ queryKey: bookingKeys.detail(bookingId) });\n\n      // Invalidate user's bookings list\n      queryClient.invalidateQueries({ queryKey: bookingKeys.mine() });\n\n      // Invalidate all booking lists\n      queryClient.invalidateQueries({ queryKey: bookingKeys.lists() });\n\n      // Invalidate QR code cache\n      queryClient.removeQueries({ queryKey: bookingKeys.qrCode(bookingId) });\n\n      // Invalidate events to reflect updated booking counts\n      queryClient.invalidateQueries({ queryKey: eventKeys.lists() });\n      queryClient.invalidateQueries({ queryKey: eventKeys.upcoming() });\n      queryClient.invalidateQueries({ queryKey: eventKeys.ambient() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Check in a booking\n *\n * Note: This is typically used by event hosts/ambassadors to check in attendees\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCheckInBooking();\n *\n * mutate('booking-123');\n * ```\n */\nexport function useCheckInBooking(\n  options?: Omit<UseMutationOptions<BookingResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<BookingResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<BookingResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/bookings/${id}/check-in`);\n      return response.data;\n    },\n    onSuccess: (checkedInBooking, bookingId, context) => {\n      // Update the booking in cache\n      queryClient.setQueryData(\n        bookingKeys.detail(bookingId),\n        checkedInBooking\n      );\n\n      // Invalidate user's bookings list to reflect check-in status\n      queryClient.invalidateQueries({ queryKey: bookingKeys.mine() });\n\n      // Invalidate all booking lists\n      queryClient.invalidateQueries({ queryKey: bookingKeys.lists() });\n\n      // Invalidate event bookings if applicable\n      if (checkedInBooking.eventId) {\n        queryClient.invalidateQueries({\n          queryKey: eventKeys.bookings(checkedInBooking.eventId)\n        });\n      }\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n"]}

package/dist/api/mutations/event-chat.d.ts

@@ -0,0 +1,35 @@
+import type { ChatMemberResponse, MessageResponse, EventChatResponse, SendMessageRequest, UpdateMessageRequest, UpdateChatSettingsRequest, UpdateMemberSettingsRequest } from '../types';
+/**
+ * Update chat settings (hosts only)
+ */
+export declare function useUpdateChatSettings(eventId: string): import("@tanstack/react-query").UseMutationResult<EventChatResponse, Error, UpdateChatSettingsRequest, unknown>;
+/**
+ * Join event chat
+ */
+export declare function useJoinEventChat(eventId: string): import("@tanstack/react-query").UseMutationResult<ChatMemberResponse, Error, void, unknown>;
+/**
+ * Leave event chat
+ */
+export declare function useLeaveEventChat(eventId: string): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+/**
+ * Update member settings (mute, nickname)
+ */
+export declare function useUpdateMemberSettings(eventId: string): import("@tanstack/react-query").UseMutationResult<ChatMemberResponse, Error, UpdateMemberSettingsRequest, unknown>;
+/**
+ * Mark messages as read
+ */
+export declare function useMarkMessagesAsRead(eventId: string): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+/**
+ * Send a message
+ */
+export declare function useSendEventChatMessage(eventId: string): import("@tanstack/react-query").UseMutationResult<MessageResponse, Error, SendMessageRequest, unknown>;
+/**
+ * Update a message
+ */
+export declare function useUpdateEventChatMessage(eventId: string): import("@tanstack/react-query").UseMutationResult<MessageResponse, Error, {
+    messageId: string;
+} & UpdateMessageRequest, unknown>;
+/**
+ * Delete a message
+ */
+export declare function useDeleteEventChatMessage(eventId: string): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;