@growsober/sdk 1.0.0

package/dist/api/mutations/support.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateCheckIn = useCreateCheckIn;
+exports.useUpdateCheckIn = useUpdateCheckIn;
+exports.useCreateMoodLog = useCreateMoodLog;
+exports.useCreateWin = useCreateWin;
+exports.useCreateHabit = useCreateHabit;
+exports.useUpdateHabit = useUpdateHabit;
+exports.useDeleteHabit = useDeleteHabit;
+exports.useCompleteHabit = useCompleteHabit;
+exports.useCreateReflection = useCreateReflection;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const support_1 = require("../queries/support");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Create a daily check-in
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateCheckIn();
+ *
+ * mutate({
+ *   mood: 8,
+ *   notes: 'Feeling great today!',
+ *   triggers: ['stress'],
+ *   gratitude: ['My support group']
+ * });
+ * ```
+ */
+function useCreateCheckIn(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/support/check-ins', data);
+            return response.data;
+        },
+        onSuccess: (newCheckIn, variables, context) => {
+            // Invalidate check-ins list and today's check-in
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.checkIns() });
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.checkInToday() });
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.checkInStreak() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Update a daily check-in
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useUpdateCheckIn();
+ *
+ * mutate({
+ *   id: 'checkin-123',
+ *   data: {
+ *     mood: 4,
+ *     notes: 'Updated notes',
+ *   }
+ * });
+ * ```
+ */
+function useUpdateCheckIn(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ id, data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/support/check-ins/${id}`, data);
+            return response.data;
+        },
+        onSuccess: (updatedCheckIn, variables, context) => {
+            // Invalidate check-ins list and today's check-in
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.checkIns() });
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.checkInToday() });
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.checkInStreak() });
+        },
+        ...options,
+    });
+}
+/**
+ * Create a mood log
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateMoodLog();
+ *
+ * mutate({
+ *   mood: 7,
+ *   notes: 'Feeling optimistic',
+ *   activities: ['exercise', 'meditation']
+ * });
+ * ```
+ */
+function useCreateMoodLog(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/support/mood', data);
+            return response.data;
+        },
+        onSuccess: (newMoodLog, variables, context) => {
+            // Invalidate mood logs list
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.moodLogs() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Create a win
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateWin();
+ *
+ * mutate({
+ *   title: '30 days sober!',
+ *   description: 'Hit my first milestone',
+ *   category: 'sobriety'
+ * });
+ * ```
+ */
+function useCreateWin(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/support/wins', data);
+            return response.data;
+        },
+        onSuccess: (newWin, variables, context) => {
+            // Invalidate wins lists
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.wins() });
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.winsByCategory() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Create a habit
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateHabit();
+ *
+ * mutate({
+ *   name: 'Morning meditation',
+ *   description: '10 minutes of mindfulness',
+ *   frequency: 'daily',
+ *   targetDays: 7
+ * });
+ * ```
+ */
+function useCreateHabit(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/support/habits', data);
+            return response.data;
+        },
+        onSuccess: (newHabit, variables, context) => {
+            // Invalidate habits list
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.habits() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Update a habit
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useUpdateHabit();
+ *
+ * mutate({
+ *   id: 'habit-123',
+ *   data: {
+ *     name: 'Evening meditation',
+ *     targetDays: 14
+ *   }
+ * });
+ * ```
+ */
+function useUpdateHabit(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ id, data, }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/support/habits/${id}`, data);
+            return response.data;
+        },
+        onSuccess: (updatedHabit, variables, context) => {
+            // Invalidate habits list
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.habits() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a habit
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useDeleteHabit();
+ *
+ * mutate('habit-123');
+ * ```
+ */
+function useDeleteHabit(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/support/habits/${id}`);
+        },
+        onSuccess: (data, habitId, context) => {
+            // Invalidate habits list
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.habits() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Complete a habit for today
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCompleteHabit();
+ *
+ * mutate('habit-123');
+ * ```
+ */
+function useCompleteHabit(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/support/habits/${id}/complete`);
+            return response.data;
+        },
+        onSuccess: (completedHabit, habitId, context) => {
+            // Invalidate habits list to show updated completion status
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.habits() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Create a reflection
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateReflection();
+ *
+ * mutate({
+ *   content: 'Today I learned...',
+ *   category: 'growth',
+ *   mood: 8
+ * });
+ * ```
+ */
+function useCreateReflection(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/support/reflections', data);
+            return response.data;
+        },
+        onSuccess: (newReflection, variables, context) => {
+            // Invalidate reflections list
+            queryClient.invalidateQueries({ queryKey: support_1.supportKeys.reflections() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"support.js","sourceRoot":"","sources":["../../../src/api/mutations/support.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 {\n  DailyCheckInResponse,\n  CreateCheckInRequest,\n  UpdateCheckInRequest,\n  MoodLogResponse,\n  CreateMoodLogRequest,\n  WinResponse,\n  CreateWinRequest,\n  HabitResponse,\n  CreateHabitRequest,\n  UpdateHabitRequest,\n  ReflectionResponse,\n  CreateReflectionRequest,\n} from '../types';\nimport { supportKeys } from '../queries/support';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Create a daily check-in\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCreateCheckIn();\n *\n * mutate({\n *   mood: 8,\n *   notes: 'Feeling great today!',\n *   triggers: ['stress'],\n *   gratitude: ['My support group']\n * });\n * ```\n */\nexport function useCreateCheckIn(\n  options?: Omit<\n    UseMutationOptions<DailyCheckInResponse, Error, CreateCheckInRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<DailyCheckInResponse, Error, CreateCheckInRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateCheckInRequest): Promise<DailyCheckInResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/support/check-ins', data);\n      return response.data;\n    },\n    onSuccess: (newCheckIn, variables, context) => {\n      // Invalidate check-ins list and today's check-in\n      queryClient.invalidateQueries({ queryKey: supportKeys.checkIns() });\n      queryClient.invalidateQueries({ queryKey: supportKeys.checkInToday() });\n      queryClient.invalidateQueries({ queryKey: supportKeys.checkInStreak() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Update a daily check-in\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useUpdateCheckIn();\n *\n * mutate({\n *   id: 'checkin-123',\n *   data: {\n *     mood: 4,\n *     notes: 'Updated notes',\n *   }\n * });\n * ```\n */\nexport function useUpdateCheckIn(\n  options?: Omit<\n    UseMutationOptions<DailyCheckInResponse, Error, { id: string; data: UpdateCheckInRequest }>,\n    'mutationFn'\n  >\n): UseMutationResult<DailyCheckInResponse, Error, { id: string; data: UpdateCheckInRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ id, data }: { id: string; data: UpdateCheckInRequest }): Promise<DailyCheckInResponse> => {\n      const client = getApiClient();\n      const response = await client.put(`/api/v1/support/check-ins/${id}`, data);\n      return response.data;\n    },\n    onSuccess: (updatedCheckIn, variables, context) => {\n      // Invalidate check-ins list and today's check-in\n      queryClient.invalidateQueries({ queryKey: supportKeys.checkIns() });\n      queryClient.invalidateQueries({ queryKey: supportKeys.checkInToday() });\n      queryClient.invalidateQueries({ queryKey: supportKeys.checkInStreak() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a mood log\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCreateMoodLog();\n *\n * mutate({\n *   mood: 7,\n *   notes: 'Feeling optimistic',\n *   activities: ['exercise', 'meditation']\n * });\n * ```\n */\nexport function useCreateMoodLog(\n  options?: Omit<\n    UseMutationOptions<MoodLogResponse, Error, CreateMoodLogRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<MoodLogResponse, Error, CreateMoodLogRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateMoodLogRequest): Promise<MoodLogResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/support/mood', data);\n      return response.data;\n    },\n    onSuccess: (newMoodLog, variables, context) => {\n      // Invalidate mood logs list\n      queryClient.invalidateQueries({ queryKey: supportKeys.moodLogs() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a win\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCreateWin();\n *\n * mutate({\n *   title: '30 days sober!',\n *   description: 'Hit my first milestone',\n *   category: 'sobriety'\n * });\n * ```\n */\nexport function useCreateWin(\n  options?: Omit<\n    UseMutationOptions<WinResponse, Error, CreateWinRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<WinResponse, Error, CreateWinRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateWinRequest): Promise<WinResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/support/wins', data);\n      return response.data;\n    },\n    onSuccess: (newWin, variables, context) => {\n      // Invalidate wins lists\n      queryClient.invalidateQueries({ queryKey: supportKeys.wins() });\n      queryClient.invalidateQueries({ queryKey: supportKeys.winsByCategory() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a habit\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCreateHabit();\n *\n * mutate({\n *   name: 'Morning meditation',\n *   description: '10 minutes of mindfulness',\n *   frequency: 'daily',\n *   targetDays: 7\n * });\n * ```\n */\nexport function useCreateHabit(\n  options?: Omit<\n    UseMutationOptions<HabitResponse, Error, CreateHabitRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<HabitResponse, Error, CreateHabitRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateHabitRequest): Promise<HabitResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/support/habits', data);\n      return response.data;\n    },\n    onSuccess: (newHabit, variables, context) => {\n      // Invalidate habits list\n      queryClient.invalidateQueries({ queryKey: supportKeys.habits() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Update a habit\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useUpdateHabit();\n *\n * mutate({\n *   id: 'habit-123',\n *   data: {\n *     name: 'Evening meditation',\n *     targetDays: 14\n *   }\n * });\n * ```\n */\nexport function useUpdateHabit(\n  options?: Omit<\n    UseMutationOptions<\n      HabitResponse,\n      Error,\n      { id: string; data: UpdateHabitRequest }\n    >,\n    'mutationFn'\n  >\n): UseMutationResult<HabitResponse, Error, { id: string; data: UpdateHabitRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      id,\n      data,\n    }: {\n      id: string;\n      data: UpdateHabitRequest;\n    }): Promise<HabitResponse> => {\n      const client = getApiClient();\n      const response = await client.put(`/api/v1/support/habits/${id}`, data);\n      return response.data;\n    },\n    onSuccess: (updatedHabit, variables, context) => {\n      // Invalidate habits list\n      queryClient.invalidateQueries({ queryKey: supportKeys.habits() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Delete a habit\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useDeleteHabit();\n *\n * mutate('habit-123');\n * ```\n */\nexport function useDeleteHabit(\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/support/habits/${id}`);\n    },\n    onSuccess: (data, habitId, context) => {\n      // Invalidate habits list\n      queryClient.invalidateQueries({ queryKey: supportKeys.habits() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Complete a habit for today\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCompleteHabit();\n *\n * mutate('habit-123');\n * ```\n */\nexport function useCompleteHabit(\n  options?: Omit<UseMutationOptions<HabitResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<HabitResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<HabitResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/support/habits/${id}/complete`);\n      return response.data;\n    },\n    onSuccess: (completedHabit, habitId, context) => {\n      // Invalidate habits list to show updated completion status\n      queryClient.invalidateQueries({ queryKey: supportKeys.habits() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a reflection\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useCreateReflection();\n *\n * mutate({\n *   content: 'Today I learned...',\n *   category: 'growth',\n *   mood: 8\n * });\n * ```\n */\nexport function useCreateReflection(\n  options?: Omit<\n    UseMutationOptions<ReflectionResponse, Error, CreateReflectionRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<ReflectionResponse, Error, CreateReflectionRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateReflectionRequest): Promise<ReflectionResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/support/reflections', data);\n      return response.data;\n    },\n    onSuccess: (newReflection, variables, context) => {\n      // Invalidate reflections list\n      queryClient.invalidateQueries({ queryKey: supportKeys.reflections() });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,211 @@
+/**
+ * Users Mutation Hooks
+ *
+ * TanStack Query mutation hooks for user-related write operations.
+ * These hooks handle user profile updates and onboarding completion.
+ *
+ * @module api/mutations/users
+ */
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { UpdateUserRequest, UserResponse } from '../types';
+/**
+ * Update current user's profile
+ *
+ * @description
+ * Updates the authenticated user's profile information.
+ * This can include name, bio, avatar, location, sober date, and other profile fields.
+ * Automatically invalidates relevant user queries to refresh the UI.
+ *
+ * @endpoint PUT /api/v1/users/me
+ *
+ * @example
+ * ```tsx
+ * import { useUpdateCurrentUser } from '@growsober/sdk';
+ *
+ * function EditProfileForm() {
+ *   const { mutate: updateProfile, isPending, error } = useUpdateCurrentUser({
+ *     onSuccess: (data) => {
+ *       toast.success('Profile updated successfully');
+ *       navigation.goBack();
+ *     },
+ *     onError: (error) => {
+ *       toast.error('Failed to update profile: ' + error.message);
+ *     },
+ *   });
+ *
+ *   const handleSubmit = (formData: FormData) => {
+ *     updateProfile({
+ *       name: formData.name,
+ *       bio: formData.bio,
+ *       avatar: formData.avatar,
+ *       city: formData.city,
+ *       soberDate: formData.soberDate,
+ *     });
+ *   };
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       <input name="name" />
+ *       <textarea name="bio" />
+ *       <button type="submit" disabled={isPending}>
+ *         {isPending ? 'Saving...' : 'Save Profile'}
+ *       </button>
+ *       {error && <p className="error">{error.message}</p>}
+ *     </form>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Update specific fields:
+ * ```tsx
+ * function AvatarUploader() {
+ *   const { mutateAsync: updateProfile } = useUpdateCurrentUser();
+ *
+ *   const handleAvatarChange = async (file: File) => {
+ *     const uploadedUrl = await uploadImage(file);
+ *     await updateProfile({ avatar: uploadedUrl });
+ *     toast.success('Avatar updated!');
+ *   };
+ *
+ *   return <ImagePicker onSelect={handleAvatarChange} />;
+ * }
+ * ```
+ *
+ * @example
+ * Update sober date:
+ * ```tsx
+ * function SoberDatePicker() {
+ *   const { mutate: updateProfile } = useUpdateCurrentUser();
+ *   const { data: user } = useCurrentUser();
+ *
+ *   const handleDateChange = (date: Date) => {
+ *     updateProfile({
+ *       soberDate: date.toISOString(),
+ *     });
+ *   };
+ *
+ *   return (
+ *     <DatePicker
+ *       value={user?.soberDate}
+ *       onChange={handleDateChange}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useUpdateCurrentUser(options?: Omit<UseMutationOptions<UserResponse, Error, UpdateUserRequest>, 'mutationFn'>): UseMutationResult<UserResponse, Error, UpdateUserRequest>;
+/**
+ * Complete user onboarding
+ *
+ * @description
+ * Marks the user's onboarding process as complete.
+ * This is typically called after a user completes all required onboarding steps
+ * (e.g., setting up profile, selecting interests, setting sober date).
+ * Updates the user's onboardingCompleted flag and unlocks full app access.
+ *
+ * @endpoint POST /api/v1/users/me/complete-onboarding
+ *
+ * @example
+ * ```tsx
+ * import { useCompleteOnboarding } from '@growsober/sdk';
+ *
+ * function OnboardingFinalStep() {
+ *   const { mutate: completeOnboarding, isPending } = useCompleteOnboarding({
+ *     onSuccess: () => {
+ *       toast.success('Welcome to GrowSober!');
+ *       navigation.navigate('Home');
+ *     },
+ *     onError: (error) => {
+ *       toast.error('Failed to complete onboarding: ' + error.message);
+ *     },
+ *   });
+ *
+ *   const handleFinish = () => {
+ *     completeOnboarding();
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <h1>You're All Set!</h1>
+ *       <p>Ready to start your sober journey?</p>
+ *       <button onClick={handleFinish} disabled={isPending}>
+ *         {isPending ? 'Setting up...' : 'Get Started'}
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Multi-step onboarding with validation:
+ * ```tsx
+ * function OnboardingFlow() {
+ *   const [currentStep, setCurrentStep] = useState(1);
+ *   const { mutateAsync: completeOnboarding } = useCompleteOnboarding();
+ *   const { data: user } = useCurrentUser();
+ *
+ *   const handleComplete = async () => {
+ *     // Validate all required fields are filled
+ *     if (!user?.name || !user?.soberDate || !user?.city) {
+ *       toast.error('Please complete all required fields');
+ *       return;
+ *     }
+ *
+ *     try {
+ *       await completeOnboarding();
+ *       // User will be redirected via onSuccess callback
+ *     } catch (error) {
+ *       console.error('Onboarding error:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {currentStep === 1 && <ProfileSetup onNext={() => setCurrentStep(2)} />}
+ *       {currentStep === 2 && <InterestSelection onNext={() => setCurrentStep(3)} />}
+ *       {currentStep === 3 && <SoberDateSetup onNext={handleComplete} />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * Check onboarding status:
+ * ```tsx
+ * function AppNavigator() {
+ *   const { data: user, isLoading } = useCurrentUser();
+ *
+ *   if (isLoading) return <SplashScreen />;
+ *
+ *   // Redirect to onboarding if not completed
+ *   if (user && !user.onboardingCompleted) {
+ *     return <OnboardingFlow />;
+ *   }
+ *
+ *   return <MainApp />;
+ * }
+ * ```
+ *
+ * @example
+ * With analytics tracking:
+ * ```tsx
+ * const { mutate: completeOnboarding } = useCompleteOnboarding({
+ *   onSuccess: (data) => {
+ *     analytics.track('Onboarding Completed', {
+ *       userId: data.id,
+ *       completedAt: new Date().toISOString(),
+ *       profileComplete: !!data.bio && !!data.avatar,
+ *     });
+ *     navigation.navigate('Home');
+ *   },
+ * });
+ * ```
+ *
+ * @param options - TanStack Query mutation options
+ * @returns TanStack Query mutation result
+ */
+export declare function useCompleteOnboarding(options?: Omit<UseMutationOptions<UserResponse, Error, void>, 'mutationFn'>): UseMutationResult<UserResponse, Error, void>;