@growsober/sdk 1.0.0

package/dist/api/mutations/map.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Map Mutation Hooks
+ *
+ * TanStack Query mutation hooks for map-related write operations.
+ * These hooks handle updating user location and visibility settings.
+ *
+ * @module api/mutations/map
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUpdateLocation = useUpdateLocation;
+exports.useUpdateOpenToMeet = useUpdateOpenToMeet;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const map_1 = require("../queries/map");
+const users_1 = require("../queries/users");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Update current user's location
+ *
+ * @description
+ * Updates the authenticated user's location for display on the member map.
+ * Location is only visible to other users if the user has enabled "open to meet".
+ *
+ * @endpoint PUT /api/v1/map/location
+ *
+ * @example
+ * ```tsx
+ * import { useUpdateLocation } from '@growsober/sdk';
+ *
+ * function LocationUpdater() {
+ *   const updateLocation = useUpdateLocation();
+ *
+ *   const handleLocationUpdate = async () => {
+ *     // Get current position from device
+ *     navigator.geolocation.getCurrentPosition(
+ *       async (position) => {
+ *         await updateLocation.mutateAsync({
+ *           lat: position.coords.latitude,
+ *           lng: position.coords.longitude,
+ *         });
+ *       },
+ *       (error) => console.error('Location error:', error)
+ *     );
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleLocationUpdate} disabled={updateLocation.isPending}>
+ *       Update My Location
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With Expo Location:
+ * ```tsx
+ * import * as Location from 'expo-location';
+ * import { useUpdateLocation } from '@growsober/sdk';
+ *
+ * function App() {
+ *   const updateLocation = useUpdateLocation();
+ *
+ *   useEffect(() => {
+ *     (async () => {
+ *       const { status } = await Location.requestForegroundPermissionsAsync();
+ *       if (status === 'granted') {
+ *         const location = await Location.getCurrentPositionAsync({});
+ *         updateLocation.mutate({
+ *           lat: location.coords.latitude,
+ *           lng: location.coords.longitude,
+ *         });
+ *       }
+ *     })();
+ *   }, []);
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+function useUpdateLocation(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put('/api/v1/map/location', data);
+            return response.data;
+        },
+        onSuccess: () => {
+            // Invalidate map queries to reflect new location
+            queryClient.invalidateQueries({ queryKey: map_1.mapKeys.members() });
+            // Also invalidate user data as location is stored on user
+            queryClient.invalidateQueries({ queryKey: users_1.userKeys.me() });
+        },
+        ...options,
+    });
+}
+/**
+ * Toggle "open to meet" status
+ *
+ * @description
+ * Updates the user's "open to meet" visibility setting.
+ * When enabled, the user's location will be visible to other premium members on the map.
+ * Premium feature.
+ *
+ * @endpoint PUT /api/v1/map/open-to-meet
+ *
+ * @example
+ * ```tsx
+ * import { useUpdateOpenToMeet } from '@growsober/sdk';
+ *
+ * function OpenToMeetToggle() {
+ *   const updateOpenToMeet = useUpdateOpenToMeet();
+ *   const [isOpen, setIsOpen] = useState(false);
+ *
+ *   const handleToggle = async () => {
+ *     const newValue = !isOpen;
+ *     await updateOpenToMeet.mutateAsync({ openToMeet: newValue });
+ *     setIsOpen(newValue);
+ *   };
+ *
+ *   return (
+ *     <Switch
+ *       checked={isOpen}
+ *       onChange={handleToggle}
+ *       disabled={updateOpenToMeet.isPending}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * With user state:
+ * ```tsx
+ * import { useCurrentUser, useUpdateOpenToMeet } from '@growsober/sdk';
+ *
+ * function OpenToMeetSetting() {
+ *   const { data: user } = useCurrentUser();
+ *   const updateOpenToMeet = useUpdateOpenToMeet({
+ *     onSuccess: (data) => {
+ *       console.log(data.openToMeet ? 'Now visible on map!' : 'Hidden from map');
+ *     },
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <label>Open to Meet</label>
+ *       <Switch
+ *         checked={user?.openToMeet}
+ *         onChange={(checked) => updateOpenToMeet.mutate({ openToMeet: checked })}
+ *       />
+ *       <p>Show your location to other members</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+function useUpdateOpenToMeet(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put('/api/v1/map/open-to-meet', data);
+            return response.data;
+        },
+        onSuccess: () => {
+            // Invalidate user data to reflect new setting
+            queryClient.invalidateQueries({ queryKey: users_1.userKeys.me() });
+            // Invalidate map queries as visibility has changed
+            queryClient.invalidateQueries({ queryKey: map_1.mapKeys.members() });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.js","sourceRoot":"","sources":["../../../src/api/mutations/map.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AA2GH,8CAyBC;AAiED,kDAyBC;AA5ND,uDAK+B;AAC/B,sCAAyC;AACzC,wCAAyC;AACzC,4CAA4C;AA6B5C,+EAA+E;AAC/E,iBAAiB;AACjB,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,SAAgB,iBAAiB,CAC/B,OAGC;IAED,MAAM,WAAW,GAAG,IAAA,4BAAc,GAAE,CAAC;IAErC,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,EAAE,IAA2B,EAAmC,EAAE;YACjF,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAC/B,sBAAsB,EACtB,IAAI,CACL,CAAC;YACF,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;QACD,SAAS,EAAE,GAAG,EAAE;YACd,iDAAiD;YACjD,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,aAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YAC/D,0DAA0D;YAC1D,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,gBAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,SAAgB,mBAAmB,CACjC,OAGC;IAED,MAAM,WAAW,GAAG,IAAA,4BAAc,GAAE,CAAC;IAErC,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,EAAE,IAA6B,EAA+B,EAAE;YAC/E,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,GAAG,CAC/B,0BAA0B,EAC1B,IAAI,CACL,CAAC;YACF,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;QACD,SAAS,EAAE,GAAG,EAAE;YACd,8CAA8C;YAC9C,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,gBAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAC3D,mDAAmD;YACnD,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,aAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACjE,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Map Mutation Hooks\n *\n * TanStack Query mutation hooks for map-related write operations.\n * These hooks handle updating user location and visibility settings.\n *\n * @module api/mutations/map\n */\n\nimport {\n  useMutation,\n  UseMutationOptions,\n  UseMutationResult,\n  useQueryClient,\n} from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { mapKeys } from '../queries/map';\nimport { userKeys } from '../queries/users';\n\n// ============================================================================\n// REQUEST TYPES\n// ============================================================================\n\nexport interface UpdateLocationRequest {\n  lat: number;\n  lng: number;\n}\n\nexport interface UpdateOpenToMeetRequest {\n  openToMeet: boolean;\n}\n\n// ============================================================================\n// RESPONSE TYPES\n// ============================================================================\n\nexport interface LocationUpdateResponse {\n  success: boolean;\n  message: string;\n}\n\nexport interface OpenToMeetResponse {\n  openToMeet: boolean;\n  message: string;\n}\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Update current user's location\n *\n * @description\n * Updates the authenticated user's location for display on the member map.\n * Location is only visible to other users if the user has enabled \"open to meet\".\n *\n * @endpoint PUT /api/v1/map/location\n *\n * @example\n * ```tsx\n * import { useUpdateLocation } from '@growsober/sdk';\n *\n * function LocationUpdater() {\n *   const updateLocation = useUpdateLocation();\n *\n *   const handleLocationUpdate = async () => {\n *     // Get current position from device\n *     navigator.geolocation.getCurrentPosition(\n *       async (position) => {\n *         await updateLocation.mutateAsync({\n *           lat: position.coords.latitude,\n *           lng: position.coords.longitude,\n *         });\n *       },\n *       (error) => console.error('Location error:', error)\n *     );\n *   };\n *\n *   return (\n *     <button onClick={handleLocationUpdate} disabled={updateLocation.isPending}>\n *       Update My Location\n *     </button>\n *   );\n * }\n * ```\n *\n * @example\n * With Expo Location:\n * ```tsx\n * import * as Location from 'expo-location';\n * import { useUpdateLocation } from '@growsober/sdk';\n *\n * function App() {\n *   const updateLocation = useUpdateLocation();\n *\n *   useEffect(() => {\n *     (async () => {\n *       const { status } = await Location.requestForegroundPermissionsAsync();\n *       if (status === 'granted') {\n *         const location = await Location.getCurrentPositionAsync({});\n *         updateLocation.mutate({\n *           lat: location.coords.latitude,\n *           lng: location.coords.longitude,\n *         });\n *       }\n *     })();\n *   }, []);\n * }\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useUpdateLocation(\n  options?: Omit<\n    UseMutationOptions<LocationUpdateResponse, Error, UpdateLocationRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<LocationUpdateResponse, Error, UpdateLocationRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: UpdateLocationRequest): Promise<LocationUpdateResponse> => {\n      const client = getApiClient();\n      const response = await client.put<LocationUpdateResponse>(\n        '/api/v1/map/location',\n        data\n      );\n      return response.data;\n    },\n    onSuccess: () => {\n      // Invalidate map queries to reflect new location\n      queryClient.invalidateQueries({ queryKey: mapKeys.members() });\n      // Also invalidate user data as location is stored on user\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Toggle \"open to meet\" status\n *\n * @description\n * Updates the user's \"open to meet\" visibility setting.\n * When enabled, the user's location will be visible to other premium members on the map.\n * Premium feature.\n *\n * @endpoint PUT /api/v1/map/open-to-meet\n *\n * @example\n * ```tsx\n * import { useUpdateOpenToMeet } from '@growsober/sdk';\n *\n * function OpenToMeetToggle() {\n *   const updateOpenToMeet = useUpdateOpenToMeet();\n *   const [isOpen, setIsOpen] = useState(false);\n *\n *   const handleToggle = async () => {\n *     const newValue = !isOpen;\n *     await updateOpenToMeet.mutateAsync({ openToMeet: newValue });\n *     setIsOpen(newValue);\n *   };\n *\n *   return (\n *     <Switch\n *       checked={isOpen}\n *       onChange={handleToggle}\n *       disabled={updateOpenToMeet.isPending}\n *     />\n *   );\n * }\n * ```\n *\n * @example\n * With user state:\n * ```tsx\n * import { useCurrentUser, useUpdateOpenToMeet } from '@growsober/sdk';\n *\n * function OpenToMeetSetting() {\n *   const { data: user } = useCurrentUser();\n *   const updateOpenToMeet = useUpdateOpenToMeet({\n *     onSuccess: (data) => {\n *       console.log(data.openToMeet ? 'Now visible on map!' : 'Hidden from map');\n *     },\n *   });\n *\n *   return (\n *     <div>\n *       <label>Open to Meet</label>\n *       <Switch\n *         checked={user?.openToMeet}\n *         onChange={(checked) => updateOpenToMeet.mutate({ openToMeet: checked })}\n *       />\n *       <p>Show your location to other members</p>\n *     </div>\n *   );\n * }\n * ```\n *\n * @param options - TanStack Query mutation options\n * @returns TanStack Query mutation result\n */\nexport function useUpdateOpenToMeet(\n  options?: Omit<\n    UseMutationOptions<OpenToMeetResponse, Error, UpdateOpenToMeetRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<OpenToMeetResponse, Error, UpdateOpenToMeetRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: UpdateOpenToMeetRequest): Promise<OpenToMeetResponse> => {\n      const client = getApiClient();\n      const response = await client.put<OpenToMeetResponse>(\n        '/api/v1/map/open-to-meet',\n        data\n      );\n      return response.data;\n    },\n    onSuccess: () => {\n      // Invalidate user data to reflect new setting\n      queryClient.invalidateQueries({ queryKey: userKeys.me() });\n      // Invalidate map queries as visibility has changed\n      queryClient.invalidateQueries({ queryKey: mapKeys.members() });\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,130 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { MatchResponse, BuddyResponse } from '../queries/matching';
+export interface CreateMatchRequest {
+    matchedUserId: string;
+    message?: string;
+}
+export interface UpdateMatchRequest {
+    status: 'ACCEPTED' | 'DECLINED' | 'BLOCKED';
+}
+export interface CreateBuddyRequest {
+    buddyId: string;
+    message?: string;
+}
+export interface UpdateBuddyRequest {
+    status: 'ACCEPTED' | 'DECLINED' | 'ENDED';
+}
+export interface LogBuddyActivityRequest {
+    type: 'CHECK_IN' | 'MESSAGE' | 'SUPPORT';
+    note?: string;
+}
+/**
+ * Create a new match request
+ *
+ * @endpoint POST /api/v1/matching/matches
+ *
+ * @example
+ * ```tsx
+ * const createMatch = useCreateMatch();
+ * await createMatch.mutateAsync({ matchedUserId: 'user-123' });
+ * ```
+ */
+export declare function useCreateMatch(options?: Omit<UseMutationOptions<MatchResponse, Error, CreateMatchRequest>, 'mutationFn'>): UseMutationResult<MatchResponse, Error, CreateMatchRequest>;
+/**
+ * Update match status (accept/decline/block)
+ *
+ * @endpoint PUT /api/v1/matching/matches/:matchId
+ *
+ * @example
+ * ```tsx
+ * const updateMatch = useUpdateMatch();
+ * await updateMatch.mutateAsync({ matchId: 'match-123', status: 'ACCEPTED' });
+ * ```
+ */
+export declare function useUpdateMatch(options?: Omit<UseMutationOptions<MatchResponse, Error, {
+    matchId: string;
+    data: UpdateMatchRequest;
+}>, 'mutationFn'>): UseMutationResult<MatchResponse, Error, {
+    matchId: string;
+    data: UpdateMatchRequest;
+}>;
+/**
+ * Accept a match (convenience hook)
+ *
+ * @example
+ * ```tsx
+ * const acceptMatch = useAcceptMatch();
+ * await acceptMatch.mutateAsync('match-123');
+ * ```
+ */
+export declare function useAcceptMatch(options?: Omit<UseMutationOptions<MatchResponse, Error, string>, 'mutationFn'>): UseMutationResult<MatchResponse, Error, string>;
+/**
+ * Decline a match (convenience hook)
+ *
+ * @example
+ * ```tsx
+ * const declineMatch = useDeclineMatch();
+ * await declineMatch.mutateAsync('match-123');
+ * ```
+ */
+export declare function useDeclineMatch(options?: Omit<UseMutationOptions<MatchResponse, Error, string>, 'mutationFn'>): UseMutationResult<MatchResponse, Error, string>;
+/**
+ * Delete a match
+ *
+ * @endpoint DELETE /api/v1/matching/matches/:matchId
+ *
+ * @example
+ * ```tsx
+ * const deleteMatch = useDeleteMatch();
+ * await deleteMatch.mutateAsync('match-123');
+ * ```
+ */
+export declare function useDeleteMatch(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
+/**
+ * Request someone as accountability buddy
+ *
+ * @endpoint POST /api/v1/matching/buddies
+ *
+ * @example
+ * ```tsx
+ * const requestBuddy = useRequestBuddy();
+ * await requestBuddy.mutateAsync({ buddyId: 'user-123' });
+ * ```
+ */
+export declare function useRequestBuddy(options?: Omit<UseMutationOptions<BuddyResponse, Error, CreateBuddyRequest>, 'mutationFn'>): UseMutationResult<BuddyResponse, Error, CreateBuddyRequest>;
+/**
+ * Update buddy request (accept/decline/end)
+ *
+ * @endpoint PUT /api/v1/matching/buddies/:buddyId
+ *
+ * @example
+ * ```tsx
+ * const updateBuddy = useUpdateBuddy();
+ * await updateBuddy.mutateAsync({ buddyId: 'buddy-123', data: { status: 'ACCEPTED' } });
+ * ```
+ */
+export declare function useUpdateBuddy(options?: Omit<UseMutationOptions<BuddyResponse, Error, {
+    buddyId: string;
+    data: UpdateBuddyRequest;
+}>, 'mutationFn'>): UseMutationResult<BuddyResponse, Error, {
+    buddyId: string;
+    data: UpdateBuddyRequest;
+}>;
+/**
+ * Log activity with buddy (check-in, message)
+ *
+ * @endpoint POST /api/v1/matching/buddies/:buddyId/activity
+ *
+ * @example
+ * ```tsx
+ * const logActivity = useLogBuddyActivity();
+ * await logActivity.mutateAsync({ buddyId: 'buddy-123', data: { type: 'CHECK_IN' } });
+ * ```
+ */
+export declare function useLogBuddyActivity(options?: Omit<UseMutationOptions<void, Error, {
+    buddyId: string;
+    data: LogBuddyActivityRequest;
+}>, 'mutationFn'>): UseMutationResult<void, Error, {
+    buddyId: string;
+    data: LogBuddyActivityRequest;
+}>;

package/dist/api/mutations/matching.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateMatch = useCreateMatch;
+exports.useUpdateMatch = useUpdateMatch;
+exports.useAcceptMatch = useAcceptMatch;
+exports.useDeclineMatch = useDeclineMatch;
+exports.useDeleteMatch = useDeleteMatch;
+exports.useRequestBuddy = useRequestBuddy;
+exports.useUpdateBuddy = useUpdateBuddy;
+exports.useLogBuddyActivity = useLogBuddyActivity;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const matching_1 = require("../queries/matching");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Create a new match request
+ *
+ * @endpoint POST /api/v1/matching/matches
+ *
+ * @example
+ * ```tsx
+ * const createMatch = useCreateMatch();
+ * await createMatch.mutateAsync({ matchedUserId: 'user-123' });
+ * ```
+ */
+function useCreateMatch(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/matching/matches', data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.matches() });
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.stats() });
+        },
+        ...options,
+    });
+}
+/**
+ * Update match status (accept/decline/block)
+ *
+ * @endpoint PUT /api/v1/matching/matches/:matchId
+ *
+ * @example
+ * ```tsx
+ * const updateMatch = useUpdateMatch();
+ * await updateMatch.mutateAsync({ matchId: 'match-123', status: 'ACCEPTED' });
+ * ```
+ */
+function useUpdateMatch(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ matchId, data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/matching/matches/${matchId}`, data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.matches() });
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.stats() });
+        },
+        ...options,
+    });
+}
+/**
+ * Accept a match (convenience hook)
+ *
+ * @example
+ * ```tsx
+ * const acceptMatch = useAcceptMatch();
+ * await acceptMatch.mutateAsync('match-123');
+ * ```
+ */
+function useAcceptMatch(options) {
+    const updateMatch = useUpdateMatch();
+    return {
+        ...updateMatch,
+        mutate: (matchId, mutateOptions) => updateMatch.mutate({ matchId, data: { status: 'ACCEPTED' } }, mutateOptions),
+        mutateAsync: (matchId) => updateMatch.mutateAsync({ matchId, data: { status: 'ACCEPTED' } }),
+    };
+}
+/**
+ * Decline a match (convenience hook)
+ *
+ * @example
+ * ```tsx
+ * const declineMatch = useDeclineMatch();
+ * await declineMatch.mutateAsync('match-123');
+ * ```
+ */
+function useDeclineMatch(options) {
+    const updateMatch = useUpdateMatch();
+    return {
+        ...updateMatch,
+        mutate: (matchId, mutateOptions) => updateMatch.mutate({ matchId, data: { status: 'DECLINED' } }, mutateOptions),
+        mutateAsync: (matchId) => updateMatch.mutateAsync({ matchId, data: { status: 'DECLINED' } }),
+    };
+}
+/**
+ * Delete a match
+ *
+ * @endpoint DELETE /api/v1/matching/matches/:matchId
+ *
+ * @example
+ * ```tsx
+ * const deleteMatch = useDeleteMatch();
+ * await deleteMatch.mutateAsync('match-123');
+ * ```
+ */
+function useDeleteMatch(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (matchId) => {
+            const client = (0, client_1.getApiClient)();
+            await client.delete(`/api/v1/matching/matches/${matchId}`);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.matches() });
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.stats() });
+        },
+        ...options,
+    });
+}
+/**
+ * Request someone as accountability buddy
+ *
+ * @endpoint POST /api/v1/matching/buddies
+ *
+ * @example
+ * ```tsx
+ * const requestBuddy = useRequestBuddy();
+ * await requestBuddy.mutateAsync({ buddyId: 'user-123' });
+ * ```
+ */
+function useRequestBuddy(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/matching/buddies', data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.buddies() });
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.buddyRequests() });
+        },
+        ...options,
+    });
+}
+/**
+ * Update buddy request (accept/decline/end)
+ *
+ * @endpoint PUT /api/v1/matching/buddies/:buddyId
+ *
+ * @example
+ * ```tsx
+ * const updateBuddy = useUpdateBuddy();
+ * await updateBuddy.mutateAsync({ buddyId: 'buddy-123', data: { status: 'ACCEPTED' } });
+ * ```
+ */
+function useUpdateBuddy(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ buddyId, data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/matching/buddies/${buddyId}`, data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.buddies() });
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.buddyRequests() });
+        },
+        ...options,
+    });
+}
+/**
+ * Log activity with buddy (check-in, message)
+ *
+ * @endpoint POST /api/v1/matching/buddies/:buddyId/activity
+ *
+ * @example
+ * ```tsx
+ * const logActivity = useLogBuddyActivity();
+ * await logActivity.mutateAsync({ buddyId: 'buddy-123', data: { type: 'CHECK_IN' } });
+ * ```
+ */
+function useLogBuddyActivity(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ buddyId, data }) => {
+            const client = (0, client_1.getApiClient)();
+            await client.post(`/api/v1/matching/buddies/${buddyId}/activity`, data);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: matching_1.matchingKeys.buddies() });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matching.js","sourceRoot":"","sources":["../../../src/api/mutations/matching.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 { matchingKeys, MatchResponse, BuddyResponse } from '../queries/matching';\n\n// ============================================================================\n// REQUEST TYPES\n// ============================================================================\n\nexport interface CreateMatchRequest {\n  matchedUserId: string;\n  message?: string;\n}\n\nexport interface UpdateMatchRequest {\n  status: 'ACCEPTED' | 'DECLINED' | 'BLOCKED';\n}\n\nexport interface CreateBuddyRequest {\n  buddyId: string;\n  message?: string;\n}\n\nexport interface UpdateBuddyRequest {\n  status: 'ACCEPTED' | 'DECLINED' | 'ENDED';\n}\n\nexport interface LogBuddyActivityRequest {\n  type: 'CHECK_IN' | 'MESSAGE' | 'SUPPORT';\n  note?: string;\n}\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Create a new match request\n *\n * @endpoint POST /api/v1/matching/matches\n *\n * @example\n * ```tsx\n * const createMatch = useCreateMatch();\n * await createMatch.mutateAsync({ matchedUserId: 'user-123' });\n * ```\n */\nexport function useCreateMatch(\n  options?: Omit<UseMutationOptions<MatchResponse, Error, CreateMatchRequest>, 'mutationFn'>\n): UseMutationResult<MatchResponse, Error, CreateMatchRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateMatchRequest): Promise<MatchResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/matching/matches', data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: matchingKeys.matches() });\n      queryClient.invalidateQueries({ queryKey: matchingKeys.stats() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update match status (accept/decline/block)\n *\n * @endpoint PUT /api/v1/matching/matches/:matchId\n *\n * @example\n * ```tsx\n * const updateMatch = useUpdateMatch();\n * await updateMatch.mutateAsync({ matchId: 'match-123', status: 'ACCEPTED' });\n * ```\n */\nexport function useUpdateMatch(\n  options?: Omit<\n    UseMutationOptions<MatchResponse, Error, { matchId: string; data: UpdateMatchRequest }>,\n    'mutationFn'\n  >\n): UseMutationResult<MatchResponse, Error, { matchId: string; data: UpdateMatchRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ matchId, data }): Promise<MatchResponse> => {\n      const client = getApiClient();\n      const response = await client.put(`/api/v1/matching/matches/${matchId}`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: matchingKeys.matches() });\n      queryClient.invalidateQueries({ queryKey: matchingKeys.stats() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Accept a match (convenience hook)\n *\n * @example\n * ```tsx\n * const acceptMatch = useAcceptMatch();\n * await acceptMatch.mutateAsync('match-123');\n * ```\n */\nexport function useAcceptMatch(\n  options?: Omit<UseMutationOptions<MatchResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<MatchResponse, Error, string> {\n  const updateMatch = useUpdateMatch();\n\n  return {\n    ...updateMatch,\n    mutate: (matchId: string, mutateOptions?: any) =>\n      updateMatch.mutate({ matchId, data: { status: 'ACCEPTED' } }, mutateOptions),\n    mutateAsync: (matchId: string) =>\n      updateMatch.mutateAsync({ matchId, data: { status: 'ACCEPTED' } }),\n  } as UseMutationResult<MatchResponse, Error, string>;\n}\n\n/**\n * Decline a match (convenience hook)\n *\n * @example\n * ```tsx\n * const declineMatch = useDeclineMatch();\n * await declineMatch.mutateAsync('match-123');\n * ```\n */\nexport function useDeclineMatch(\n  options?: Omit<UseMutationOptions<MatchResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<MatchResponse, Error, string> {\n  const updateMatch = useUpdateMatch();\n\n  return {\n    ...updateMatch,\n    mutate: (matchId: string, mutateOptions?: any) =>\n      updateMatch.mutate({ matchId, data: { status: 'DECLINED' } }, mutateOptions),\n    mutateAsync: (matchId: string) =>\n      updateMatch.mutateAsync({ matchId, data: { status: 'DECLINED' } }),\n  } as UseMutationResult<MatchResponse, Error, string>;\n}\n\n/**\n * Delete a match\n *\n * @endpoint DELETE /api/v1/matching/matches/:matchId\n *\n * @example\n * ```tsx\n * const deleteMatch = useDeleteMatch();\n * await deleteMatch.mutateAsync('match-123');\n * ```\n */\nexport function useDeleteMatch(\n  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>\n): UseMutationResult<void, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (matchId: string): Promise<void> => {\n      const client = getApiClient();\n      await client.delete(`/api/v1/matching/matches/${matchId}`);\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: matchingKeys.matches() });\n      queryClient.invalidateQueries({ queryKey: matchingKeys.stats() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Request someone as accountability buddy\n *\n * @endpoint POST /api/v1/matching/buddies\n *\n * @example\n * ```tsx\n * const requestBuddy = useRequestBuddy();\n * await requestBuddy.mutateAsync({ buddyId: 'user-123' });\n * ```\n */\nexport function useRequestBuddy(\n  options?: Omit<UseMutationOptions<BuddyResponse, Error, CreateBuddyRequest>, 'mutationFn'>\n): UseMutationResult<BuddyResponse, Error, CreateBuddyRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateBuddyRequest): Promise<BuddyResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/matching/buddies', data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: matchingKeys.buddies() });\n      queryClient.invalidateQueries({ queryKey: matchingKeys.buddyRequests() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update buddy request (accept/decline/end)\n *\n * @endpoint PUT /api/v1/matching/buddies/:buddyId\n *\n * @example\n * ```tsx\n * const updateBuddy = useUpdateBuddy();\n * await updateBuddy.mutateAsync({ buddyId: 'buddy-123', data: { status: 'ACCEPTED' } });\n * ```\n */\nexport function useUpdateBuddy(\n  options?: Omit<\n    UseMutationOptions<BuddyResponse, Error, { buddyId: string; data: UpdateBuddyRequest }>,\n    'mutationFn'\n  >\n): UseMutationResult<BuddyResponse, Error, { buddyId: string; data: UpdateBuddyRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ buddyId, data }): Promise<BuddyResponse> => {\n      const client = getApiClient();\n      const response = await client.put(`/api/v1/matching/buddies/${buddyId}`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: matchingKeys.buddies() });\n      queryClient.invalidateQueries({ queryKey: matchingKeys.buddyRequests() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Log activity with buddy (check-in, message)\n *\n * @endpoint POST /api/v1/matching/buddies/:buddyId/activity\n *\n * @example\n * ```tsx\n * const logActivity = useLogBuddyActivity();\n * await logActivity.mutateAsync({ buddyId: 'buddy-123', data: { type: 'CHECK_IN' } });\n * ```\n */\nexport function useLogBuddyActivity(\n  options?: Omit<\n    UseMutationOptions<void, Error, { buddyId: string; data: LogBuddyActivityRequest }>,\n    'mutationFn'\n  >\n): UseMutationResult<void, Error, { buddyId: string; data: LogBuddyActivityRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ buddyId, data }): Promise<void> => {\n      const client = getApiClient();\n      await client.post(`/api/v1/matching/buddies/${buddyId}/activity`, data);\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: matchingKeys.buddies() });\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,63 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { NotificationResponse } from '../types';
+/**
+ * Mark a notification as read
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: markAsRead } = useMarkNotificationRead();
+ *
+ * const handleNotificationClick = (notificationId: string) => {
+ *   markAsRead(notificationId);
+ * };
+ * ```
+ */
+export declare function useMarkNotificationRead(options?: Omit<UseMutationOptions<NotificationResponse, Error, string>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    userId: string;
+    type: "EVENT_REMINDER" | "EVENT_CANCELLED" | "EVENT_UPDATED" | "NEW_EVENT" | "HUB_WELCOME" | "NEW_MEMBER" | "STREAK_MILESTONE" | "DAILY_REMINDER" | "JACK_RESPONSE" | "WEEKLY_REFLECTION" | "BADGE_EARNED" | "SYSTEM_UPDATE";
+    title: string;
+    body?: Record<string, never>;
+    data?: Record<string, never>;
+    imageUrl?: Record<string, never>;
+    channel: "APP" | "EMAIL" | "PUSH" | "SMS" | "WHATSAPP";
+    isRead: boolean;
+    sentAt?: Record<string, never>;
+    readAt?: Record<string, never>;
+    actionUrl?: Record<string, never>;
+    deliveryStatus: "PENDING" | "SENT" | "DELIVERED" | "FAILED";
+    errorMessage?: Record<string, never>;
+    createdAt: string;
+}, Error, string, unknown>;
+/**
+ * Mark all notifications as read
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: markAllRead, isPending } = useMarkAllNotificationsRead();
+ *
+ * const handleMarkAllRead = () => {
+ *   markAllRead();
+ * };
+ * ```
+ */
+export declare function useMarkAllNotificationsRead(options?: Omit<UseMutationOptions<void, Error, void>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+/**
+ * Delete a notification
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: deleteNotification } = useDeleteNotification();
+ *
+ * const handleDelete = (notificationId: string) => {
+ *   deleteNotification(notificationId);
+ * };
+ * ```
+ */
+export declare function useDeleteNotification(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;