@spotsdev/sdk 1.0.0

package/dist/api/mutations/orders.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Orders Mutation Hooks
+ *
+ * TanStack Query hooks for order mutation operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateOrder = useCreateOrder;
+exports.useCreateStripeIntent = useCreateStripeIntent;
+exports.useCreateCoinbaseCharge = useCreateCoinbaseCharge;
+exports.useUpdateOrderStatus = useUpdateOrderStatus;
+exports.useCancelOrder = useCancelOrder;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const orders_1 = require("../queries/orders");
+const products_1 = require("../queries/products");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Create a new order
+ *
+ * @endpoint POST /api/v1/orders
+ */
+function useCreateOrder(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/orders', data);
+            return response.data.data;
+        },
+        onSuccess: (_, variables) => {
+            // Invalidate products to reflect updated stock
+            queryClient.invalidateQueries({ queryKey: products_1.productKeys.bySpot(variables.spotId) });
+            // Invalidate my orders list
+            queryClient.invalidateQueries({ queryKey: orders_1.orderKeys.list({ my: true }) });
+        },
+        ...options,
+    });
+}
+/**
+ * Create Stripe PaymentIntent for an order
+ *
+ * @endpoint POST /api/v1/payments/stripe/intent/{orderId}
+ */
+function useCreateStripeIntent(options) {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (orderId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/payments/stripe/intent/${orderId}`);
+            return response.data.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Create Coinbase Commerce charge for an order
+ *
+ * @endpoint POST /api/v1/payments/coinbase/charge/{orderId}
+ */
+function useCreateCoinbaseCharge(options) {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (orderId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/payments/coinbase/charge/${orderId}`);
+            return response.data.data;
+        },
+        ...options,
+    });
+}
+/**
+ * Update order status (seller action)
+ *
+ * @endpoint PUT /api/v1/orders/{orderId}/status
+ */
+function useUpdateOrderStatus(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ orderId, status }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/orders/${orderId}/status`, {
+                status,
+            });
+            return response.data.data;
+        },
+        onSuccess: (data) => {
+            queryClient.setQueryData(orders_1.orderKeys.detail(data.id), data);
+            queryClient.invalidateQueries({ queryKey: orders_1.orderKeys.spotOrders(data.spotId) });
+        },
+        ...options,
+    });
+}
+/**
+ * Cancel an order (buyer action, only for pending orders)
+ *
+ * @endpoint POST /api/v1/orders/{orderId}/cancel
+ */
+function useCancelOrder(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (orderId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/orders/${orderId}/cancel`);
+            return response.data.data;
+        },
+        onSuccess: (data) => {
+            queryClient.setQueryData(orders_1.orderKeys.detail(data.id), data);
+            queryClient.invalidateQueries({ queryKey: orders_1.orderKeys.list({ my: true }) });
+            // Restore stock
+            queryClient.invalidateQueries({ queryKey: products_1.productKeys.bySpot(data.spotId) });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orders.js","sourceRoot":"","sources":["../../../src/api/mutations/orders.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Orders Mutation Hooks\n *\n * TanStack Query hooks for order mutation operations.\n */\n\nimport { useMutation, useQueryClient, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { orderKeys, OrderWithDetails } from '../queries/orders';\nimport { productKeys } from '../queries/products';\nimport type { Order, OrderStatus, ApiResponse } from '../types';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport interface CartItem {\n  productId: string;\n  quantity: number;\n}\n\nexport interface CreateOrderRequest {\n  spotId: string;\n  items: CartItem[];\n  notes?: string;\n  deliveryAddress?: string;\n}\n\nexport interface CreateOrderResponse extends Order {\n  items: Array<{\n    id: string;\n    productId: string;\n    productName: string;\n    quantity: number;\n    unitPrice: number;\n    totalPrice: number;\n  }>;\n}\n\nexport interface PaymentIntentResponse {\n  clientSecret: string;\n  paymentIntentId: string;\n}\n\nexport interface CoinbaseChargeResponse {\n  chargeId: string;\n  chargeCode: string;\n  hostedUrl: string;\n}\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Create a new order\n *\n * @endpoint POST /api/v1/orders\n */\nexport function useCreateOrder(\n  options?: Omit<UseMutationOptions<CreateOrderResponse, Error, CreateOrderRequest>, 'mutationFn'>\n): UseMutationResult<CreateOrderResponse, Error, CreateOrderRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateOrderRequest): Promise<CreateOrderResponse> => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<CreateOrderResponse>>('/api/v1/orders', data);\n      return response.data.data;\n    },\n    onSuccess: (_, variables) => {\n      // Invalidate products to reflect updated stock\n      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(variables.spotId) });\n      // Invalidate my orders list\n      queryClient.invalidateQueries({ queryKey: orderKeys.list({ my: true }) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Create Stripe PaymentIntent for an order\n *\n * @endpoint POST /api/v1/payments/stripe/intent/{orderId}\n */\nexport function useCreateStripeIntent(\n  options?: Omit<UseMutationOptions<PaymentIntentResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<PaymentIntentResponse, Error, string> {\n  return useMutation({\n    mutationFn: async (orderId: string): Promise<PaymentIntentResponse> => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<PaymentIntentResponse>>(\n        `/api/v1/payments/stripe/intent/${orderId}`\n      );\n      return response.data.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Create Coinbase Commerce charge for an order\n *\n * @endpoint POST /api/v1/payments/coinbase/charge/{orderId}\n */\nexport function useCreateCoinbaseCharge(\n  options?: Omit<UseMutationOptions<CoinbaseChargeResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<CoinbaseChargeResponse, Error, string> {\n  return useMutation({\n    mutationFn: async (orderId: string): Promise<CoinbaseChargeResponse> => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<CoinbaseChargeResponse>>(\n        `/api/v1/payments/coinbase/charge/${orderId}`\n      );\n      return response.data.data;\n    },\n    ...options,\n  });\n}\n\n/**\n * Update order status (seller action)\n *\n * @endpoint PUT /api/v1/orders/{orderId}/status\n */\nexport function useUpdateOrderStatus(\n  options?: Omit<\n    UseMutationOptions<OrderWithDetails, Error, { orderId: string; status: OrderStatus }>,\n    'mutationFn'\n  >\n): UseMutationResult<OrderWithDetails, Error, { orderId: string; status: OrderStatus }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ orderId, status }): Promise<OrderWithDetails> => {\n      const client = getApiClient();\n      const response = await client.put<ApiResponse<OrderWithDetails>>(`/api/v1/orders/${orderId}/status`, {\n        status,\n      });\n      return response.data.data;\n    },\n    onSuccess: (data) => {\n      queryClient.setQueryData(orderKeys.detail(data.id), data);\n      queryClient.invalidateQueries({ queryKey: orderKeys.spotOrders(data.spotId) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Cancel an order (buyer action, only for pending orders)\n *\n * @endpoint POST /api/v1/orders/{orderId}/cancel\n */\nexport function useCancelOrder(\n  options?: Omit<UseMutationOptions<OrderWithDetails, Error, string>, 'mutationFn'>\n): UseMutationResult<OrderWithDetails, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (orderId: string): Promise<OrderWithDetails> => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<OrderWithDetails>>(`/api/v1/orders/${orderId}/cancel`);\n      return response.data.data;\n    },\n    onSuccess: (data) => {\n      queryClient.setQueryData(orderKeys.detail(data.id), data);\n      queryClient.invalidateQueries({ queryKey: orderKeys.list({ my: true }) });\n      // Restore stock\n      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(data.spotId) });\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,123 @@
+/**
+ * Posts Mutation Hooks
+ *
+ * TanStack Query hooks for post/board mutation operations.
+ */
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { Post, PostResponse, CreatePostRequest, CreateReplyRequest, RespondToPostRequest, UpdateResponseRequest, UpvoteResponse, PostStatusDto } from '../types';
+/**
+ * Create a new post
+ *
+ * @endpoint POST /api/v1/spots/{spotId}/posts
+ */
+export declare function useCreatePost(options?: Omit<UseMutationOptions<Post, Error, {
+    spotId: string;
+} & CreatePostRequest>, 'mutationFn'>): UseMutationResult<Post, Error, {
+    spotId: string;
+} & CreatePostRequest>;
+/**
+ * Update a post
+ *
+ * @endpoint PUT /api/v1/posts/{postId}
+ */
+export declare function useUpdatePost(options?: Omit<UseMutationOptions<Post, Error, {
+    postId: string;
+    title?: string;
+    content?: string;
+}>, 'mutationFn'>): UseMutationResult<Post, Error, {
+    postId: string;
+    title?: string;
+    content?: string;
+}>;
+/**
+ * Delete a post
+ *
+ * @endpoint DELETE /api/v1/posts/{postId}
+ */
+export declare function useDeletePost(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
+/**
+ * Fulfill a post (mark as fulfilled)
+ *
+ * @endpoint PUT /api/v1/posts/{postId}/fulfill
+ */
+export declare function useFulfillPost(options?: Omit<UseMutationOptions<Post, Error, string>, 'mutationFn'>): UseMutationResult<Post, Error, string>;
+/**
+ * Upvote/unupvote a post
+ *
+ * @endpoint POST /api/v1/posts/{postId}/upvote
+ */
+export declare function useUpvotePost(options?: Omit<UseMutationOptions<UpvoteResponse, Error, string>, 'mutationFn'>): UseMutationResult<UpvoteResponse, Error, string>;
+/**
+ * Create a reply to a post
+ *
+ * @endpoint POST /api/v1/posts/{postId}/reply
+ */
+export declare function useCreateReply(options?: Omit<UseMutationOptions<unknown, Error, {
+    postId: string;
+} & CreateReplyRequest>, 'mutationFn'>): UseMutationResult<unknown, Error, {
+    postId: string;
+} & CreateReplyRequest>;
+/**
+ * Delete a reply
+ *
+ * @endpoint DELETE /api/v1/replies/{replyId}
+ */
+export declare function useDeleteReply(options?: Omit<UseMutationOptions<void, Error, {
+    replyId: string;
+    postId: string;
+}>, 'mutationFn'>): UseMutationResult<void, Error, {
+    replyId: string;
+    postId: string;
+}>;
+/**
+ * Respond to a post (express interest)
+ *
+ * @endpoint POST /api/v1/posts/{postId}/respond
+ */
+export declare function useRespondToPost(options?: Omit<UseMutationOptions<PostResponse, Error, {
+    postId: string;
+} & RespondToPostRequest>, 'mutationFn'>): UseMutationResult<PostResponse, Error, {
+    postId: string;
+} & RespondToPostRequest>;
+/**
+ * Accept or decline a response
+ *
+ * @endpoint PUT /api/v1/responses/{responseId}
+ */
+export declare function useUpdateResponse(options?: Omit<UseMutationOptions<PostResponse, Error, {
+    responseId: string;
+    postId: string;
+} & UpdateResponseRequest>, 'mutationFn'>): UseMutationResult<PostResponse, Error, {
+    responseId: string;
+    postId: string;
+} & UpdateResponseRequest>;
+/**
+ * Report a post
+ *
+ * @endpoint POST /api/v1/posts/{postId}/report
+ */
+export declare function useReportPost(options?: Omit<UseMutationOptions<void, Error, {
+    postId: string;
+    reason: string;
+    details?: string;
+}>, 'mutationFn'>): UseMutationResult<void, Error, {
+    postId: string;
+    reason: string;
+    details?: string;
+}>;
+interface PostStatusUpdate {
+    isRead?: boolean;
+    isHidden?: boolean;
+    isPinned?: boolean;
+}
+/**
+ * Update user's status for a post (read/hidden/pinned)
+ *
+ * @endpoint PUT /api/v1/posts/{postId}/status
+ */
+export declare function useUpdatePostStatus(options?: Omit<UseMutationOptions<PostStatusDto, Error, {
+    postId: string;
+} & PostStatusUpdate>, 'mutationFn'>): UseMutationResult<PostStatusDto, Error, {
+    postId: string;
+} & PostStatusUpdate>;
+export {};

package/dist/api/mutations/posts.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * Posts Mutation Hooks
+ *
+ * TanStack Query hooks for post/board mutation operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreatePost = useCreatePost;
+exports.useUpdatePost = useUpdatePost;
+exports.useDeletePost = useDeletePost;
+exports.useFulfillPost = useFulfillPost;
+exports.useUpvotePost = useUpvotePost;
+exports.useCreateReply = useCreateReply;
+exports.useDeleteReply = useDeleteReply;
+exports.useRespondToPost = useRespondToPost;
+exports.useUpdateResponse = useUpdateResponse;
+exports.useReportPost = useReportPost;
+exports.useUpdatePostStatus = useUpdatePostStatus;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const posts_1 = require("../queries/posts");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Create a new post
+ *
+ * @endpoint POST /api/v1/spots/{spotId}/posts
+ */
+function useCreatePost(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ spotId, ...data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/spots/${spotId}/posts`, data);
+            return response.data.data;
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.bySpot(variables.spotId) });
+        },
+        ...options,
+    });
+}
+/**
+ * Update a post
+ *
+ * @endpoint PUT /api/v1/posts/{postId}
+ */
+function useUpdatePost(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ postId, ...data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/posts/${postId}`, data);
+            return response.data.data;
+        },
+        onSuccess: (data, variables) => {
+            queryClient.setQueryData(posts_1.postKeys.detail(variables.postId), data);
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a post
+ *
+ * @endpoint DELETE /api/v1/posts/{postId}
+ */
+function useDeletePost(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (postId) => {
+            const client = (0, client_1.getApiClient)();
+            await client.delete(`/api/v1/posts/${postId}`);
+        },
+        onSuccess: (_, postId) => {
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.detail(postId) });
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.lists() });
+        },
+        ...options,
+    });
+}
+/**
+ * Fulfill a post (mark as fulfilled)
+ *
+ * @endpoint PUT /api/v1/posts/{postId}/fulfill
+ */
+function useFulfillPost(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (postId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/posts/${postId}/fulfill`);
+            return response.data.data;
+        },
+        onSuccess: (data, postId) => {
+            queryClient.setQueryData(posts_1.postKeys.detail(postId), data);
+        },
+        ...options,
+    });
+}
+/**
+ * Upvote/unupvote a post
+ *
+ * @endpoint POST /api/v1/posts/{postId}/upvote
+ */
+function useUpvotePost(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (postId) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/posts/${postId}/upvote`);
+            return response.data.data;
+        },
+        onSuccess: (_, postId) => {
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.detail(postId) });
+        },
+        ...options,
+    });
+}
+/**
+ * Create a reply to a post
+ *
+ * @endpoint POST /api/v1/posts/{postId}/reply
+ */
+function useCreateReply(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ postId, ...data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/posts/${postId}/reply`, data);
+            return response.data.data;
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.detail(variables.postId) });
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a reply
+ *
+ * @endpoint DELETE /api/v1/replies/{replyId}
+ */
+function useDeleteReply(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ replyId }) => {
+            const client = (0, client_1.getApiClient)();
+            await client.delete(`/api/v1/replies/${replyId}`);
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.detail(variables.postId) });
+        },
+        ...options,
+    });
+}
+/**
+ * Respond to a post (express interest)
+ *
+ * @endpoint POST /api/v1/posts/{postId}/respond
+ */
+function useRespondToPost(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ postId, ...data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/posts/${postId}/respond`, data);
+            return response.data.data;
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.detail(variables.postId) });
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.responses(variables.postId) });
+        },
+        ...options,
+    });
+}
+/**
+ * Accept or decline a response
+ *
+ * @endpoint PUT /api/v1/responses/{responseId}
+ */
+function useUpdateResponse(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ responseId, postId: _, ...data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/responses/${responseId}`, data);
+            return response.data.data;
+        },
+        onSuccess: (_, variables) => {
+            queryClient.invalidateQueries({ queryKey: posts_1.postKeys.responses(variables.postId) });
+        },
+        ...options,
+    });
+}
+/**
+ * Report a post
+ *
+ * @endpoint POST /api/v1/posts/{postId}/report
+ */
+function useReportPost(options) {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ postId, ...data }) => {
+            const client = (0, client_1.getApiClient)();
+            await client.post(`/api/v1/posts/${postId}/report`, data);
+        },
+        ...options,
+    });
+}
+/**
+ * Update user's status for a post (read/hidden/pinned)
+ *
+ * @endpoint PUT /api/v1/posts/{postId}/status
+ */
+function useUpdatePostStatus(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ postId, ...data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/posts/${postId}/status`, data);
+            return response.data.data;
+        },
+        onSuccess: (data, variables) => {
+            queryClient.setQueryData(posts_1.postKeys.status(variables.postId), data);
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"posts.js","sourceRoot":"","sources":["../../../src/api/mutations/posts.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Posts Mutation Hooks\n *\n * TanStack Query hooks for post/board mutation operations.\n */\n\nimport { useMutation, useQueryClient, UseMutationOptions, UseMutationResult } from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport { postKeys } from '../queries/posts';\nimport type {\n  Post,\n  PostResponse,\n  CreatePostRequest,\n  CreateReplyRequest,\n  RespondToPostRequest,\n  UpdateResponseRequest,\n  ApiResponse,\n  UpvoteResponse,\n  PostStatusDto,\n} from '../types';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Create a new post\n *\n * @endpoint POST /api/v1/spots/{spotId}/posts\n */\nexport function useCreatePost(\n  options?: Omit<UseMutationOptions<Post, Error, { spotId: string } & CreatePostRequest>, 'mutationFn'>\n): UseMutationResult<Post, Error, { spotId: string } & CreatePostRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ spotId, ...data }): Promise<Post> => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<Post>>(`/api/v1/spots/${spotId}/posts`, data);\n      return response.data.data;\n    },\n    onSuccess: (_, variables) => {\n      queryClient.invalidateQueries({ queryKey: postKeys.bySpot(variables.spotId) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update a post\n *\n * @endpoint PUT /api/v1/posts/{postId}\n */\nexport function useUpdatePost(\n  options?: Omit<UseMutationOptions<Post, Error, { postId: string; title?: string; content?: string }>, 'mutationFn'>\n): UseMutationResult<Post, Error, { postId: string; title?: string; content?: string }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ postId, ...data }): Promise<Post> => {\n      const client = getApiClient();\n      const response = await client.put<ApiResponse<Post>>(`/api/v1/posts/${postId}`, data);\n      return response.data.data;\n    },\n    onSuccess: (data, variables) => {\n      queryClient.setQueryData(postKeys.detail(variables.postId), data);\n    },\n    ...options,\n  });\n}\n\n/**\n * Delete a post\n *\n * @endpoint DELETE /api/v1/posts/{postId}\n */\nexport function useDeletePost(\n  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>\n): UseMutationResult<void, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (postId: string): Promise<void> => {\n      const client = getApiClient();\n      await client.delete(`/api/v1/posts/${postId}`);\n    },\n    onSuccess: (_, postId) => {\n      queryClient.invalidateQueries({ queryKey: postKeys.detail(postId) });\n      queryClient.invalidateQueries({ queryKey: postKeys.lists() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Fulfill a post (mark as fulfilled)\n *\n * @endpoint PUT /api/v1/posts/{postId}/fulfill\n */\nexport function useFulfillPost(\n  options?: Omit<UseMutationOptions<Post, Error, string>, 'mutationFn'>\n): UseMutationResult<Post, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (postId: string): Promise<Post> => {\n      const client = getApiClient();\n      const response = await client.put<ApiResponse<Post>>(`/api/v1/posts/${postId}/fulfill`);\n      return response.data.data;\n    },\n    onSuccess: (data, postId) => {\n      queryClient.setQueryData(postKeys.detail(postId), data);\n    },\n    ...options,\n  });\n}\n\n/**\n * Upvote/unupvote a post\n *\n * @endpoint POST /api/v1/posts/{postId}/upvote\n */\nexport function useUpvotePost(\n  options?: Omit<UseMutationOptions<UpvoteResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<UpvoteResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (postId: string): Promise<UpvoteResponse> => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<UpvoteResponse>>(`/api/v1/posts/${postId}/upvote`);\n      return response.data.data;\n    },\n    onSuccess: (_, postId) => {\n      queryClient.invalidateQueries({ queryKey: postKeys.detail(postId) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Create a reply to a post\n *\n * @endpoint POST /api/v1/posts/{postId}/reply\n */\nexport function useCreateReply(\n  options?: Omit<UseMutationOptions<unknown, Error, { postId: string } & CreateReplyRequest>, 'mutationFn'>\n): UseMutationResult<unknown, Error, { postId: string } & CreateReplyRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ postId, ...data }) => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<unknown>>(`/api/v1/posts/${postId}/reply`, data);\n      return response.data.data;\n    },\n    onSuccess: (_, variables) => {\n      queryClient.invalidateQueries({ queryKey: postKeys.detail(variables.postId) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Delete a reply\n *\n * @endpoint DELETE /api/v1/replies/{replyId}\n */\nexport function useDeleteReply(\n  options?: Omit<UseMutationOptions<void, Error, { replyId: string; postId: string }>, 'mutationFn'>\n): UseMutationResult<void, Error, { replyId: string; postId: string }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ replyId }): Promise<void> => {\n      const client = getApiClient();\n      await client.delete(`/api/v1/replies/${replyId}`);\n    },\n    onSuccess: (_, variables) => {\n      queryClient.invalidateQueries({ queryKey: postKeys.detail(variables.postId) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Respond to a post (express interest)\n *\n * @endpoint POST /api/v1/posts/{postId}/respond\n */\nexport function useRespondToPost(\n  options?: Omit<UseMutationOptions<PostResponse, Error, { postId: string } & RespondToPostRequest>, 'mutationFn'>\n): UseMutationResult<PostResponse, Error, { postId: string } & RespondToPostRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ postId, ...data }): Promise<PostResponse> => {\n      const client = getApiClient();\n      const response = await client.post<ApiResponse<PostResponse>>(`/api/v1/posts/${postId}/respond`, data);\n      return response.data.data;\n    },\n    onSuccess: (_, variables) => {\n      queryClient.invalidateQueries({ queryKey: postKeys.detail(variables.postId) });\n      queryClient.invalidateQueries({ queryKey: postKeys.responses(variables.postId) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Accept or decline a response\n *\n * @endpoint PUT /api/v1/responses/{responseId}\n */\nexport function useUpdateResponse(\n  options?: Omit<UseMutationOptions<PostResponse, Error, { responseId: string; postId: string } & UpdateResponseRequest>, 'mutationFn'>\n): UseMutationResult<PostResponse, Error, { responseId: string; postId: string } & UpdateResponseRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ responseId, postId: _, ...data }): Promise<PostResponse> => {\n      const client = getApiClient();\n      const response = await client.put<ApiResponse<PostResponse>>(`/api/v1/responses/${responseId}`, data);\n      return response.data.data;\n    },\n    onSuccess: (_, variables) => {\n      queryClient.invalidateQueries({ queryKey: postKeys.responses(variables.postId) });\n    },\n    ...options,\n  });\n}\n\n/**\n * Report a post\n *\n * @endpoint POST /api/v1/posts/{postId}/report\n */\nexport function useReportPost(\n  options?: Omit<UseMutationOptions<void, Error, { postId: string; reason: string; details?: string }>, 'mutationFn'>\n): UseMutationResult<void, Error, { postId: string; reason: string; details?: string }> {\n  return useMutation({\n    mutationFn: async ({ postId, ...data }): Promise<void> => {\n      const client = getApiClient();\n      await client.post(`/api/v1/posts/${postId}/report`, data);\n    },\n    ...options,\n  });\n}\n\n// PostStatusUpdate matches partial PostStatusDto for updates\ninterface PostStatusUpdate {\n  isRead?: boolean;\n  isHidden?: boolean;\n  isPinned?: boolean;\n}\n\n/**\n * Update user's status for a post (read/hidden/pinned)\n *\n * @endpoint PUT /api/v1/posts/{postId}/status\n */\nexport function useUpdatePostStatus(\n  options?: Omit<UseMutationOptions<PostStatusDto, Error, { postId: string } & PostStatusUpdate>, 'mutationFn'>\n): UseMutationResult<PostStatusDto, Error, { postId: string } & PostStatusUpdate> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ postId, ...data }): Promise<PostStatusDto> => {\n      const client = getApiClient();\n      const response = await client.put<ApiResponse<PostStatusDto>>(`/api/v1/posts/${postId}/status`, data);\n      return response.data.data;\n    },\n    onSuccess: (data, variables) => {\n      queryClient.setQueryData(postKeys.status(variables.postId), data);\n    },\n    ...options,\n  });\n}\n"]}

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

@@ -0,0 +1,81 @@
+/**
+ * Products Mutation Hooks
+ *
+ * TanStack Query hooks for product mutation operations.
+ */
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { Product, ProductType, ProductStatus } from '../types';
+export interface CreateProductRequest {
+    spotId: string;
+    name: string;
+    description?: string;
+    type: ProductType;
+    price: number;
+    currency?: string;
+    stockQuantity?: number;
+    lowStockThreshold?: number;
+    validFrom?: string;
+    validUntil?: string;
+    deliveryRadiusKm?: number;
+    prepTimeMinutes?: number;
+    maxCapacity?: number;
+    eventDate?: string;
+    imageUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateProductRequest {
+    name?: string;
+    description?: string;
+    price?: number;
+    stockQuantity?: number;
+    lowStockThreshold?: number;
+    status?: ProductStatus;
+    validFrom?: string;
+    validUntil?: string;
+    deliveryRadiusKm?: number;
+    prepTimeMinutes?: number;
+    maxCapacity?: number;
+    eventDate?: string;
+    imageUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Create a new product
+ *
+ * @endpoint POST /api/v1/spots/{spotId}/products
+ */
+export declare function useCreateProduct(options?: Omit<UseMutationOptions<Product, Error, CreateProductRequest>, 'mutationFn'>): UseMutationResult<Product, Error, CreateProductRequest>;
+/**
+ * Update a product
+ *
+ * @endpoint PUT /api/v1/products/{productId}
+ */
+export declare function useUpdateProduct(options?: Omit<UseMutationOptions<Product, Error, {
+    productId: string;
+    data: UpdateProductRequest;
+}>, 'mutationFn'>): UseMutationResult<Product, Error, {
+    productId: string;
+    data: UpdateProductRequest;
+}>;
+/**
+ * Delete a product
+ *
+ * @endpoint DELETE /api/v1/products/{productId}
+ */
+export declare function useDeleteProduct(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
+/**
+ * Adjust product stock
+ *
+ * @endpoint POST /api/v1/products/{productId}/stock
+ */
+export declare function useAdjustStock(options?: Omit<UseMutationOptions<Product, Error, {
+    productId: string;
+    quantity: number;
+    reason: 'RESTOCK' | 'ADJUSTMENT';
+    notes?: string;
+}>, 'mutationFn'>): UseMutationResult<Product, Error, {
+    productId: string;
+    quantity: number;
+    reason: 'RESTOCK' | 'ADJUSTMENT';
+    notes?: string;
+}>;