@growsober/sdk 1.0.9 → 1.0.11

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

@@ -113,4 +113,93 @@ export declare function useUpdatePartnerReward(businessId: string, options?: Omi
         isActive: boolean;
     }>;
 }, unknown>;
+interface UpdateRewardRequest {
+    isActive?: boolean;
+    title?: string;
+    description?: string;
+    code?: string;
+    redeemType?: 'IN_PERSON' | 'ONLINE' | 'BOTH';
+    maxRedemptions?: number;
+    perUserLimit?: number;
+    validFrom?: string;
+    validUntil?: string;
+}
+/**
+ * Update a venue reward
+ *
+ * @param venueId - Venue ID
+ *
+ * @example
+ * ```tsx
+ * const updateReward = useUpdateVenueReward('venue-123');
+ *
+ * const handleUpdate = async (rewardId: string) => {
+ *   await updateReward.mutateAsync({
+ *     id: rewardId,
+ *     data: { isActive: false },
+ *   });
+ * };
+ * ```
+ */
+export declare function useUpdateVenueReward(venueId: string, options?: Omit<UseMutationOptions<unknown, Error, {
+    id: string;
+    data: UpdateRewardRequest;
+}>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    id: string;
+    data: UpdateRewardRequest;
+}, unknown>;
+/**
+ * Delete a venue reward
+ *
+ * @param venueId - Venue ID
+ *
+ * @example
+ * ```tsx
+ * const deleteReward = useDeleteVenueReward('venue-123');
+ *
+ * const handleDelete = async (rewardId: string) => {
+ *   await deleteReward.mutateAsync(rewardId);
+ * };
+ * ```
+ */
+export declare function useDeleteVenueReward(venueId: string, options?: Omit<UseMutationOptions<unknown, Error, string>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
+/**
+ * Update a brand reward
+ *
+ * @param brandId - Brand ID
+ *
+ * @example
+ * ```tsx
+ * const updateReward = useUpdateBrandReward('brand-123');
+ *
+ * const handleUpdate = async (rewardId: string) => {
+ *   await updateReward.mutateAsync({
+ *     id: rewardId,
+ *     data: { isActive: false },
+ *   });
+ * };
+ * ```
+ */
+export declare function useUpdateBrandReward(brandId: string, options?: Omit<UseMutationOptions<unknown, Error, {
+    id: string;
+    data: UpdateRewardRequest;
+}>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    id: string;
+    data: UpdateRewardRequest;
+}, unknown>;
+/**
+ * Delete a brand reward
+ *
+ * @param brandId - Brand ID
+ *
+ * @example
+ * ```tsx
+ * const deleteReward = useDeleteBrandReward('brand-123');
+ *
+ * const handleDelete = async (rewardId: string) => {
+ *   await deleteReward.mutateAsync(rewardId);
+ * };
+ * ```
+ */
+export declare function useDeleteBrandReward(brandId: string, options?: Omit<UseMutationOptions<unknown, Error, string>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<unknown, Error, string, unknown>;
 export {};

package/dist/api/mutations/badges.js

@@ -5,6 +5,10 @@ exports.useCreatePartnerReward = useCreatePartnerReward;
 exports.useCreateVenueReward = useCreateVenueReward;
 exports.useCreateBrandReward = useCreateBrandReward;
 exports.useUpdatePartnerReward = useUpdatePartnerReward;
+exports.useUpdateVenueReward = useUpdateVenueReward;
+exports.useDeleteVenueReward = useDeleteVenueReward;
+exports.useUpdateBrandReward = useUpdateBrandReward;
+exports.useDeleteBrandReward = useDeleteBrandReward;
 const react_query_1 = require("@tanstack/react-query");
 const client_1 = require("../client");
 const badges_1 = require("../queries/badges");
@@ -174,4 +178,129 @@ function useUpdatePartnerReward(businessId, options) {
         ...options,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"badges.js","sourceRoot":"","sources":["../../../src/api/mutations/badges.ts"],"names":[],"mappings":"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","sourcesContent":["import { useMutation, useQueryClient, UseMutationOptions } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { badgeKeys, rewardKeys } from '../queries/badges';\nimport type {\n  PartnerRewardResponse,\n  PartnerRewardRedemptionResponse,\n  CreatePartnerRewardRequest,\n} from '../types';\n\n// ============================================================================\n// REWARD MUTATION HOOKS\n// ============================================================================\n\n/**\n * Redeem a partner reward\n *\n * @example\n * ```tsx\n * const redeemReward = useRedeemReward();\n *\n * const handleRedeem = async (rewardId: string) => {\n *   await redeemReward.mutateAsync(rewardId);\n *   // Show success message\n * };\n * ```\n */\nexport function useRedeemReward(\n  options?: Omit<UseMutationOptions<PartnerRewardRedemptionResponse, Error, string>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (rewardId: string): Promise<PartnerRewardRedemptionResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/rewards/${rewardId}/redeem`);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      // Invalidate wallet, available and redeemed rewards\n      queryClient.invalidateQueries({ queryKey: rewardKeys.wallet() });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.redeemed() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a partner reward (for business dashboard)\n *\n * @param businessId - Business ID creating the reward\n *\n * @example\n * ```tsx\n * const createReward = useCreatePartnerReward('business-123');\n *\n * const handleCreate = async () => {\n *   await createReward.mutateAsync({\n *     badgeId: 'badge-week-warrior',\n *     title: 'Free Coffee',\n *     description: 'Show your badge for a free coffee',\n *   });\n * };\n * ```\n */\nexport function useCreatePartnerReward(\n  businessId: string,\n  options?: Omit<UseMutationOptions<PartnerRewardResponse, Error, CreatePartnerRewardRequest>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreatePartnerRewardRequest): Promise<PartnerRewardResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/businesses/${businessId}/rewards`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBusiness(businessId) });\n    },\n    ...options,\n  });\n}\n\n// ============================================================================\n// UNIFIED REWARD MUTATIONS (Venue & Brand)\n// ============================================================================\n\ninterface CreateRewardRequest {\n  badgeId: string;\n  title: string;\n  description?: string;\n  code?: string;\n  redeemType?: 'IN_PERSON' | 'ONLINE' | 'BOTH';\n  maxRedemptions?: number;\n  perUserLimit?: number;\n  validFrom?: string;\n  validUntil?: string;\n}\n\n/**\n * Create a reward for a venue\n *\n * @param venueId - Venue ID\n *\n * @example\n * ```tsx\n * const createReward = useCreateVenueReward('venue-123');\n *\n * const handleCreate = async () => {\n *   await createReward.mutateAsync({\n *     badgeId: 'badge-week-warrior',\n *     title: 'Free Coffee',\n *     description: 'Show your badge for a free coffee',\n *     redeemType: 'IN_PERSON',\n *   });\n * };\n * ```\n */\nexport function useCreateVenueReward(\n  venueId: string,\n  options?: Omit<UseMutationOptions<unknown, Error, CreateRewardRequest>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateRewardRequest) => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/venues/${venueId}/rewards`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forVenue(venueId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a reward for a brand\n *\n * @param brandId - Brand ID\n *\n * @example\n * ```tsx\n * const createReward = useCreateBrandReward('brand-123');\n *\n * const handleCreate = async () => {\n *   await createReward.mutateAsync({\n *     badgeId: 'badge-week-warrior',\n *     title: '10% Off',\n *     description: 'Use code at checkout',\n *     code: 'SOBER10',\n *     redeemType: 'ONLINE',\n *   });\n * };\n * ```\n */\nexport function useCreateBrandReward(\n  brandId: string,\n  options?: Omit<UseMutationOptions<unknown, Error, CreateRewardRequest>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateRewardRequest) => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/brands/${brandId}/rewards`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBrand(brandId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update a partner reward (for business dashboard)\n *\n * @param businessId - Business ID\n *\n * @example\n * ```tsx\n * const updateReward = useUpdatePartnerReward('business-123');\n *\n * const handleUpdate = async (rewardId: string) => {\n *   await updateReward.mutateAsync({\n *     id: rewardId,\n *     data: { title: 'Updated Title', isActive: false },\n *   });\n * };\n * ```\n */\nexport function useUpdatePartnerReward(\n  businessId: string,\n  options?: Omit<\n    UseMutationOptions<\n      PartnerRewardResponse,\n      Error,\n      { id: string; data: Partial<CreatePartnerRewardRequest & { isActive: boolean }> }\n    >,\n    'mutationFn'\n  >\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      id,\n      data,\n    }: {\n      id: string;\n      data: Partial<CreatePartnerRewardRequest & { isActive: boolean }>;\n    }): Promise<PartnerRewardResponse> => {\n      const client = getApiClient();\n      const response = await client.patch(`/api/v1/businesses/${businessId}/rewards/${id}`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBusiness(businessId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n"]}
+/**
+ * Update a venue reward
+ *
+ * @param venueId - Venue ID
+ *
+ * @example
+ * ```tsx
+ * const updateReward = useUpdateVenueReward('venue-123');
+ *
+ * const handleUpdate = async (rewardId: string) => {
+ *   await updateReward.mutateAsync({
+ *     id: rewardId,
+ *     data: { isActive: false },
+ *   });
+ * };
+ * ```
+ */
+function useUpdateVenueReward(venueId, 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.patch(`/api/v1/venues/${venueId}/rewards/${id}`, data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.forVenue(venueId) });
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.available() });
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a venue reward
+ *
+ * @param venueId - Venue ID
+ *
+ * @example
+ * ```tsx
+ * const deleteReward = useDeleteVenueReward('venue-123');
+ *
+ * const handleDelete = async (rewardId: string) => {
+ *   await deleteReward.mutateAsync(rewardId);
+ * };
+ * ```
+ */
+function useDeleteVenueReward(venueId, options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (rewardId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.delete(`/api/v1/venues/${venueId}/rewards/${rewardId}`);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.forVenue(venueId) });
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.available() });
+        },
+        ...options,
+    });
+}
+// ============================================================================
+// BRAND REWARD MUTATIONS
+// ============================================================================
+/**
+ * Update a brand reward
+ *
+ * @param brandId - Brand ID
+ *
+ * @example
+ * ```tsx
+ * const updateReward = useUpdateBrandReward('brand-123');
+ *
+ * const handleUpdate = async (rewardId: string) => {
+ *   await updateReward.mutateAsync({
+ *     id: rewardId,
+ *     data: { isActive: false },
+ *   });
+ * };
+ * ```
+ */
+function useUpdateBrandReward(brandId, 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.patch(`/api/v1/brands/${brandId}/rewards/${id}`, data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.forBrand(brandId) });
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.available() });
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a brand reward
+ *
+ * @param brandId - Brand ID
+ *
+ * @example
+ * ```tsx
+ * const deleteReward = useDeleteBrandReward('brand-123');
+ *
+ * const handleDelete = async (rewardId: string) => {
+ *   await deleteReward.mutateAsync(rewardId);
+ * };
+ * ```
+ */
+function useDeleteBrandReward(brandId, options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (rewardId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.delete(`/api/v1/brands/${brandId}/rewards/${rewardId}`);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.forBrand(brandId) });
+            queryClient.invalidateQueries({ queryKey: badges_1.rewardKeys.available() });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"badges.js","sourceRoot":"","sources":["../../../src/api/mutations/badges.ts"],"names":[],"mappings":"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","sourcesContent":["import { useMutation, useQueryClient, UseMutationOptions } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { badgeKeys, rewardKeys } from '../queries/badges';\nimport type {\n  PartnerRewardResponse,\n  PartnerRewardRedemptionResponse,\n  CreatePartnerRewardRequest,\n} from '../types';\n\n// ============================================================================\n// REWARD MUTATION HOOKS\n// ============================================================================\n\n/**\n * Redeem a partner reward\n *\n * @example\n * ```tsx\n * const redeemReward = useRedeemReward();\n *\n * const handleRedeem = async (rewardId: string) => {\n *   await redeemReward.mutateAsync(rewardId);\n *   // Show success message\n * };\n * ```\n */\nexport function useRedeemReward(\n  options?: Omit<UseMutationOptions<PartnerRewardRedemptionResponse, Error, string>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (rewardId: string): Promise<PartnerRewardRedemptionResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/rewards/${rewardId}/redeem`);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      // Invalidate wallet, available and redeemed rewards\n      queryClient.invalidateQueries({ queryKey: rewardKeys.wallet() });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.redeemed() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a partner reward (for business dashboard)\n *\n * @param businessId - Business ID creating the reward\n *\n * @example\n * ```tsx\n * const createReward = useCreatePartnerReward('business-123');\n *\n * const handleCreate = async () => {\n *   await createReward.mutateAsync({\n *     badgeId: 'badge-week-warrior',\n *     title: 'Free Coffee',\n *     description: 'Show your badge for a free coffee',\n *   });\n * };\n * ```\n */\nexport function useCreatePartnerReward(\n  businessId: string,\n  options?: Omit<UseMutationOptions<PartnerRewardResponse, Error, CreatePartnerRewardRequest>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreatePartnerRewardRequest): Promise<PartnerRewardResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/businesses/${businessId}/rewards`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBusiness(businessId) });\n    },\n    ...options,\n  });\n}\n\n// ============================================================================\n// UNIFIED REWARD MUTATIONS (Venue & Brand)\n// ============================================================================\n\ninterface CreateRewardRequest {\n  badgeId: string;\n  title: string;\n  description?: string;\n  code?: string;\n  redeemType?: 'IN_PERSON' | 'ONLINE' | 'BOTH';\n  maxRedemptions?: number;\n  perUserLimit?: number;\n  validFrom?: string;\n  validUntil?: string;\n}\n\n/**\n * Create a reward for a venue\n *\n * @param venueId - Venue ID\n *\n * @example\n * ```tsx\n * const createReward = useCreateVenueReward('venue-123');\n *\n * const handleCreate = async () => {\n *   await createReward.mutateAsync({\n *     badgeId: 'badge-week-warrior',\n *     title: 'Free Coffee',\n *     description: 'Show your badge for a free coffee',\n *     redeemType: 'IN_PERSON',\n *   });\n * };\n * ```\n */\nexport function useCreateVenueReward(\n  venueId: string,\n  options?: Omit<UseMutationOptions<unknown, Error, CreateRewardRequest>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateRewardRequest) => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/venues/${venueId}/rewards`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forVenue(venueId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a reward for a brand\n *\n * @param brandId - Brand ID\n *\n * @example\n * ```tsx\n * const createReward = useCreateBrandReward('brand-123');\n *\n * const handleCreate = async () => {\n *   await createReward.mutateAsync({\n *     badgeId: 'badge-week-warrior',\n *     title: '10% Off',\n *     description: 'Use code at checkout',\n *     code: 'SOBER10',\n *     redeemType: 'ONLINE',\n *   });\n * };\n * ```\n */\nexport function useCreateBrandReward(\n  brandId: string,\n  options?: Omit<UseMutationOptions<unknown, Error, CreateRewardRequest>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateRewardRequest) => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/brands/${brandId}/rewards`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBrand(brandId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update a partner reward (for business dashboard)\n *\n * @param businessId - Business ID\n *\n * @example\n * ```tsx\n * const updateReward = useUpdatePartnerReward('business-123');\n *\n * const handleUpdate = async (rewardId: string) => {\n *   await updateReward.mutateAsync({\n *     id: rewardId,\n *     data: { title: 'Updated Title', isActive: false },\n *   });\n * };\n * ```\n */\nexport function useUpdatePartnerReward(\n  businessId: string,\n  options?: Omit<\n    UseMutationOptions<\n      PartnerRewardResponse,\n      Error,\n      { id: string; data: Partial<CreatePartnerRewardRequest & { isActive: boolean }> }\n    >,\n    'mutationFn'\n  >\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      id,\n      data,\n    }: {\n      id: string;\n      data: Partial<CreatePartnerRewardRequest & { isActive: boolean }>;\n    }): Promise<PartnerRewardResponse> => {\n      const client = getApiClient();\n      const response = await client.patch(`/api/v1/businesses/${businessId}/rewards/${id}`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBusiness(businessId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n// ============================================================================\n// VENUE REWARD MUTATIONS\n// ============================================================================\n\ninterface UpdateRewardRequest {\n  isActive?: boolean;\n  title?: string;\n  description?: string;\n  code?: string;\n  redeemType?: 'IN_PERSON' | 'ONLINE' | 'BOTH';\n  maxRedemptions?: number;\n  perUserLimit?: number;\n  validFrom?: string;\n  validUntil?: string;\n}\n\n/**\n * Update a venue reward\n *\n * @param venueId - Venue ID\n *\n * @example\n * ```tsx\n * const updateReward = useUpdateVenueReward('venue-123');\n *\n * const handleUpdate = async (rewardId: string) => {\n *   await updateReward.mutateAsync({\n *     id: rewardId,\n *     data: { isActive: false },\n *   });\n * };\n * ```\n */\nexport function useUpdateVenueReward(\n  venueId: string,\n  options?: Omit<\n    UseMutationOptions<unknown, Error, { id: string; data: UpdateRewardRequest }>,\n    'mutationFn'\n  >\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ id, data }: { id: string; data: UpdateRewardRequest }) => {\n      const client = getApiClient();\n      const response = await client.patch(`/api/v1/venues/${venueId}/rewards/${id}`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forVenue(venueId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Delete a venue reward\n *\n * @param venueId - Venue ID\n *\n * @example\n * ```tsx\n * const deleteReward = useDeleteVenueReward('venue-123');\n *\n * const handleDelete = async (rewardId: string) => {\n *   await deleteReward.mutateAsync(rewardId);\n * };\n * ```\n */\nexport function useDeleteVenueReward(\n  venueId: string,\n  options?: Omit<UseMutationOptions<unknown, Error, string>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (rewardId: string) => {\n      const client = getApiClient();\n      const response = await client.delete(`/api/v1/venues/${venueId}/rewards/${rewardId}`);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forVenue(venueId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n// ============================================================================\n// BRAND REWARD MUTATIONS\n// ============================================================================\n\n/**\n * Update a brand reward\n *\n * @param brandId - Brand ID\n *\n * @example\n * ```tsx\n * const updateReward = useUpdateBrandReward('brand-123');\n *\n * const handleUpdate = async (rewardId: string) => {\n *   await updateReward.mutateAsync({\n *     id: rewardId,\n *     data: { isActive: false },\n *   });\n * };\n * ```\n */\nexport function useUpdateBrandReward(\n  brandId: string,\n  options?: Omit<\n    UseMutationOptions<unknown, Error, { id: string; data: UpdateRewardRequest }>,\n    'mutationFn'\n  >\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ id, data }: { id: string; data: UpdateRewardRequest }) => {\n      const client = getApiClient();\n      const response = await client.patch(`/api/v1/brands/${brandId}/rewards/${id}`, data);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBrand(brandId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Delete a brand reward\n *\n * @param brandId - Brand ID\n *\n * @example\n * ```tsx\n * const deleteReward = useDeleteBrandReward('brand-123');\n *\n * const handleDelete = async (rewardId: string) => {\n *   await deleteReward.mutateAsync(rewardId);\n * };\n * ```\n */\nexport function useDeleteBrandReward(\n  brandId: string,\n  options?: Omit<UseMutationOptions<unknown, Error, string>, 'mutationFn'>\n) {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (rewardId: string) => {\n      const client = getApiClient();\n      const response = await client.delete(`/api/v1/brands/${brandId}/rewards/${rewardId}`);\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: rewardKeys.forBrand(brandId) });\n      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -25,3 +25,4 @@ export * from './badges';
 export * from './creators';
 export * from './brands';
 export * from './products';
+export * from './venues';

package/dist/api/mutations/index.js

@@ -41,4 +41,5 @@ __exportStar(require("./badges"), exports);
 __exportStar(require("./creators"), exports);
 __exportStar(require("./brands"), exports);
 __exportStar(require("./products"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL211dGF0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7R0FJRzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILDBDQUF3QjtBQUN4Qix5Q0FBdUI7QUFDdkIsNkNBQTJCO0FBQzNCLDJDQUF5QjtBQUN6Qix5Q0FBdUI7QUFDdkIsNENBQTBCO0FBQzFCLHdDQUFzQjtBQUN0QixrREFBZ0M7QUFDaEMsMkNBQXlCO0FBQ3pCLGtEQUFnQztBQUNoQyw0Q0FBMEI7QUFDMUIsMENBQXdCO0FBQ3hCLHlDQUF1QjtBQUN2QixnREFBOEI7QUFDOUIsMkNBQXlCO0FBQ3pCLDZDQUEyQjtBQUMzQiwrQ0FBNkI7QUFDN0IsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6Qiw2Q0FBMkI7QUFDM0IsMkNBQXlCO0FBQ3pCLDZDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTXV0YXRpb24gSG9va3NcbiAqXG4gKiBSZS1leHBvcnRzIGFsbCBtdXRhdGlvbiBob29rcyBmb3IgQVBJIGVuZHBvaW50cy5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2FkbWluJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aCc7XG5leHBvcnQgKiBmcm9tICcuL2Jvb2tpbmdzJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vaHVicyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYnJhcnknO1xuZXhwb3J0ICogZnJvbSAnLi9tYXAnO1xuZXhwb3J0ICogZnJvbSAnLi9ub3RpZmljYXRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vb2ZmZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vc3Vic2NyaXB0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3N1cHBvcnQnO1xuZXhwb3J0ICogZnJvbSAnLi91c2Vycyc7XG5leHBvcnQgKiBmcm9tICcuL2phY2snO1xuZXhwb3J0ICogZnJvbSAnLi9hbWJhc3NhZG9ycyc7XG5leHBvcnQgKiBmcm9tICcuL2dyb3c5MCc7XG5leHBvcnQgKiBmcm9tICcuL21hdGNoaW5nJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnQtY2hhdCc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXItcGlucyc7XG5leHBvcnQgKiBmcm9tICcuL2JhZGdlcyc7XG5leHBvcnQgKiBmcm9tICcuL2NyZWF0b3JzJztcbmV4cG9ydCAqIGZyb20gJy4vYnJhbmRzJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZHVjdHMnO1xuIl19
+__exportStar(require("./venues"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL211dGF0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7R0FJRzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILDBDQUF3QjtBQUN4Qix5Q0FBdUI7QUFDdkIsNkNBQTJCO0FBQzNCLDJDQUF5QjtBQUN6Qix5Q0FBdUI7QUFDdkIsNENBQTBCO0FBQzFCLHdDQUFzQjtBQUN0QixrREFBZ0M7QUFDaEMsMkNBQXlCO0FBQ3pCLGtEQUFnQztBQUNoQyw0Q0FBMEI7QUFDMUIsMENBQXdCO0FBQ3hCLHlDQUF1QjtBQUN2QixnREFBOEI7QUFDOUIsMkNBQXlCO0FBQ3pCLDZDQUEyQjtBQUMzQiwrQ0FBNkI7QUFDN0IsOENBQTRCO0FBQzVCLDJDQUF5QjtBQUN6Qiw2Q0FBMkI7QUFDM0IsMkNBQXlCO0FBQ3pCLDZDQUEyQjtBQUMzQiwyQ0FBeUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE11dGF0aW9uIEhvb2tzXG4gKlxuICogUmUtZXhwb3J0cyBhbGwgbXV0YXRpb24gaG9va3MgZm9yIEFQSSBlbmRwb2ludHMuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9hZG1pbic7XG5leHBvcnQgKiBmcm9tICcuL2F1dGgnO1xuZXhwb3J0ICogZnJvbSAnLi9ib29raW5ncyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2h1YnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWJyYXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vbWFwJztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL29mZmVycyc7XG5leHBvcnQgKiBmcm9tICcuL3N1YnNjcmlwdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdXBwb3J0JztcbmV4cG9ydCAqIGZyb20gJy4vdXNlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9qYWNrJztcbmV4cG9ydCAqIGZyb20gJy4vYW1iYXNzYWRvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9ncm93OTAnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXRjaGluZyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50LWNoYXQnO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyLXBpbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9iYWRnZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9jcmVhdG9ycyc7XG5leHBvcnQgKiBmcm9tICcuL2JyYW5kcyc7XG5leHBvcnQgKiBmcm9tICcuL3Byb2R1Y3RzJztcbmV4cG9ydCAqIGZyb20gJy4vdmVudWVzJztcbiJdfQ==

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

@@ -0,0 +1,126 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import type { VenueResponse, CreateVenueRequest, UpdateVenueRequest } from '../types';
+/**
+ * Update a venue
+ *
+ * @example
+ * ```tsx
+ * const updateVenue = useUpdateVenue({
+ *   onSuccess: () => toast.success('Venue updated'),
+ * });
+ *
+ * const handleSave = () => {
+ *   updateVenue.mutate({
+ *     id: venueId,
+ *     data: { name: 'Updated Name', hasAfDrinks: true },
+ *   });
+ * };
+ * ```
+ */
+export declare function useUpdateVenue(options?: Omit<UseMutationOptions<VenueResponse, Error, {
+    id: string;
+    data: UpdateVenueRequest;
+}>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    appId: string;
+    name: string;
+    slug: string;
+    description?: Record<string, never>;
+    type: "COFFEE_SHOP" | "RESTAURANT" | "BAR" | "WELLNESS" | "VENUE" | "ACTIVITY" | "RETAIL" | "OTHER";
+    hasAfDrinks: boolean;
+    isAfVenue: boolean;
+    afHighlights: string[];
+    address?: Record<string, never>;
+    cityId?: Record<string, never>;
+    locationLat?: Record<string, never>;
+    locationLong?: Record<string, never>;
+    phone?: Record<string, never>;
+    email?: Record<string, never>;
+    website?: Record<string, never>;
+    instagram?: Record<string, never>;
+    profileImage?: Record<string, never>;
+    bannerImage?: Record<string, never>;
+    photos: string[];
+    openingHours?: Record<string, never>;
+    rating?: Record<string, never>;
+    reviewCount: number;
+    isActive: boolean;
+    isVerified: boolean;
+    isFeatured: boolean;
+    isFoundingPartner: boolean;
+    createdAt: string;
+    updatedAt: string;
+}, Error, {
+    id: string;
+    data: UpdateVenueRequest;
+}, unknown>;
+/**
+ * Create a venue
+ *
+ * @example
+ * ```tsx
+ * const createVenue = useCreateVenue({
+ *   onSuccess: (venue) => {
+ *     toast.success('Venue created');
+ *     router.push(`/venues/${venue.id}`);
+ *   },
+ * });
+ *
+ * const handleCreate = () => {
+ *   createVenue.mutate({
+ *     name: 'My Venue',
+ *     address: '123 Main St',
+ *     hasAfDrinks: true,
+ *   });
+ * };
+ * ```
+ */
+export declare function useCreateVenue(options?: Omit<UseMutationOptions<VenueResponse, Error, CreateVenueRequest>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<{
+    id: string;
+    appId: string;
+    name: string;
+    slug: string;
+    description?: Record<string, never>;
+    type: "COFFEE_SHOP" | "RESTAURANT" | "BAR" | "WELLNESS" | "VENUE" | "ACTIVITY" | "RETAIL" | "OTHER";
+    hasAfDrinks: boolean;
+    isAfVenue: boolean;
+    afHighlights: string[];
+    address?: Record<string, never>;
+    cityId?: Record<string, never>;
+    locationLat?: Record<string, never>;
+    locationLong?: Record<string, never>;
+    phone?: Record<string, never>;
+    email?: Record<string, never>;
+    website?: Record<string, never>;
+    instagram?: Record<string, never>;
+    profileImage?: Record<string, never>;
+    bannerImage?: Record<string, never>;
+    photos: string[];
+    openingHours?: Record<string, never>;
+    rating?: Record<string, never>;
+    reviewCount: number;
+    isActive: boolean;
+    isVerified: boolean;
+    isFeatured: boolean;
+    isFoundingPartner: boolean;
+    createdAt: string;
+    updatedAt: string;
+}, Error, CreateVenueRequest, unknown>;
+/**
+ * Delete a venue
+ *
+ * @example
+ * ```tsx
+ * const deleteVenue = useDeleteVenue({
+ *   onSuccess: () => {
+ *     toast.success('Venue deleted');
+ *     router.push('/venues');
+ *   },
+ * });
+ *
+ * const handleDelete = (venueId: string) => {
+ *   deleteVenue.mutate(venueId);
+ * };
+ * ```
+ */
+export declare function useDeleteVenue(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;

package/dist/api/mutations/venues.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUpdateVenue = useUpdateVenue;
+exports.useCreateVenue = useCreateVenue;
+exports.useDeleteVenue = useDeleteVenue;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const venues_1 = require("../queries/venues");
+// ============================================================================
+// VENUE MUTATION HOOKS
+// ============================================================================
+/**
+ * Update a venue
+ *
+ * @example
+ * ```tsx
+ * const updateVenue = useUpdateVenue({
+ *   onSuccess: () => toast.success('Venue updated'),
+ * });
+ *
+ * const handleSave = () => {
+ *   updateVenue.mutate({
+ *     id: venueId,
+ *     data: { name: 'Updated Name', hasAfDrinks: true },
+ *   });
+ * };
+ * ```
+ */
+function useUpdateVenue(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.patch(`/api/v1/venues/${id}`, data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({ queryKey: venues_1.venueKeys.detail(variables.id) });
+            queryClient.invalidateQueries({ queryKey: venues_1.venueKeys.lists() });
+        },
+        ...options,
+    });
+}
+/**
+ * Create a venue
+ *
+ * @example
+ * ```tsx
+ * const createVenue = useCreateVenue({
+ *   onSuccess: (venue) => {
+ *     toast.success('Venue created');
+ *     router.push(`/venues/${venue.id}`);
+ *   },
+ * });
+ *
+ * const handleCreate = () => {
+ *   createVenue.mutate({
+ *     name: 'My Venue',
+ *     address: '123 Main St',
+ *     hasAfDrinks: true,
+ *   });
+ * };
+ * ```
+ */
+function useCreateVenue(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/venues', data);
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: venues_1.venueKeys.lists() });
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a venue
+ *
+ * @example
+ * ```tsx
+ * const deleteVenue = useDeleteVenue({
+ *   onSuccess: () => {
+ *     toast.success('Venue deleted');
+ *     router.push('/venues');
+ *   },
+ * });
+ *
+ * const handleDelete = (venueId: string) => {
+ *   deleteVenue.mutate(venueId);
+ * };
+ * ```
+ */
+function useDeleteVenue(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (venueId) => {
+            const client = (0, client_1.getApiClient)();
+            await client.delete(`/api/v1/venues/${venueId}`);
+        },
+        onSuccess: (_, venueId) => {
+            queryClient.invalidateQueries({ queryKey: venues_1.venueKeys.detail(venueId) });
+            queryClient.invalidateQueries({ queryKey: venues_1.venueKeys.lists() });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@growsober/sdk",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Shared TypeScript SDK for GrowSober API - TanStack Query hooks, API client, and utilities",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/src/api/mutations/badges.ts

@@ -226,3 +226,171 @@ export function useUpdatePartnerReward(
     ...options,
   });
 }
+
+// ============================================================================
+// VENUE REWARD MUTATIONS
+// ============================================================================
+
+interface UpdateRewardRequest {
+  isActive?: boolean;
+  title?: string;
+  description?: string;
+  code?: string;
+  redeemType?: 'IN_PERSON' | 'ONLINE' | 'BOTH';
+  maxRedemptions?: number;
+  perUserLimit?: number;
+  validFrom?: string;
+  validUntil?: string;
+}
+
+/**
+ * Update a venue reward
+ *
+ * @param venueId - Venue ID
+ *
+ * @example
+ * ```tsx
+ * const updateReward = useUpdateVenueReward('venue-123');
+ *
+ * const handleUpdate = async (rewardId: string) => {
+ *   await updateReward.mutateAsync({
+ *     id: rewardId,
+ *     data: { isActive: false },
+ *   });
+ * };
+ * ```
+ */
+export function useUpdateVenueReward(
+  venueId: string,
+  options?: Omit<
+    UseMutationOptions<unknown, Error, { id: string; data: UpdateRewardRequest }>,
+    'mutationFn'
+  >
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ id, data }: { id: string; data: UpdateRewardRequest }) => {
+      const client = getApiClient();
+      const response = await client.patch(`/api/v1/venues/${venueId}/rewards/${id}`, data);
+      return response.data?.data || response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: rewardKeys.forVenue(venueId) });
+      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });
+    },
+    ...options,
+  });
+}
+
+/**
+ * Delete a venue reward
+ *
+ * @param venueId - Venue ID
+ *
+ * @example
+ * ```tsx
+ * const deleteReward = useDeleteVenueReward('venue-123');
+ *
+ * const handleDelete = async (rewardId: string) => {
+ *   await deleteReward.mutateAsync(rewardId);
+ * };
+ * ```
+ */
+export function useDeleteVenueReward(
+  venueId: string,
+  options?: Omit<UseMutationOptions<unknown, Error, string>, 'mutationFn'>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (rewardId: string) => {
+      const client = getApiClient();
+      const response = await client.delete(`/api/v1/venues/${venueId}/rewards/${rewardId}`);
+      return response.data?.data || response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: rewardKeys.forVenue(venueId) });
+      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });
+    },
+    ...options,
+  });
+}
+
+// ============================================================================
+// BRAND REWARD MUTATIONS
+// ============================================================================
+
+/**
+ * Update a brand reward
+ *
+ * @param brandId - Brand ID
+ *
+ * @example
+ * ```tsx
+ * const updateReward = useUpdateBrandReward('brand-123');
+ *
+ * const handleUpdate = async (rewardId: string) => {
+ *   await updateReward.mutateAsync({
+ *     id: rewardId,
+ *     data: { isActive: false },
+ *   });
+ * };
+ * ```
+ */
+export function useUpdateBrandReward(
+  brandId: string,
+  options?: Omit<
+    UseMutationOptions<unknown, Error, { id: string; data: UpdateRewardRequest }>,
+    'mutationFn'
+  >
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ id, data }: { id: string; data: UpdateRewardRequest }) => {
+      const client = getApiClient();
+      const response = await client.patch(`/api/v1/brands/${brandId}/rewards/${id}`, data);
+      return response.data?.data || response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: rewardKeys.forBrand(brandId) });
+      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });
+    },
+    ...options,
+  });
+}
+
+/**
+ * Delete a brand reward
+ *
+ * @param brandId - Brand ID
+ *
+ * @example
+ * ```tsx
+ * const deleteReward = useDeleteBrandReward('brand-123');
+ *
+ * const handleDelete = async (rewardId: string) => {
+ *   await deleteReward.mutateAsync(rewardId);
+ * };
+ * ```
+ */
+export function useDeleteBrandReward(
+  brandId: string,
+  options?: Omit<UseMutationOptions<unknown, Error, string>, 'mutationFn'>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (rewardId: string) => {
+      const client = getApiClient();
+      const response = await client.delete(`/api/v1/brands/${brandId}/rewards/${rewardId}`);
+      return response.data?.data || response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: rewardKeys.forBrand(brandId) });
+      queryClient.invalidateQueries({ queryKey: rewardKeys.available() });
+    },
+    ...options,
+  });
+}

package/src/api/mutations/index.ts

@@ -26,3 +26,4 @@ export * from './badges';
 export * from './creators';
 export * from './brands';
 export * from './products';
+export * from './venues';

package/src/api/mutations/venues.ts

@@ -0,0 +1,127 @@
+import { useMutation, useQueryClient, UseMutationOptions } from '@tanstack/react-query';
+import { getApiClient } from '../client';
+import { venueKeys } from '../queries/venues';
+import type { VenueResponse, CreateVenueRequest, UpdateVenueRequest } from '../types';
+
+// ============================================================================
+// VENUE MUTATION HOOKS
+// ============================================================================
+
+/**
+ * Update a venue
+ *
+ * @example
+ * ```tsx
+ * const updateVenue = useUpdateVenue({
+ *   onSuccess: () => toast.success('Venue updated'),
+ * });
+ *
+ * const handleSave = () => {
+ *   updateVenue.mutate({
+ *     id: venueId,
+ *     data: { name: 'Updated Name', hasAfDrinks: true },
+ *   });
+ * };
+ * ```
+ */
+export function useUpdateVenue(
+  options?: Omit<
+    UseMutationOptions<VenueResponse, Error, { id: string; data: UpdateVenueRequest }>,
+    'mutationFn'
+  >
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({
+      id,
+      data,
+    }: {
+      id: string;
+      data: UpdateVenueRequest;
+    }): Promise<VenueResponse> => {
+      const client = getApiClient();
+      const response = await client.patch(`/api/v1/venues/${id}`, data);
+      return response.data?.data || response.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: venueKeys.detail(variables.id) });
+      queryClient.invalidateQueries({ queryKey: venueKeys.lists() });
+    },
+    ...options,
+  });
+}
+
+/**
+ * Create a venue
+ *
+ * @example
+ * ```tsx
+ * const createVenue = useCreateVenue({
+ *   onSuccess: (venue) => {
+ *     toast.success('Venue created');
+ *     router.push(`/venues/${venue.id}`);
+ *   },
+ * });
+ *
+ * const handleCreate = () => {
+ *   createVenue.mutate({
+ *     name: 'My Venue',
+ *     address: '123 Main St',
+ *     hasAfDrinks: true,
+ *   });
+ * };
+ * ```
+ */
+export function useCreateVenue(
+  options?: Omit<UseMutationOptions<VenueResponse, Error, CreateVenueRequest>, 'mutationFn'>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (data: CreateVenueRequest): Promise<VenueResponse> => {
+      const client = getApiClient();
+      const response = await client.post('/api/v1/venues', data);
+      return response.data?.data || response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: venueKeys.lists() });
+    },
+    ...options,
+  });
+}
+
+/**
+ * Delete a venue
+ *
+ * @example
+ * ```tsx
+ * const deleteVenue = useDeleteVenue({
+ *   onSuccess: () => {
+ *     toast.success('Venue deleted');
+ *     router.push('/venues');
+ *   },
+ * });
+ *
+ * const handleDelete = (venueId: string) => {
+ *   deleteVenue.mutate(venueId);
+ * };
+ * ```
+ */
+export function useDeleteVenue(
+  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (venueId: string): Promise<void> => {
+      const client = getApiClient();
+      await client.delete(`/api/v1/venues/${venueId}`);
+    },
+    onSuccess: (_, venueId) => {
+      queryClient.invalidateQueries({ queryKey: venueKeys.detail(venueId) });
+      queryClient.invalidateQueries({ queryKey: venueKeys.lists() });
+    },
+    ...options,
+  });
+}