@growsober/sdk 1.0.0

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

@@ -0,0 +1,61 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+export interface ChatRequest {
+    message: string;
+    conversationId?: string;
+}
+export interface ChatResponse {
+    message: string;
+    conversationId: string;
+    messageId: string;
+}
+export interface NewConversationResponse {
+    conversationId: string;
+}
+/**
+ * Send a message to Jack and get a response
+ *
+ * @example
+ * ```tsx
+ * const chatMutation = useChatWithJack();
+ *
+ * const handleSend = async (message: string) => {
+ *   const response = await chatMutation.mutateAsync({
+ *     message,
+ *     conversationId: currentConversationId, // optional
+ *   });
+ *   console.log('Jack says:', response.message);
+ * };
+ * ```
+ */
+export declare function useChatWithJack(options?: Omit<UseMutationOptions<ChatResponse, Error, ChatRequest>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<ChatResponse, Error, ChatRequest, unknown>;
+/**
+ * Start a new conversation with Jack
+ *
+ * @example
+ * ```tsx
+ * const newConversation = useStartJackConversation();
+ *
+ * const handleNewChat = async () => {
+ *   const { conversationId } = await newConversation.mutateAsync();
+ *   setCurrentConversationId(conversationId);
+ * };
+ * ```
+ */
+export declare function useStartJackConversation(options?: Omit<UseMutationOptions<NewConversationResponse, Error, void>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<NewConversationResponse, Error, void, unknown>;
+/**
+ * Archive a conversation with Jack
+ *
+ * @example
+ * ```tsx
+ * const archiveConversation = useArchiveJackConversation();
+ *
+ * const handleArchive = async (conversationId: string) => {
+ *   await archiveConversation.mutateAsync(conversationId);
+ * };
+ * ```
+ */
+export declare function useArchiveJackConversation(options?: Omit<UseMutationOptions<{
+    success: boolean;
+}, Error, string>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<{
+    success: boolean;
+}, Error, string, unknown>;

package/dist/api/mutations/jack.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useChatWithJack = useChatWithJack;
+exports.useStartJackConversation = useStartJackConversation;
+exports.useArchiveJackConversation = useArchiveJackConversation;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const jack_1 = require("../queries/jack");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Send a message to Jack and get a response
+ *
+ * @example
+ * ```tsx
+ * const chatMutation = useChatWithJack();
+ *
+ * const handleSend = async (message: string) => {
+ *   const response = await chatMutation.mutateAsync({
+ *     message,
+ *     conversationId: currentConversationId, // optional
+ *   });
+ *   console.log('Jack says:', response.message);
+ * };
+ * ```
+ */
+function useChatWithJack(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/jack/chat', data);
+            // API wraps response in { data: {...}, meta: {...} }
+            return response.data?.data || response.data;
+        },
+        onSuccess: (data) => {
+            // Invalidate conversation queries to refresh the list
+            queryClient.invalidateQueries({ queryKey: jack_1.jackKeys.conversations() });
+            queryClient.invalidateQueries({ queryKey: jack_1.jackKeys.history() });
+            if (data.conversationId) {
+                queryClient.invalidateQueries({ queryKey: jack_1.jackKeys.conversation(data.conversationId) });
+            }
+        },
+        ...options,
+    });
+}
+/**
+ * Start a new conversation with Jack
+ *
+ * @example
+ * ```tsx
+ * const newConversation = useStartJackConversation();
+ *
+ * const handleNewChat = async () => {
+ *   const { conversationId } = await newConversation.mutateAsync();
+ *   setCurrentConversationId(conversationId);
+ * };
+ * ```
+ */
+function useStartJackConversation(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/support/jack/conversations/new');
+            // API wraps response in { data: {...}, meta: {...} }
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: jack_1.jackKeys.conversations() });
+        },
+        ...options,
+    });
+}
+/**
+ * Archive a conversation with Jack
+ *
+ * @example
+ * ```tsx
+ * const archiveConversation = useArchiveJackConversation();
+ *
+ * const handleArchive = async (conversationId: string) => {
+ *   await archiveConversation.mutateAsync(conversationId);
+ * };
+ * ```
+ */
+function useArchiveJackConversation(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (conversationId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.delete(`/api/v1/support/jack/conversations/${conversationId}`);
+            // API wraps response in { data: {...}, meta: {...} }
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: jack_1.jackKeys.conversations() });
+            queryClient.invalidateQueries({ queryKey: jack_1.jackKeys.history() });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jack.js","sourceRoot":"","sources":["../../../src/api/mutations/jack.ts"],"names":[],"mappings":";;AA2CA,0CAsBC;AAeD,4DAiBC;AAcD,gEAkBC;AAjID,uDAAwF;AACxF,sCAAyC;AACzC,0CAA2C;AAqB3C,+EAA+E;AAC/E,iBAAiB;AACjB,+EAA+E;AAE/E;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,eAAe,CAC7B,OAAkF;IAElF,MAAM,WAAW,GAAG,IAAA,4BAAc,GAAE,CAAC;IAErC,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,EAAE,IAAiB,EAAyB,EAAE;YAC7D,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,IAAI,CAAC,CAAC;YACtE,qDAAqD;YACrD,OAAO,QAAQ,CAAC,IAAI,EAAE,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC;QAC9C,CAAC;QACD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;YAClB,sDAAsD;YACtD,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,eAAQ,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;YACtE,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,eAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YAChE,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;gBACxB,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,eAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;YAC1F,CAAC;QACH,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,wBAAwB,CACtC,OAAsF;IAEtF,MAAM,WAAW,GAAG,IAAA,4BAAc,GAAE,CAAC;IAErC,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,IAAsC,EAAE;YACvD,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;YAC7E,qDAAqD;YACrD,OAAO,QAAQ,CAAC,IAAI,EAAE,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC;QAC9C,CAAC;QACD,SAAS,EAAE,GAAG,EAAE;YACd,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,eAAQ,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;QACxE,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,0BAA0B,CACxC,OAAqF;IAErF,MAAM,WAAW,GAAG,IAAA,4BAAc,GAAE,CAAC;IAErC,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,EAAE,cAAsB,EAAiC,EAAE;YAC1E,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,sCAAsC,cAAc,EAAE,CAAC,CAAC;YAC7F,qDAAqD;YACrD,OAAO,QAAQ,CAAC,IAAI,EAAE,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC;QAC9C,CAAC;QACD,SAAS,EAAE,GAAG,EAAE;YACd,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,eAAQ,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;YACtE,WAAW,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,eAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAClE,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { useMutation, useQueryClient, UseMutationOptions } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { jackKeys } from '../queries/jack';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport interface ChatRequest {\n  message: string;\n  conversationId?: string;\n}\n\nexport interface ChatResponse {\n  message: string;\n  conversationId: string;\n  messageId: string;\n}\n\nexport interface NewConversationResponse {\n  conversationId: string;\n}\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Send a message to Jack and get a response\n *\n * @example\n * ```tsx\n * const chatMutation = useChatWithJack();\n *\n * const handleSend = async (message: string) => {\n *   const response = await chatMutation.mutateAsync({\n *     message,\n *     conversationId: currentConversationId, // optional\n *   });\n *   console.log('Jack says:', response.message);\n * };\n * ```\n */\nexport function useChatWithJack(\n  options?: Omit<UseMutationOptions<ChatResponse, Error, ChatRequest>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: ChatRequest): Promise<ChatResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/support/jack/chat', data);\n      // API wraps response in { data: {...}, meta: {...} }\n      return response.data?.data || response.data;\n    },\n    onSuccess: (data) => {\n      // Invalidate conversation queries to refresh the list\n      queryClient.invalidateQueries({ queryKey: jackKeys.conversations() });\n      queryClient.invalidateQueries({ queryKey: jackKeys.history() });\n      if (data.conversationId) {\n        queryClient.invalidateQueries({ queryKey: jackKeys.conversation(data.conversationId) });\n      }\n    },\n    ...options,\n  });\n}\n\n/**\n * Start a new conversation with Jack\n *\n * @example\n * ```tsx\n * const newConversation = useStartJackConversation();\n *\n * const handleNewChat = async () => {\n *   const { conversationId } = await newConversation.mutateAsync();\n *   setCurrentConversationId(conversationId);\n * };\n * ```\n */\nexport function useStartJackConversation(\n  options?: Omit<UseMutationOptions<NewConversationResponse, Error, void>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (): Promise<NewConversationResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/support/jack/conversations/new');\n      // API wraps response in { data: {...}, meta: {...} }\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: jackKeys.conversations() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Archive a conversation with Jack\n *\n * @example\n * ```tsx\n * const archiveConversation = useArchiveJackConversation();\n *\n * const handleArchive = async (conversationId: string) => {\n *   await archiveConversation.mutateAsync(conversationId);\n * };\n * ```\n */\nexport function useArchiveJackConversation(\n  options?: Omit<UseMutationOptions<{ success: boolean }, Error, string>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (conversationId: string): Promise<{ success: boolean }> => {\n      const client = getApiClient();\n      const response = await client.delete(`/api/v1/support/jack/conversations/${conversationId}`);\n      // API wraps response in { data: {...}, meta: {...} }\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: jackKeys.conversations() });\n      queryClient.invalidateQueries({ queryKey: jackKeys.history() });\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,67 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { LibraryProgressResponse } from '../types';
+/**
+ * Mark a library item as viewed
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useMarkViewed();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+export declare function useMarkViewed(options?: Omit<UseMutationOptions<LibraryProgressResponse, Error, string>, 'mutationFn'>): UseMutationResult<LibraryProgressResponse, Error, string>;
+/**
+ * Mark a library item as completed
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useMarkCompleted();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+export declare function useMarkCompleted(options?: Omit<UseMutationOptions<LibraryProgressResponse, Error, string>, 'mutationFn'>): UseMutationResult<LibraryProgressResponse, Error, string>;
+/**
+ * Toggle like status for a library item
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useToggleLike();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+export declare function useToggleLike(options?: Omit<UseMutationOptions<LibraryProgressResponse, Error, string>, 'mutationFn'>): UseMutationResult<LibraryProgressResponse, Error, string>;
+/**
+ * Add a bookmark to a library item
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useAddBookmark();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+export declare function useAddBookmark(options?: Omit<UseMutationOptions<LibraryProgressResponse, Error, string>, 'mutationFn'>): UseMutationResult<LibraryProgressResponse, Error, string>;
+/**
+ * Remove a bookmark from a library item
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useRemoveBookmark();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+export declare function useRemoveBookmark(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;

package/dist/api/mutations/library.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarkViewed = useMarkViewed;
+exports.useMarkCompleted = useMarkCompleted;
+exports.useToggleLike = useToggleLike;
+exports.useAddBookmark = useAddBookmark;
+exports.useRemoveBookmark = useRemoveBookmark;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const library_1 = require("../queries/library");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Mark a library item as viewed
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useMarkViewed();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+function useMarkViewed(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/library/${id}/view`);
+            return response.data;
+        },
+        onSuccess: (data, id, context) => {
+            // Invalidate the specific item to reflect updated view status
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.detail(id) });
+            // Invalidate lists to update view counts
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.lists() });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Mark a library item as completed
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useMarkCompleted();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+function useMarkCompleted(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/library/${id}/complete`);
+            return response.data;
+        },
+        onSuccess: (data, id, context) => {
+            // Invalidate the specific item to reflect completion status
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.detail(id) });
+            // Invalidate lists
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.lists() });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Toggle like status for a library item
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useToggleLike();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+function useToggleLike(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/library/${id}/like`);
+            return response.data;
+        },
+        onSuccess: (data, id, context) => {
+            // Invalidate the specific item to reflect like status
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.detail(id) });
+            // Invalidate lists to update like counts
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.lists() });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Add a bookmark to a library item
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useAddBookmark();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+function useAddBookmark(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/library/${id}/bookmark`);
+            return response.data;
+        },
+        onSuccess: (data, id, context) => {
+            // Invalidate the specific item to reflect bookmark status
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.detail(id) });
+            // Invalidate lists
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.lists() });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Remove a bookmark from a library item
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useRemoveBookmark();
+ *
+ * mutate('lib-123');
+ * ```
+ */
+function useRemoveBookmark(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/library/${id}/bookmark`);
+        },
+        onSuccess: (data, id, context) => {
+            // Invalidate the specific item to reflect bookmark removal
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.detail(id) });
+            // Invalidate lists
+            queryClient.invalidateQueries({ queryKey: library_1.libraryKeys.lists() });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"library.js","sourceRoot":"","sources":["../../../src/api/mutations/library.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 { LibraryProgressResponse } from '../types';\nimport { libraryKeys } from '../queries/library';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Mark a library item as viewed\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useMarkViewed();\n *\n * mutate('lib-123');\n * ```\n */\nexport function useMarkViewed(\n  options?: Omit<\n    UseMutationOptions<LibraryProgressResponse, Error, string>,\n    'mutationFn'\n  >\n): UseMutationResult<LibraryProgressResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<LibraryProgressResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/library/${id}/view`);\n      return response.data;\n    },\n    onSuccess: (data, id, context) => {\n      // Invalidate the specific item to reflect updated view status\n      queryClient.invalidateQueries({ queryKey: libraryKeys.detail(id) });\n\n      // Invalidate lists to update view counts\n      queryClient.invalidateQueries({ queryKey: libraryKeys.lists() });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Mark a library item as completed\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useMarkCompleted();\n *\n * mutate('lib-123');\n * ```\n */\nexport function useMarkCompleted(\n  options?: Omit<\n    UseMutationOptions<LibraryProgressResponse, Error, string>,\n    'mutationFn'\n  >\n): UseMutationResult<LibraryProgressResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<LibraryProgressResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/library/${id}/complete`);\n      return response.data;\n    },\n    onSuccess: (data, id, context) => {\n      // Invalidate the specific item to reflect completion status\n      queryClient.invalidateQueries({ queryKey: libraryKeys.detail(id) });\n\n      // Invalidate lists\n      queryClient.invalidateQueries({ queryKey: libraryKeys.lists() });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Toggle like status for a library item\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useToggleLike();\n *\n * mutate('lib-123');\n * ```\n */\nexport function useToggleLike(\n  options?: Omit<\n    UseMutationOptions<LibraryProgressResponse, Error, string>,\n    'mutationFn'\n  >\n): UseMutationResult<LibraryProgressResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<LibraryProgressResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/library/${id}/like`);\n      return response.data;\n    },\n    onSuccess: (data, id, context) => {\n      // Invalidate the specific item to reflect like status\n      queryClient.invalidateQueries({ queryKey: libraryKeys.detail(id) });\n\n      // Invalidate lists to update like counts\n      queryClient.invalidateQueries({ queryKey: libraryKeys.lists() });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Add a bookmark to a library item\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useAddBookmark();\n *\n * mutate('lib-123');\n * ```\n */\nexport function useAddBookmark(\n  options?: Omit<\n    UseMutationOptions<LibraryProgressResponse, Error, string>,\n    'mutationFn'\n  >\n): UseMutationResult<LibraryProgressResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<LibraryProgressResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/library/${id}/bookmark`);\n      return response.data;\n    },\n    onSuccess: (data, id, context) => {\n      // Invalidate the specific item to reflect bookmark status\n      queryClient.invalidateQueries({ queryKey: libraryKeys.detail(id) });\n\n      // Invalidate lists\n      queryClient.invalidateQueries({ queryKey: libraryKeys.lists() });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Remove a bookmark from a library item\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate, isPending } = useRemoveBookmark();\n *\n * mutate('lib-123');\n * ```\n */\nexport function useRemoveBookmark(\n  options?: Omit<\n    UseMutationOptions<void, Error, string>,\n    'mutationFn'\n  >\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/library/${id}/bookmark`);\n    },\n    onSuccess: (data, id, context) => {\n      // Invalidate the specific item to reflect bookmark removal\n      queryClient.invalidateQueries({ queryKey: libraryKeys.detail(id) });\n\n      // Invalidate lists\n      queryClient.invalidateQueries({ queryKey: libraryKeys.lists() });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,153 @@
+/**
+ * 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
+ */
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+export interface UpdateLocationRequest {
+    lat: number;
+    lng: number;
+}
+export interface UpdateOpenToMeetRequest {
+    openToMeet: boolean;
+}
+export interface LocationUpdateResponse {
+    success: boolean;
+    message: string;
+}
+export interface OpenToMeetResponse {
+    openToMeet: boolean;
+    message: string;
+}
+/**
+ * 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
+ */
+export declare function useUpdateLocation(options?: Omit<UseMutationOptions<LocationUpdateResponse, Error, UpdateLocationRequest>, 'mutationFn'>): UseMutationResult<LocationUpdateResponse, Error, UpdateLocationRequest>;
+/**
+ * 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
+ */
+export declare function useUpdateOpenToMeet(options?: Omit<UseMutationOptions<OpenToMeetResponse, Error, UpdateOpenToMeetRequest>, 'mutationFn'>): UseMutationResult<OpenToMeetResponse, Error, UpdateOpenToMeetRequest>;