@growsober/sdk 1.0.0

package/dist/api/mutations/notifications.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMarkNotificationRead = useMarkNotificationRead;
+exports.useMarkAllNotificationsRead = useMarkAllNotificationsRead;
+exports.useDeleteNotification = useDeleteNotification;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const notifications_1 = require("../queries/notifications");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Mark a notification as read
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: markAsRead } = useMarkNotificationRead();
+ *
+ * const handleNotificationClick = (notificationId: string) => {
+ *   markAsRead(notificationId);
+ * };
+ * ```
+ */
+function useMarkNotificationRead(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.patch(`/api/v1/notifications/${id}/read`);
+            return response.data;
+        },
+        onSuccess: (data, id, context) => {
+            // Update notification in cache
+            queryClient.setQueryData(notifications_1.notificationKeys.detail(id), data);
+            // Invalidate lists to refetch
+            queryClient.invalidateQueries({ queryKey: notifications_1.notificationKeys.list() });
+            queryClient.invalidateQueries({ queryKey: notifications_1.notificationKeys.unreadCount() });
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Mark all notifications as read
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: markAllRead, isPending } = useMarkAllNotificationsRead();
+ *
+ * const handleMarkAllRead = () => {
+ *   markAllRead();
+ * };
+ * ```
+ */
+function useMarkAllNotificationsRead(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            await client.patch('/api/v1/notifications/read-all');
+        },
+        onSuccess: (data, variables, context) => {
+            // Invalidate all notification queries
+            queryClient.invalidateQueries({ queryKey: notifications_1.notificationKeys.all });
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a notification
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: deleteNotification } = useDeleteNotification();
+ *
+ * const handleDelete = (notificationId: string) => {
+ *   deleteNotification(notificationId);
+ * };
+ * ```
+ */
+function useDeleteNotification(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/notifications/${id}`);
+        },
+        onSuccess: (data, id, context) => {
+            // Remove from cache
+            queryClient.removeQueries({ queryKey: notifications_1.notificationKeys.detail(id) });
+            // Invalidate lists to refetch
+            queryClient.invalidateQueries({ queryKey: notifications_1.notificationKeys.list() });
+            queryClient.invalidateQueries({ queryKey: notifications_1.notificationKeys.unreadCount() });
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { OfferResponse, RedeemOfferRequest } from '../types';
+/**
+ * Redeem an offer
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useRedeemOffer();
+ *
+ * mutate({
+ *   id: 'offer-123',
+ *   data: {
+ *     // Add any required fields from RedeemOfferRequest
+ *   }
+ * });
+ * ```
+ */
+export declare function useRedeemOffer(options?: Omit<UseMutationOptions<OfferResponse, Error, {
+    id: string;
+    data?: RedeemOfferRequest;
+}>, 'mutationFn'>): UseMutationResult<OfferResponse, Error, {
+    id: string;
+    data?: RedeemOfferRequest;
+}>;

package/dist/api/mutations/offers.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRedeemOffer = useRedeemOffer;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const offers_1 = require("../queries/offers");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Redeem an offer
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useRedeemOffer();
+ *
+ * mutate({
+ *   id: 'offer-123',
+ *   data: {
+ *     // Add any required fields from RedeemOfferRequest
+ *   }
+ * });
+ * ```
+ */
+function useRedeemOffer(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.post(`/api/v1/offers/${id}/redeem`, data);
+            return response.data;
+        },
+        onSuccess: (redeemedOffer, variables, context) => {
+            // Update the specific offer in cache
+            queryClient.setQueryData(offers_1.offerKeys.detail(variables.id), redeemedOffer);
+            // Invalidate the can-redeem check for this offer
+            queryClient.invalidateQueries({ queryKey: offers_1.offerKeys.canRedeem(variables.id) });
+            // Invalidate offer lists to reflect redemption counts
+            queryClient.invalidateQueries({ queryKey: offers_1.offerKeys.lists() });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,127 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { CreateCheckoutRequest, SubscriptionResponse } from '../types';
+export interface CheckoutSession {
+    sessionId: string;
+    url: string;
+}
+export interface CustomerPortalSession {
+    url: string;
+}
+/**
+ * Create a Stripe checkout session for subscription
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: createCheckout, isPending } = useCreateCheckout();
+ *
+ * const handleUpgrade = () => {
+ *   createCheckout(
+ *     { tier: 'PREMIUM', successUrl: '/success', cancelUrl: '/cancel' },
+ *     {
+ *       onSuccess: (session) => {
+ *         window.location.href = session.url;
+ *       },
+ *     }
+ *   );
+ * };
+ * ```
+ */
+export declare function useCreateCheckout(options?: Omit<UseMutationOptions<CheckoutSession, Error, CreateCheckoutRequest>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<CheckoutSession, Error, {
+    tier: "FREE" | "PREMIUM";
+    successUrl?: string;
+    cancelUrl?: string;
+    priceId?: string;
+}, unknown>;
+/**
+ * Get Stripe customer portal URL for managing subscription
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: getPortal, isPending } = useCustomerPortal();
+ *
+ * const handleManageSubscription = () => {
+ *   getPortal(undefined, {
+ *     onSuccess: (session) => {
+ *       window.location.href = session.url;
+ *     },
+ *   });
+ * };
+ * ```
+ */
+export declare function useCustomerPortal(options?: Omit<UseMutationOptions<CustomerPortalSession, Error, void>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<CustomerPortalSession, Error, void, unknown>;
+/**
+ * Cancel current subscription
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: cancelSubscription, isPending } = useCancelSubscription();
+ *
+ * const handleCancel = () => {
+ *   cancelSubscription(undefined, {
+ *     onSuccess: () => {
+ *       // Subscription will be cancelled at period end
+ *     },
+ *   });
+ * };
+ * ```
+ */
+export declare function useCancelSubscription(options?: Omit<UseMutationOptions<SubscriptionResponse, Error, void>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    userId: string;
+    tier: "FREE" | "PREMIUM";
+    status: "ACTIVE" | "TRIALING" | "PAST_DUE" | "CANCELLED" | "PAUSED";
+    stripeCustomerId?: Record<string, never>;
+    stripeSubscriptionId?: Record<string, never>;
+    stripePriceId?: Record<string, never>;
+    currentPeriodStart?: Record<string, never>;
+    currentPeriodEnd?: Record<string, never>;
+    cancelAtPeriodEnd: boolean;
+    cancelledAt?: Record<string, never>;
+    trialStart?: Record<string, never>;
+    trialEnd?: Record<string, never>;
+    hadTrial: boolean;
+    createdAt: string;
+    updatedAt: string;
+}, Error, void, unknown>;
+/**
+ * Resume a cancelled subscription (before period end)
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: resumeSubscription, isPending } = useResumeSubscription();
+ *
+ * const handleResume = () => {
+ *   resumeSubscription(undefined, {
+ *     onSuccess: () => {
+ *       // Subscription resumed
+ *     },
+ *   });
+ * };
+ * ```
+ */
+export declare function useResumeSubscription(options?: Omit<UseMutationOptions<SubscriptionResponse, Error, void>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    userId: string;
+    tier: "FREE" | "PREMIUM";
+    status: "ACTIVE" | "TRIALING" | "PAST_DUE" | "CANCELLED" | "PAUSED";
+    stripeCustomerId?: Record<string, never>;
+    stripeSubscriptionId?: Record<string, never>;
+    stripePriceId?: Record<string, never>;
+    currentPeriodStart?: Record<string, never>;
+    currentPeriodEnd?: Record<string, never>;
+    cancelAtPeriodEnd: boolean;
+    cancelledAt?: Record<string, never>;
+    trialStart?: Record<string, never>;
+    trialEnd?: Record<string, never>;
+    hadTrial: boolean;
+    createdAt: string;
+    updatedAt: string;
+}, Error, void, unknown>;

package/dist/api/mutations/subscriptions.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateCheckout = useCreateCheckout;
+exports.useCustomerPortal = useCustomerPortal;
+exports.useCancelSubscription = useCancelSubscription;
+exports.useResumeSubscription = useResumeSubscription;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const subscriptions_1 = require("../queries/subscriptions");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Create a Stripe checkout session for subscription
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: createCheckout, isPending } = useCreateCheckout();
+ *
+ * const handleUpgrade = () => {
+ *   createCheckout(
+ *     { tier: 'PREMIUM', successUrl: '/success', cancelUrl: '/cancel' },
+ *     {
+ *       onSuccess: (session) => {
+ *         window.location.href = session.url;
+ *       },
+ *     }
+ *   );
+ * };
+ * ```
+ */
+function useCreateCheckout(options) {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/subscriptions/checkout', data);
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Get Stripe customer portal URL for managing subscription
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: getPortal, isPending } = useCustomerPortal();
+ *
+ * const handleManageSubscription = () => {
+ *   getPortal(undefined, {
+ *     onSuccess: (session) => {
+ *       window.location.href = session.url;
+ *     },
+ *   });
+ * };
+ * ```
+ */
+function useCustomerPortal(options) {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/subscriptions/portal');
+            return response.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Cancel current subscription
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: cancelSubscription, isPending } = useCancelSubscription();
+ *
+ * const handleCancel = () => {
+ *   cancelSubscription(undefined, {
+ *     onSuccess: () => {
+ *       // Subscription will be cancelled at period end
+ *     },
+ *   });
+ * };
+ * ```
+ */
+function useCancelSubscription(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/subscriptions/cancel');
+            return response.data;
+        },
+        onSuccess: (data, variables, context) => {
+            // Update subscription in cache
+            queryClient.setQueryData(subscriptions_1.subscriptionKeys.mine(), data);
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Resume a cancelled subscription (before period end)
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate: resumeSubscription, isPending } = useResumeSubscription();
+ *
+ * const handleResume = () => {
+ *   resumeSubscription(undefined, {
+ *     onSuccess: () => {
+ *       // Subscription resumed
+ *     },
+ *   });
+ * };
+ * ```
+ */
+function useResumeSubscription(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/subscriptions/resume');
+            return response.data;
+        },
+        onSuccess: (data, variables, context) => {
+            // Update subscription in cache
+            queryClient.setQueryData(subscriptions_1.subscriptionKeys.mine(), data);
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscriptions.js","sourceRoot":"","sources":["../../../src/api/mutations/subscriptions.ts"],"names":[],"mappings":";;AA2CA,8CAWC;AAoBD,8CAWC;AAoBD,sDAkBC;AAoBD,sDAkBC;AAjKD,uDAAwF;AACxF,sCAAyC;AACzC,4DAA4D;AAgB5D,+EAA+E;AAC/E,iBAAiB;AACjB,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,iBAAiB,CAC/B,OAA+F;IAE/F,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,EAAE,IAA2B,EAA4B,EAAE;YAC1E,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,gCAAgC,EAAE,IAAI,CAAC,CAAC;YAC3E,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,iBAAiB,CAC/B,OAAoF;IAEpF,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,IAAoC,EAAE;YACrD,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;YACnE,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,qBAAqB,CACnC,OAAmF;IAEnF,MAAM,WAAW,GAAG,IAAA,4BAAc,GAAE,CAAC;IAErC,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,IAAmC,EAAE;YACpD,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;YACnE,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;QACD,SAAS,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;YACtC,+BAA+B;YAC/B,WAAW,CAAC,YAAY,CAAC,gCAAgB,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;YACxD,mDAAmD;QACrD,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,qBAAqB,CACnC,OAAmF;IAEnF,MAAM,WAAW,GAAG,IAAA,4BAAc,GAAE,CAAC;IAErC,OAAO,IAAA,yBAAW,EAAC;QACjB,UAAU,EAAE,KAAK,IAAmC,EAAE;YACpD,MAAM,MAAM,GAAG,IAAA,qBAAY,GAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;YACnE,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;QACD,SAAS,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;YACtC,+BAA+B;YAC/B,WAAW,CAAC,YAAY,CAAC,gCAAgB,CAAC,IAAI,EAAE,EAAE,IAAI,CAAC,CAAC;YACxD,mDAAmD;QACrD,CAAC;QACD,GAAG,OAAO;KACX,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { useMutation, useQueryClient, UseMutationOptions } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { subscriptionKeys } from '../queries/subscriptions';\nimport type { CreateCheckoutRequest, SubscriptionResponse } from '../types';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport interface CheckoutSession {\n  sessionId: string;\n  url: string;\n}\n\nexport interface CustomerPortalSession {\n  url: string;\n}\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Create a Stripe checkout session for subscription\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate: createCheckout, isPending } = useCreateCheckout();\n *\n * const handleUpgrade = () => {\n *   createCheckout(\n *     { tier: 'PREMIUM', successUrl: '/success', cancelUrl: '/cancel' },\n *     {\n *       onSuccess: (session) => {\n *         window.location.href = session.url;\n *       },\n *     }\n *   );\n * };\n * ```\n */\nexport function useCreateCheckout(\n  options?: Omit<UseMutationOptions<CheckoutSession, Error, CreateCheckoutRequest>, 'mutationFn'>\n) {\n  return useMutation({\n    mutationFn: async (data: CreateCheckoutRequest): Promise<CheckoutSession> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/subscriptions/checkout', data);\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Get Stripe customer portal URL for managing subscription\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate: getPortal, isPending } = useCustomerPortal();\n *\n * const handleManageSubscription = () => {\n *   getPortal(undefined, {\n *     onSuccess: (session) => {\n *       window.location.href = session.url;\n *     },\n *   });\n * };\n * ```\n */\nexport function useCustomerPortal(\n  options?: Omit<UseMutationOptions<CustomerPortalSession, Error, void>, 'mutationFn'>\n) {\n  return useMutation({\n    mutationFn: async (): Promise<CustomerPortalSession> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/subscriptions/portal');\n      return response.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Cancel current subscription\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate: cancelSubscription, isPending } = useCancelSubscription();\n *\n * const handleCancel = () => {\n *   cancelSubscription(undefined, {\n *     onSuccess: () => {\n *       // Subscription will be cancelled at period end\n *     },\n *   });\n * };\n * ```\n */\nexport function useCancelSubscription(\n  options?: Omit<UseMutationOptions<SubscriptionResponse, Error, void>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (): Promise<SubscriptionResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/subscriptions/cancel');\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Update subscription in cache\n      queryClient.setQueryData(subscriptionKeys.mine(), data);\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Resume a cancelled subscription (before period end)\n *\n * @param options - TanStack Query mutation options\n *\n * @example\n * ```tsx\n * const { mutate: resumeSubscription, isPending } = useResumeSubscription();\n *\n * const handleResume = () => {\n *   resumeSubscription(undefined, {\n *     onSuccess: () => {\n *       // Subscription resumed\n *     },\n *   });\n * };\n * ```\n */\nexport function useResumeSubscription(\n  options?: Omit<UseMutationOptions<SubscriptionResponse, Error, void>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (): Promise<SubscriptionResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/subscriptions/resume');\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Update subscription in cache\n      queryClient.setQueryData(subscriptionKeys.mine(), data);\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,165 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { DailyCheckInResponse, CreateCheckInRequest, UpdateCheckInRequest, MoodLogResponse, CreateMoodLogRequest, WinResponse, CreateWinRequest, HabitResponse, CreateHabitRequest, UpdateHabitRequest, ReflectionResponse, CreateReflectionRequest } from '../types';
+/**
+ * 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']
+ * });
+ * ```
+ */
+export declare function useCreateCheckIn(options?: Omit<UseMutationOptions<DailyCheckInResponse, Error, CreateCheckInRequest>, 'mutationFn'>): UseMutationResult<DailyCheckInResponse, Error, CreateCheckInRequest>;
+/**
+ * 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',
+ *   }
+ * });
+ * ```
+ */
+export declare function useUpdateCheckIn(options?: Omit<UseMutationOptions<DailyCheckInResponse, Error, {
+    id: string;
+    data: UpdateCheckInRequest;
+}>, 'mutationFn'>): UseMutationResult<DailyCheckInResponse, Error, {
+    id: string;
+    data: UpdateCheckInRequest;
+}>;
+/**
+ * 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']
+ * });
+ * ```
+ */
+export declare function useCreateMoodLog(options?: Omit<UseMutationOptions<MoodLogResponse, Error, CreateMoodLogRequest>, 'mutationFn'>): UseMutationResult<MoodLogResponse, Error, CreateMoodLogRequest>;
+/**
+ * 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'
+ * });
+ * ```
+ */
+export declare function useCreateWin(options?: Omit<UseMutationOptions<WinResponse, Error, CreateWinRequest>, 'mutationFn'>): UseMutationResult<WinResponse, Error, CreateWinRequest>;
+/**
+ * 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
+ * });
+ * ```
+ */
+export declare function useCreateHabit(options?: Omit<UseMutationOptions<HabitResponse, Error, CreateHabitRequest>, 'mutationFn'>): UseMutationResult<HabitResponse, Error, CreateHabitRequest>;
+/**
+ * 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
+ *   }
+ * });
+ * ```
+ */
+export declare function useUpdateHabit(options?: Omit<UseMutationOptions<HabitResponse, Error, {
+    id: string;
+    data: UpdateHabitRequest;
+}>, 'mutationFn'>): UseMutationResult<HabitResponse, Error, {
+    id: string;
+    data: UpdateHabitRequest;
+}>;
+/**
+ * Delete a habit
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useDeleteHabit();
+ *
+ * mutate('habit-123');
+ * ```
+ */
+export declare function useDeleteHabit(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
+/**
+ * Complete a habit for today
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCompleteHabit();
+ *
+ * mutate('habit-123');
+ * ```
+ */
+export declare function useCompleteHabit(options?: Omit<UseMutationOptions<HabitResponse, Error, string>, 'mutationFn'>): UseMutationResult<HabitResponse, Error, string>;
+/**
+ * Create a reflection
+ *
+ * @param options - TanStack Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const { mutate, isPending } = useCreateReflection();
+ *
+ * mutate({
+ *   content: 'Today I learned...',
+ *   category: 'growth',
+ *   mood: 8
+ * });
+ * ```
+ */
+export declare function useCreateReflection(options?: Omit<UseMutationOptions<ReflectionResponse, Error, CreateReflectionRequest>, 'mutationFn'>): UseMutationResult<ReflectionResponse, Error, CreateReflectionRequest>;