@spotsdev/sdk 1.4.0 → 1.5.2

package/dist/index.cjs

@@ -0,0 +1,2166 @@
+'use strict';
+
+var axios = require('axios');
+var types_star = require('@spotsdev/types');
+var reactQuery = require('@tanstack/react-query');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var types_star__namespace = /*#__PURE__*/_interopNamespace(types_star);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  clubKeys: () => clubKeys,
+  configureSDK: () => configureSDK,
+  conversationKeys: () => conversationKeys,
+  getApiClient: () => getApiClient,
+  getConfig: () => getConfig,
+  miscKeys: () => miscKeys,
+  notificationKeys: () => notificationKeys,
+  orderKeys: () => orderKeys,
+  paymentKeys: () => paymentKeys,
+  postKeys: () => postKeys,
+  productKeys: () => productKeys,
+  spotKeys: () => spotKeys,
+  templateKeys: () => templateKeys,
+  useAdjustStock: () => useAdjustStock,
+  useBlockUser: () => useBlockUser,
+  useBlockedUsers: () => useBlockedUsers,
+  useCancelOrder: () => useCancelOrder,
+  useCities: () => useCities,
+  useClaimSpot: () => useClaimSpot,
+  useClub: () => useClub,
+  useClubBySlug: () => useClubBySlug,
+  useClubMembership: () => useClubMembership,
+  useClubsBySpot: () => useClubsBySpot,
+  useClubsByUser: () => useClubsByUser,
+  useCompleteOnboardingStep: () => useCompleteOnboardingStep,
+  useConversation: () => useConversation,
+  useConversationMessages: () => useConversationMessages,
+  useConversations: () => useConversations,
+  useCreateClub: () => useCreateClub,
+  useCreateCoinbaseCharge: () => useCreateCoinbaseCharge,
+  useCreateConversation: () => useCreateConversation,
+  useCreateDirectConversation: () => useCreateDirectConversation,
+  useCreateOrder: () => useCreateOrder,
+  useCreatePost: () => useCreatePost,
+  useCreateProduct: () => useCreateProduct,
+  useCreateReply: () => useCreateReply,
+  useCreateSpot: () => useCreateSpot,
+  useCreateStripeIntent: () => useCreateStripeIntent,
+  useCurrentUser: () => useCurrentUser,
+  useDeleteAccount: () => useDeleteAccount,
+  useDeletePost: () => useDeletePost,
+  useDeleteProduct: () => useDeleteProduct,
+  useDeleteReply: () => useDeleteReply,
+  useFavoriteSpot: () => useFavoriteSpot,
+  useFulfillPost: () => useFulfillPost,
+  useInfiniteSpots: () => useInfiniteSpots,
+  useJoinClub: () => useJoinClub,
+  useLeaveClub: () => useLeaveClub,
+  useLifeSituations: () => useLifeSituations,
+  useMarkConversationAsRead: () => useMarkConversationAsRead,
+  useMarkNotificationsRead: () => useMarkNotificationsRead,
+  useMyOrders: () => useMyOrders,
+  useNotifications: () => useNotifications,
+  useOrder: () => useOrder,
+  useOwnedSpots: () => useOwnedSpots,
+  usePaymentConfig: () => usePaymentConfig,
+  usePost: () => usePost,
+  usePostResponses: () => usePostResponses,
+  usePostStatus: () => usePostStatus,
+  usePostUpvotes: () => usePostUpvotes,
+  usePosts: () => usePosts,
+  usePostsFeed: () => usePostsFeed,
+  useProduct: () => useProduct,
+  useProductBySlug: () => useProductBySlug,
+  useRateSpot: () => useRateSpot,
+  useRedeem: () => useRedeem,
+  useRedemptionLookup: () => useRedemptionLookup,
+  useRefreshToken: () => useRefreshToken,
+  useRegisterDeviceToken: () => useRegisterDeviceToken,
+  useRemoveDeviceToken: () => useRemoveDeviceToken,
+  useReportPost: () => useReportPost,
+  useReportSpot: () => useReportSpot,
+  useRespondToPost: () => useRespondToPost,
+  useSendMessage: () => useSendMessage,
+  useSendOtp: () => useSendOtp,
+  useSendTypingIndicator: () => useSendTypingIndicator,
+  useSpot: () => useSpot,
+  useSpotByQR: () => useSpotByQR,
+  useSpotBySlug: () => useSpotBySlug,
+  useSpotFavoriteStatus: () => useSpotFavoriteStatus,
+  useSpotImages: () => useSpotImages,
+  useSpotOrders: () => useSpotOrders,
+  useSpotPosts: () => useSpotPosts,
+  useSpotProducts: () => useSpotProducts,
+  useSpotRedemptions: () => useSpotRedemptions,
+  useSpots: () => useSpots,
+  useSubscribeToSpot: () => useSubscribeToSpot,
+  useTemplate: () => useTemplate,
+  useTemplateBySlug: () => useTemplateBySlug,
+  useTemplates: () => useTemplates,
+  useUnblockUser: () => useUnblockUser,
+  useUnreadNotificationCount: () => useUnreadNotificationCount,
+  useUnsubscribeFromSpot: () => useUnsubscribeFromSpot,
+  useUpdateClub: () => useUpdateClub,
+  useUpdateInterests: () => useUpdateInterests,
+  useUpdateOrderStatus: () => useUpdateOrderStatus,
+  useUpdatePost: () => useUpdatePost,
+  useUpdatePostStatus: () => useUpdatePostStatus,
+  useUpdateProduct: () => useUpdateProduct,
+  useUpdateProfile: () => useUpdateProfile,
+  useUpdateResponse: () => useUpdateResponse,
+  useUpdateSpot: () => useUpdateSpot,
+  useUpdateVibes: () => useUpdateVibes,
+  useUploadAvatar: () => useUploadAvatar,
+  useUpvotePost: () => useUpvotePost,
+  useUserActivity: () => useUserActivity,
+  useUserClubs: () => useUserClubs,
+  useUserFavorites: () => useUserFavorites,
+  useUserPosts: () => useUserPosts,
+  useUserSpotsSummary: () => useUserSpotsSummary,
+  useUserStats: () => useUserStats,
+  useUserSubscriptions: () => useUserSubscriptions,
+  useVerifyOtp: () => useVerifyOtp,
+  useVibes: () => useVibes,
+  useVoidRedemption: () => useVoidRedemption,
+  useWallet: () => useWallet,
+  useWalletHistory: () => useWalletHistory,
+  userKeys: () => userKeys,
+  walletKeys: () => walletKeys
+});
+var config = null;
+var apiClient = null;
+function configureSDK(sdkConfig) {
+  config = sdkConfig;
+  apiClient = createApiClient(sdkConfig);
+}
+function getApiClient() {
+  if (!apiClient) {
+    throw new Error("SDK not configured. Call configureSDK() first.");
+  }
+  return apiClient;
+}
+function getConfig() {
+  if (!config) {
+    throw new Error("SDK not configured. Call configureSDK() first.");
+  }
+  return config;
+}
+function createApiClient(sdkConfig) {
+  const client = axios__default.default.create({
+    baseURL: sdkConfig.baseURL,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  client.interceptors.request.use(
+    async (requestConfig) => {
+      const token = await sdkConfig.getAccessToken();
+      if (token) {
+        requestConfig.headers.Authorization = `Bearer ${token}`;
+      }
+      console.log(
+        `[SDK] ${requestConfig.method?.toUpperCase()} ${sdkConfig.baseURL}${requestConfig.url}`
+      );
+      return requestConfig;
+    },
+    (error) => Promise.reject(error)
+  );
+  client.interceptors.response.use(
+    (response) => response,
+    async (error) => {
+      console.log(
+        `[SDK] Error: ${error.response?.status} ${error.config?.url}`,
+        error.message
+      );
+      if (error.response?.status === 401) {
+        if (sdkConfig.refreshAccessToken) {
+          try {
+            const newToken = await sdkConfig.refreshAccessToken();
+            if (newToken && error.config) {
+              error.config.headers.Authorization = `Bearer ${newToken}`;
+              return client.request(error.config);
+            }
+          } catch {
+            sdkConfig.onUnauthorized?.();
+          }
+        } else {
+          sdkConfig.onUnauthorized?.();
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+  return client;
+}
+
+// src/api/types.ts
+var types_exports = {};
+__reExport(types_exports, types_star__namespace);
+
+// src/index.ts
+__reExport(index_exports, types_exports);
+function useSendOtp(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post(
+        "/auth/send-otp",
+        data
+      );
+      return response.data;
+    },
+    ...options
+  });
+}
+function useVerifyOtp(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post("/auth/verify-otp", data);
+      return response.data;
+    },
+    ...options
+  });
+}
+function useRefreshToken(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post(
+        "/auth/refresh",
+        data
+      );
+      return response.data;
+    },
+    ...options
+  });
+}
+function extractArrayData(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data && typeof data === "object" && "data" in data) {
+    const nested = data.data;
+    if (Array.isArray(nested)) {
+      return nested;
+    }
+  }
+  return [];
+}
+var userKeys = {
+  all: ["users"],
+  me: () => [...userKeys.all, "me"],
+  stats: () => [...userKeys.me(), "stats"],
+  spotsSummary: () => [...userKeys.me(), "spots-summary"],
+  activity: (limit) => [...userKeys.me(), "activity", limit],
+  posts: (params) => [...userKeys.me(), "posts", params],
+  clubs: () => [...userKeys.me(), "clubs"],
+  subscriptions: () => [...userKeys.me(), "subscriptions"],
+  blocked: () => [...userKeys.me(), "blocked"],
+  ownedSpots: () => [...userKeys.me(), "owned-spots"],
+  favorites: () => [...userKeys.me(), "favorites"]
+};
+function useCurrentUser(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.me(),
+    queryFn: async () => {
+      console.log("[SDK-USERS] Fetching /users/me...");
+      const client = getApiClient();
+      try {
+        const response = await client.get("/users/me");
+        console.log("[SDK-USERS] Success:", response.status);
+        return response.data.data;
+      } catch (error) {
+        const axiosError = error;
+        console.log(
+          "[SDK-USERS] Error:",
+          axiosError.response?.status,
+          "URL:",
+          axiosError.config?.baseURL,
+          axiosError.config?.url
+        );
+        throw error;
+      }
+    },
+    ...options
+  });
+}
+function useUserStats(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.stats(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/users/me/stats");
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useUserSpotsSummary(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.spotsSummary(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        "/users/me/spots-summary"
+      );
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useUserActivity(limit = 10, options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.activity(limit),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/users/me/activity?limit=${limit}`
+      );
+      return extractArrayData(response.data.data);
+    },
+    ...options
+  });
+}
+function useUserPosts(params, options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.posts(params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.page) queryParams.set("page", String(params.page));
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      const response = await client.get(
+        `/user/me/posts?${queryParams}`
+      );
+      return extractArrayData(response.data.data);
+    },
+    ...options
+  });
+}
+function useUserClubs(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.clubs(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/user/me/clubs");
+      return extractArrayData(response.data.data);
+    },
+    ...options
+  });
+}
+function useUserSubscriptions(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.subscriptions(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        "/user/me/subscriptions"
+      );
+      return extractArrayData(response.data.data);
+    },
+    ...options
+  });
+}
+function useBlockedUsers(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.blocked(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/user/me/blocked");
+      return extractArrayData(response.data.data);
+    },
+    ...options
+  });
+}
+function useOwnedSpots(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.ownedSpots(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        "/users/me/owned-spots"
+      );
+      return extractArrayData(response.data.data);
+    },
+    ...options
+  });
+}
+function useUserFavorites(options) {
+  return reactQuery.useQuery({
+    queryKey: userKeys.favorites(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        "/users/me/favorites"
+      );
+      return extractArrayData(response.data.data);
+    },
+    ...options
+  });
+}
+function extractArrayData2(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data && typeof data === "object" && "data" in data) {
+    const nested = data.data;
+    if (Array.isArray(nested)) {
+      return nested;
+    }
+  }
+  return [];
+}
+function extractObjectData(data) {
+  if (data && typeof data === "object" && "data" in data && !Array.isArray(data)) {
+    const nested = data.data;
+    if (nested && typeof nested === "object" && "data" in nested && !Array.isArray(nested)) {
+      return nested.data;
+    }
+    return nested;
+  }
+  return data;
+}
+var spotKeys = {
+  all: ["spots"],
+  lists: () => [...spotKeys.all, "list"],
+  list: (filters) => [...spotKeys.lists(), filters],
+  details: () => [...spotKeys.all, "detail"],
+  detail: (id) => [...spotKeys.details(), id],
+  bySlug: (slug) => [...spotKeys.all, "slug", slug],
+  byQR: (qrCode) => [...spotKeys.all, "qr", qrCode],
+  images: (spotId) => [...spotKeys.detail(spotId), "images"]
+};
+function useSpots(params, options) {
+  return reactQuery.useQuery({
+    queryKey: spotKeys.list(params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.city) queryParams.set("city", params.city);
+      if (params?.type) queryParams.set("type", params.type);
+      if (params?.lat) queryParams.set("lat", String(params.lat));
+      if (params?.lng) queryParams.set("lng", String(params.lng));
+      if (params?.radius) queryParams.set("radius", String(params.radius));
+      if (params?.search) queryParams.set("search", params.search);
+      if (params?.vibes) queryParams.set("vibeIds", params.vibes);
+      if (params?.cityId) queryParams.set("cityId", params.cityId);
+      if (params?.page) queryParams.set("page", String(params.page));
+      const response = await client.get(
+        `/spots?${queryParams}`
+      );
+      return extractArrayData2(response.data.data);
+    },
+    ...options
+  });
+}
+function useSpot(spotId, options) {
+  return reactQuery.useQuery({
+    queryKey: spotKeys.detail(spotId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/spots/${spotId}`
+      );
+      return extractObjectData(response.data.data);
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+function useSpotBySlug(slug, options) {
+  return reactQuery.useQuery({
+    queryKey: spotKeys.bySlug(slug),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/spots/slug/${slug}`
+      );
+      return extractObjectData(response.data.data);
+    },
+    enabled: !!slug,
+    ...options
+  });
+}
+function useSpotByQR(qrCode, options) {
+  return reactQuery.useQuery({
+    queryKey: spotKeys.byQR(qrCode),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/spots/qr/${qrCode}`
+      );
+      return extractObjectData(response.data.data);
+    },
+    enabled: !!qrCode,
+    ...options
+  });
+}
+function useSpotImages(spotId, options) {
+  return reactQuery.useQuery({
+    queryKey: spotKeys.images(spotId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/spots/${spotId}/images`
+      );
+      return extractArrayData2(response.data.data);
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+function useSpotFavoriteStatus(spotId, options) {
+  return reactQuery.useQuery({
+    queryKey: [...spotKeys.detail(spotId), "favorite"],
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/spots/${spotId}/favorite`
+      );
+      return extractObjectData(response.data.data);
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+function useInfiniteSpots(params, options) {
+  return reactQuery.useInfiniteQuery({
+    queryKey: [...spotKeys.lists(), "infinite", params],
+    queryFn: async ({ pageParam = 1 }) => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      queryParams.set("page", String(pageParam));
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.city) queryParams.set("city", params.city);
+      if (params?.cityId) queryParams.set("cityId", params.cityId);
+      if (params?.type && params.type !== "All")
+        queryParams.set("type", params.type);
+      if (params?.search?.trim())
+        queryParams.set("search", params.search.trim());
+      if (params?.templateSlugs) {
+        params.templateSlugs.forEach(
+          (slug) => queryParams.append("templateSlugs", slug)
+        );
+      }
+      if (params?.vibeIds) {
+        params.vibeIds.forEach((id) => queryParams.append("vibeIds", id));
+      }
+      const response = await client.get(
+        `/spots?${queryParams}`
+      );
+      const data = response.data.data;
+      if (data && typeof data === "object" && "data" in data) {
+        return data;
+      }
+      const page = pageParam;
+      return {
+        data: extractArrayData2(data),
+        meta: {
+          total: 0,
+          page,
+          limit: params?.limit || 20,
+          totalPages: 1,
+          hasNextPage: false,
+          hasPreviousPage: page > 1
+        }
+      };
+    },
+    initialPageParam: 1,
+    getNextPageParam: (lastPage) => {
+      return lastPage.meta.hasNextPage ? lastPage.meta.page + 1 : void 0;
+    },
+    ...options
+  });
+}
+function extractArrayData3(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data && typeof data === "object" && "data" in data) {
+    const nested = data.data;
+    if (Array.isArray(nested)) {
+      return nested;
+    }
+  }
+  return [];
+}
+function extractObjectData2(data) {
+  if (data && typeof data === "object" && "data" in data && !Array.isArray(data)) {
+    const nested = data.data;
+    if (nested && typeof nested === "object" && "data" in nested && !Array.isArray(nested)) {
+      return nested.data;
+    }
+    return nested;
+  }
+  return data;
+}
+var postKeys = {
+  all: ["posts"],
+  lists: () => [...postKeys.all, "list"],
+  list: (filters) => [...postKeys.lists(), filters],
+  bySpot: (spotId, filters) => [...postKeys.all, "spot", spotId, filters],
+  details: () => [...postKeys.all, "detail"],
+  detail: (id) => [...postKeys.details(), id],
+  responses: (postId) => [...postKeys.detail(postId), "responses"],
+  status: (postId) => [...postKeys.detail(postId), "status"],
+  upvotes: (postId, filters) => [...postKeys.detail(postId), "upvotes", filters]
+};
+function useSpotPosts(spotId, params, options) {
+  return reactQuery.useQuery({
+    queryKey: postKeys.bySpot(spotId, params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.postType) queryParams.set("postType", params.postType);
+      if (params?.status) queryParams.set("status", params.status);
+      if (params?.page) queryParams.set("page", String(params.page));
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      const response = await client.get(
+        `/spots/${spotId}/posts?${queryParams}`
+      );
+      return extractArrayData3(response.data.data);
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+function usePost(postId, options) {
+  return reactQuery.useQuery({
+    queryKey: postKeys.detail(postId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/posts/${postId}`
+      );
+      return extractObjectData2(response.data.data);
+    },
+    enabled: !!postId,
+    ...options
+  });
+}
+function usePostResponses(postId, options) {
+  return reactQuery.useQuery({
+    queryKey: postKeys.responses(postId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/posts/${postId}/responses`
+      );
+      return extractArrayData3(response.data.data);
+    },
+    enabled: !!postId,
+    ...options
+  });
+}
+function usePosts(params, options) {
+  return reactQuery.useQuery({
+    queryKey: postKeys.list(params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.postType) queryParams.set("postType", params.postType);
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      const response = await client.get(
+        `/posts?${queryParams}`
+      );
+      return extractArrayData3(response.data.data);
+    },
+    ...options
+  });
+}
+function usePostStatus(postId, options) {
+  return reactQuery.useQuery({
+    queryKey: postKeys.status(postId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/posts/${postId}/status`
+      );
+      return extractObjectData2(response.data.data);
+    },
+    enabled: !!postId,
+    ...options
+  });
+}
+function usePostUpvotes(postId, params, options) {
+  return reactQuery.useQuery({
+    queryKey: postKeys.upvotes(postId, params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.offset) queryParams.set("offset", String(params.offset));
+      const queryString = queryParams.toString();
+      const response = await client.get(
+        `/posts/${postId}/upvotes${queryString ? `?${queryString}` : ""}`
+      );
+      return response.data.data;
+    },
+    enabled: !!postId,
+    ...options
+  });
+}
+function usePostsFeed(params, options) {
+  return reactQuery.useQuery({
+    queryKey: [...postKeys.lists(), "feed", params],
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      queryParams.set("lat", String(params.lat));
+      queryParams.set("lng", String(params.lng));
+      if (params.radius) queryParams.set("radius", String(params.radius));
+      if (params.postType) queryParams.set("postType", params.postType);
+      if (params.cursor) queryParams.set("cursor", params.cursor);
+      if (params.limit) queryParams.set("limit", String(params.limit));
+      const response = await client.get(`/posts/feed?${queryParams}`);
+      const data = response.data.data;
+      return {
+        posts: data.posts ?? extractArrayData3(data),
+        hasMore: data.hasMore ?? false,
+        nextCursor: data.nextCursor
+      };
+    },
+    enabled: params.lat !== 0 && params.lng !== 0,
+    ...options
+  });
+}
+var conversationKeys = {
+  all: ["conversations"],
+  lists: () => [...conversationKeys.all, "list"],
+  list: () => [...conversationKeys.lists()],
+  details: () => [...conversationKeys.all, "detail"],
+  detail: (id) => [...conversationKeys.details(), id],
+  messages: (conversationId, params) => [...conversationKeys.detail(conversationId), "messages", params]
+};
+function useConversations(options) {
+  return reactQuery.useQuery({
+    queryKey: conversationKeys.list(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/conversations");
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useConversation(conversationId, options) {
+  return reactQuery.useQuery({
+    queryKey: conversationKeys.detail(conversationId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/conversations/${conversationId}`
+      );
+      return response.data.data;
+    },
+    enabled: !!conversationId,
+    ...options
+  });
+}
+function useConversationMessages(conversationId, params, options) {
+  return reactQuery.useQuery({
+    queryKey: conversationKeys.messages(conversationId, params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.before) queryParams.set("before", params.before);
+      const response = await client.get(`/conversations/${conversationId}/messages?${queryParams}`);
+      return response.data;
+    },
+    enabled: !!conversationId,
+    ...options
+  });
+}
+var clubKeys = {
+  all: ["clubs"],
+  bySpot: (spotId) => [...clubKeys.all, "spot", spotId],
+  details: () => [...clubKeys.all, "detail"],
+  detail: (id) => [...clubKeys.details(), id],
+  bySlug: (slug) => [...clubKeys.all, "slug", slug],
+  byUser: (userId) => [...clubKeys.all, "user", userId],
+  membership: (clubId, userId) => [...clubKeys.detail(clubId), "membership", userId]
+};
+function useClubsBySpot(spotId, options) {
+  return reactQuery.useQuery({
+    queryKey: clubKeys.bySpot(spotId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/clubs/spot/${spotId}`
+      );
+      return response.data.data;
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+function useClub(clubId, options) {
+  return reactQuery.useQuery({
+    queryKey: clubKeys.detail(clubId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(`/clubs/${clubId}`);
+      return response.data.data;
+    },
+    enabled: !!clubId,
+    ...options
+  });
+}
+function useClubBySlug(slug, options) {
+  return reactQuery.useQuery({
+    queryKey: clubKeys.bySlug(slug),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/clubs/slug/${slug}`
+      );
+      return response.data.data;
+    },
+    enabled: !!slug,
+    ...options
+  });
+}
+function useClubsByUser(userId, options) {
+  return reactQuery.useQuery({
+    queryKey: clubKeys.byUser(userId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/clubs/user/${userId}`
+      );
+      return response.data.data;
+    },
+    enabled: !!userId,
+    ...options
+  });
+}
+function useClubMembership(clubId, userId, options) {
+  return reactQuery.useQuery({
+    queryKey: clubKeys.membership(clubId, userId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(`/clubs/${clubId}/membership/${userId}`);
+      return response.data.data;
+    },
+    enabled: !!clubId && !!userId,
+    ...options
+  });
+}
+var templateKeys = {
+  all: ["templates"],
+  lists: () => [...templateKeys.all, "list"],
+  list: (filters) => [...templateKeys.lists(), filters],
+  details: () => [...templateKeys.all, "detail"],
+  detail: (id) => [...templateKeys.details(), id],
+  bySlug: (slug) => [...templateKeys.all, "slug", slug]
+};
+function useTemplates(params, options) {
+  return reactQuery.useQuery({
+    queryKey: templateKeys.list(params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.spotType) queryParams.set("spotType", params.spotType);
+      const response = await client.get(
+        `/templates?${queryParams}`
+      );
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useTemplate(templateId, options) {
+  return reactQuery.useQuery({
+    queryKey: templateKeys.detail(templateId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/templates/${templateId}`
+      );
+      return response.data.data;
+    },
+    enabled: !!templateId,
+    ...options
+  });
+}
+function useTemplateBySlug(slug, options) {
+  return reactQuery.useQuery({
+    queryKey: templateKeys.bySlug(slug),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/templates/slug/${slug}`
+      );
+      return response.data.data;
+    },
+    enabled: !!slug,
+    ...options
+  });
+}
+var notificationKeys = {
+  all: ["notifications"],
+  lists: () => [...notificationKeys.all, "list"],
+  list: (params) => [...notificationKeys.lists(), params],
+  unreadCount: () => [...notificationKeys.all, "unreadCount"]
+};
+function useNotifications(params, options) {
+  return reactQuery.useQuery({
+    queryKey: notificationKeys.list(params),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.unreadOnly)
+        queryParams.set("unreadOnly", String(params.unreadOnly));
+      const response = await client.get(
+        `/notifications?${queryParams}`
+      );
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useUnreadNotificationCount(options) {
+  return reactQuery.useQuery({
+    queryKey: notificationKeys.unreadCount(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        "/notifications/unread-count"
+      );
+      return response.data.data.count;
+    },
+    ...options
+  });
+}
+function extractArrayData4(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data && typeof data === "object" && "data" in data) {
+    const nested = data.data;
+    if (Array.isArray(nested)) {
+      return nested;
+    }
+  }
+  return [];
+}
+var miscKeys = {
+  cities: () => ["cities"],
+  vibes: () => ["vibes"],
+  lifeSituations: () => ["life-situations"]
+};
+function useCities(options) {
+  return reactQuery.useQuery({
+    queryKey: miscKeys.cities(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/cities");
+      return extractArrayData4(response.data.data);
+    },
+    staleTime: 1e3 * 60 * 60,
+    ...options
+  });
+}
+function useVibes(options) {
+  return reactQuery.useQuery({
+    queryKey: miscKeys.vibes(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/vibes");
+      return extractArrayData4(response.data.data);
+    },
+    staleTime: 1e3 * 60 * 60,
+    ...options
+  });
+}
+function useLifeSituations(options) {
+  return reactQuery.useQuery({
+    queryKey: miscKeys.lifeSituations(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/life-situations");
+      return extractArrayData4(response.data.data);
+    },
+    staleTime: 1e3 * 60 * 60,
+    ...options
+  });
+}
+var productKeys = {
+  all: ["products"],
+  lists: () => [...productKeys.all, "list"],
+  list: (filters) => [...productKeys.lists(), filters],
+  details: () => [...productKeys.all, "detail"],
+  detail: (id) => [...productKeys.details(), id],
+  bySlug: (spotId, slug) => [...productKeys.all, "slug", spotId, slug],
+  bySpot: (spotId) => [...productKeys.all, "spot", spotId]
+};
+function useSpotProducts(spotId, params, options) {
+  return reactQuery.useQuery({
+    queryKey: productKeys.bySpot(spotId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.page) queryParams.set("page", String(params.page));
+      if (params?.type) queryParams.set("type", params.type);
+      const response = await client.get(
+        `/spots/${spotId}/products?${queryParams}`
+      );
+      return response.data.data;
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+function useProduct(productId, options) {
+  return reactQuery.useQuery({
+    queryKey: productKeys.detail(productId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/products/${productId}`
+      );
+      return response.data.data;
+    },
+    enabled: !!productId,
+    ...options
+  });
+}
+function useProductBySlug(spotId, slug, options) {
+  return reactQuery.useQuery({
+    queryKey: productKeys.bySlug(spotId, slug),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/spots/${spotId}/products/slug/${slug}`
+      );
+      return response.data.data;
+    },
+    enabled: !!spotId && !!slug,
+    ...options
+  });
+}
+var orderKeys = {
+  all: ["orders"],
+  lists: () => [...orderKeys.all, "list"],
+  list: (filters) => [...orderKeys.lists(), filters],
+  details: () => [...orderKeys.all, "detail"],
+  detail: (id) => [...orderKeys.details(), id],
+  myOrders: () => [...orderKeys.all, "my"],
+  spotOrders: (spotId) => [...orderKeys.all, "spot", spotId]
+};
+function useMyOrders(params, options) {
+  return reactQuery.useQuery({
+    queryKey: orderKeys.list({ ...params, my: true }),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.status) queryParams.set("status", params.status);
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.page) queryParams.set("page", String(params.page));
+      const response = await client.get(`/users/me/orders?${queryParams}`);
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useOrder(orderId, options) {
+  return reactQuery.useQuery({
+    queryKey: orderKeys.detail(orderId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/orders/${orderId}`
+      );
+      return response.data.data;
+    },
+    enabled: !!orderId,
+    ...options
+  });
+}
+function useSpotOrders(spotId, params, options) {
+  return reactQuery.useQuery({
+    queryKey: orderKeys.spotOrders(spotId),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.status) queryParams.set("status", params.status);
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      if (params?.page) queryParams.set("page", String(params.page));
+      const response = await client.get(`/seller/spots/${spotId}/orders?${queryParams}`);
+      return response.data.data;
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+function extractArrayData5(data) {
+  if (Array.isArray(data)) {
+    return data;
+  }
+  if (data && typeof data === "object" && "data" in data) {
+    const nested = data.data;
+    if (Array.isArray(nested)) {
+      return nested;
+    }
+  }
+  return [];
+}
+function extractObjectData3(data) {
+  if (data && typeof data === "object" && "data" in data && !Array.isArray(data)) {
+    const nested = data.data;
+    if (nested && typeof nested === "object" && "data" in nested && !Array.isArray(nested)) {
+      return nested.data;
+    }
+    return nested;
+  }
+  return data;
+}
+var walletKeys = {
+  all: ["wallet"],
+  active: () => [...walletKeys.all, "active"],
+  history: (page) => [...walletKeys.all, "history", page],
+  redemptions: () => ["redemptions"],
+  lookup: (qrCode) => [...walletKeys.redemptions(), "lookup", qrCode],
+  spotRedemptions: (spotId, page) => [...walletKeys.redemptions(), "spot", spotId, page]
+};
+function useWallet(options) {
+  return reactQuery.useQuery({
+    queryKey: walletKeys.active(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get("/wallet");
+      return extractArrayData5(response.data.data);
+    },
+    ...options
+  });
+}
+function useWalletHistory(params, options) {
+  return reactQuery.useQuery({
+    queryKey: walletKeys.history(params?.page),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.page) queryParams.set("page", String(params.page));
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      const response = await client.get(
+        `/wallet/history?${queryParams}`
+      );
+      return extractObjectData3(response.data.data);
+    },
+    ...options
+  });
+}
+function useRedemptionLookup(qrCode, options) {
+  return reactQuery.useQuery({
+    queryKey: walletKeys.lookup(qrCode),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        `/redemptions/lookup/${qrCode}`
+      );
+      return extractObjectData3(response.data.data);
+    },
+    enabled: !!qrCode && qrCode.length > 0,
+    ...options
+  });
+}
+function useSpotRedemptions(spotId, params, options) {
+  return reactQuery.useQuery({
+    queryKey: walletKeys.spotRedemptions(spotId, params?.page),
+    queryFn: async () => {
+      const client = getApiClient();
+      const queryParams = new URLSearchParams();
+      if (params?.page) queryParams.set("page", String(params.page));
+      if (params?.limit) queryParams.set("limit", String(params.limit));
+      const response = await client.get(
+        `/spots/${spotId}/redemptions?${queryParams}`
+      );
+      return extractObjectData3(response.data.data);
+    },
+    enabled: !!spotId,
+    ...options
+  });
+}
+var paymentKeys = {
+  all: ["payments"],
+  config: () => [...paymentKeys.all, "config"]
+};
+function usePaymentConfig(options) {
+  return reactQuery.useQuery({
+    queryKey: paymentKeys.config(),
+    queryFn: async () => {
+      const client = getApiClient();
+      const response = await client.get(
+        "/payments/config"
+      );
+      return response.data.data;
+    },
+    staleTime: 1e3 * 60 * 60,
+    // 1 hour - config rarely changes
+    ...options
+  });
+}
+function useUpdateProfile(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.put("/users/me", data);
+      return response.data.data;
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(userKeys.me(), data);
+    },
+    ...options
+  });
+}
+function useUploadAvatar(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (formData) => {
+      const client = getApiClient();
+      const response = await client.post(
+        "/users/me/avatar",
+        formData,
+        {
+          headers: { "Content-Type": "multipart/form-data" }
+        }
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+    },
+    ...options
+  });
+}
+function useDeleteAccount(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async () => {
+      const client = getApiClient();
+      await client.delete("/users/me");
+    },
+    onSuccess: () => {
+      queryClient.clear();
+    },
+    ...options
+  });
+}
+function useUpdateVibes(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.put(
+        "/users/me/vibes",
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+    },
+    ...options
+  });
+}
+function useUpdateInterests(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.put(
+        "/user/me/interests",
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+    },
+    ...options
+  });
+}
+function useCompleteOnboardingStep(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post(
+        "/user/me/onboarding-step",
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.me() });
+    },
+    ...options
+  });
+}
+function useBlockUser(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (userId) => {
+      const client = getApiClient();
+      await client.post(`/users/${userId}/block`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.blocked() });
+    },
+    ...options
+  });
+}
+function useUnblockUser(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (userId) => {
+      const client = getApiClient();
+      await client.delete(`/users/${userId}/block`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.blocked() });
+    },
+    ...options
+  });
+}
+function useCreatePost(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ spotId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/spots/${spotId}/posts`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: postKeys.bySpot(variables.spotId)
+      });
+    },
+    ...options
+  });
+}
+function useUpdatePost(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ postId, title, content }) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/posts/${postId}`,
+        { title, description: content }
+      );
+      return response.data.data;
+    },
+    onSuccess: (data, variables) => {
+      queryClient.setQueryData(postKeys.detail(variables.postId), data);
+    },
+    ...options
+  });
+}
+function useDeletePost(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (postId) => {
+      const client = getApiClient();
+      await client.delete(`/posts/${postId}`);
+    },
+    onSuccess: (_, postId) => {
+      queryClient.invalidateQueries({ queryKey: postKeys.detail(postId) });
+      queryClient.invalidateQueries({ queryKey: postKeys.lists() });
+    },
+    ...options
+  });
+}
+function useFulfillPost(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (postId) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/posts/${postId}/fulfill`
+      );
+      return response.data.data;
+    },
+    onSuccess: (data, postId) => {
+      queryClient.setQueryData(postKeys.detail(postId), data);
+    },
+    ...options
+  });
+}
+function useUpvotePost(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (postId) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/posts/${postId}/upvote`
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, postId) => {
+      queryClient.invalidateQueries({ queryKey: postKeys.detail(postId) });
+    },
+    ...options
+  });
+}
+function useCreateReply(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ postId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/posts/${postId}/reply`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: postKeys.detail(variables.postId)
+      });
+    },
+    ...options
+  });
+}
+function useDeleteReply(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ replyId }) => {
+      const client = getApiClient();
+      await client.delete(`/replies/${replyId}`);
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: postKeys.detail(variables.postId)
+      });
+    },
+    ...options
+  });
+}
+function useRespondToPost(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ postId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/posts/${postId}/respond`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: postKeys.detail(variables.postId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: postKeys.responses(variables.postId)
+      });
+    },
+    ...options
+  });
+}
+function useUpdateResponse(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({
+      responseId,
+      postId: _,
+      ...data
+    }) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/responses/${responseId}`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: postKeys.responses(variables.postId)
+      });
+    },
+    ...options
+  });
+}
+function useReportPost(options) {
+  return reactQuery.useMutation({
+    mutationFn: async ({ postId, ...data }) => {
+      const client = getApiClient();
+      await client.post(`/posts/${postId}/report`, data);
+    },
+    ...options
+  });
+}
+function useUpdatePostStatus(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ postId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/posts/${postId}/status`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (data, variables) => {
+      queryClient.setQueryData(postKeys.status(variables.postId), data);
+    },
+    ...options
+  });
+}
+function useCreateSpot(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post("/spots", data);
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: spotKeys.lists() });
+    },
+    ...options
+  });
+}
+function useUpdateSpot(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ spotId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/spots/${spotId}`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (data, variables) => {
+      queryClient.setQueryData(spotKeys.detail(variables.spotId), data);
+    },
+    ...options
+  });
+}
+function useClaimSpot(options) {
+  return reactQuery.useMutation({
+    mutationFn: async ({ spotId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/spots/${spotId}/claim`,
+        data
+      );
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useSubscribeToSpot(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (spotId) => {
+      const client = getApiClient();
+      await client.post(`/spots/${spotId}/subscribe`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.subscriptions() });
+    },
+    ...options
+  });
+}
+function useUnsubscribeFromSpot(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (spotId) => {
+      const client = getApiClient();
+      await client.delete(`/spots/${spotId}/subscribe`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.subscriptions() });
+    },
+    ...options
+  });
+}
+function useFavoriteSpot(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (spotId) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/spots/${spotId}/favorite`
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: userKeys.favorites() });
+    },
+    ...options
+  });
+}
+function useRateSpot(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({
+      spotId,
+      rating
+    }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/spots/${spotId}/rate`,
+        { rating }
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: spotKeys.detail(variables.spotId)
+      });
+    },
+    ...options
+  });
+}
+function useReportSpot(options) {
+  return reactQuery.useMutation({
+    mutationFn: async ({
+      spotId,
+      reason,
+      details
+    }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/spots/${spotId}/report`,
+        { reason, details }
+      );
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useCreateConversation(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post(
+        "/conversations",
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: conversationKeys.lists() });
+    },
+    ...options
+  });
+}
+function useCreateDirectConversation(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post(
+        "/conversations/direct",
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: conversationKeys.lists() });
+    },
+    ...options
+  });
+}
+function useSendMessage(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ conversationId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/conversations/${conversationId}/messages`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: conversationKeys.messages(variables.conversationId)
+      });
+      queryClient.invalidateQueries({ queryKey: conversationKeys.lists() });
+    },
+    ...options
+  });
+}
+function useMarkConversationAsRead(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (conversationId) => {
+      const client = getApiClient();
+      await client.put(`/conversations/${conversationId}/read`);
+    },
+    onSuccess: (_, conversationId) => {
+      queryClient.invalidateQueries({
+        queryKey: conversationKeys.detail(conversationId)
+      });
+      queryClient.invalidateQueries({ queryKey: conversationKeys.lists() });
+    },
+    ...options
+  });
+}
+function useSendTypingIndicator(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (conversationId) => {
+      const client = getApiClient();
+      await client.post(`/conversations/${conversationId}/typing`);
+    },
+    ...options
+  });
+}
+function useCreateClub(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post("/clubs", data);
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: clubKeys.bySpot(variables.spotId)
+      });
+    },
+    ...options
+  });
+}
+function useUpdateClub(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ clubId, ...data }) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/clubs/${clubId}`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (data, variables) => {
+      queryClient.setQueryData(clubKeys.detail(variables.clubId), data);
+    },
+    ...options
+  });
+}
+function useJoinClub(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (clubId) => {
+      const client = getApiClient();
+      await client.post(`/clubs/${clubId}/join`);
+    },
+    onSuccess: (_, clubId) => {
+      queryClient.invalidateQueries({ queryKey: clubKeys.detail(clubId) });
+      queryClient.invalidateQueries({ queryKey: userKeys.clubs() });
+    },
+    ...options
+  });
+}
+function useLeaveClub(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (clubId) => {
+      const client = getApiClient();
+      await client.post(`/clubs/${clubId}/leave`);
+    },
+    onSuccess: (_, clubId) => {
+      queryClient.invalidateQueries({ queryKey: clubKeys.detail(clubId) });
+      queryClient.invalidateQueries({ queryKey: userKeys.clubs() });
+    },
+    ...options
+  });
+}
+function useMarkNotificationsRead(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      await client.put("/notifications/read", data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: notificationKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: notificationKeys.unreadCount() });
+    },
+    ...options
+  });
+}
+function useRegisterDeviceToken(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      await client.post("/device-tokens", data);
+    },
+    ...options
+  });
+}
+function useRemoveDeviceToken(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      await client.delete("/device-tokens", { data });
+    },
+    ...options
+  });
+}
+function generateSlug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 100);
+}
+function useCreateProduct(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const { spotId, slug, ...productData } = data;
+      const productSlug = slug || generateSlug(productData.name);
+      const response = await client.post(
+        `/spots/${spotId}/products`,
+        { ...productData, slug: productSlug }
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(variables.spotId) });
+      queryClient.invalidateQueries({ queryKey: productKeys.list({ my: true }) });
+    },
+    ...options
+  });
+}
+function useUpdateProduct(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ productId, data }) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/products/${productId}`,
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(productKeys.detail(data.id), data);
+      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(data.spotId) });
+      queryClient.invalidateQueries({ queryKey: productKeys.list({ my: true }) });
+    },
+    ...options
+  });
+}
+function useDeleteProduct(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (productId) => {
+      const client = getApiClient();
+      await client.delete(`/products/${productId}`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: productKeys.all });
+    },
+    ...options
+  });
+}
+function useAdjustStock(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ productId, quantity, reason, notes }) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/products/${productId}/stock`,
+        { quantity, reason, notes }
+      );
+      return response.data.data;
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(productKeys.detail(data.id), data);
+      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(data.spotId) });
+    },
+    ...options
+  });
+}
+function useCreateOrder(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (data) => {
+      const client = getApiClient();
+      const response = await client.post(
+        "/orders",
+        data
+      );
+      return response.data.data;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(variables.spotId) });
+      queryClient.invalidateQueries({ queryKey: orderKeys.list({ my: true }) });
+    },
+    ...options
+  });
+}
+function useCreateStripeIntent(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (orderId) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/payments/stripe/intent/${orderId}`
+      );
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useCreateCoinbaseCharge(options) {
+  return reactQuery.useMutation({
+    mutationFn: async (orderId) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/payments/coinbase/charge/${orderId}`
+      );
+      return response.data.data;
+    },
+    ...options
+  });
+}
+function useUpdateOrderStatus(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({ orderId, status }) => {
+      const client = getApiClient();
+      const response = await client.put(
+        `/orders/${orderId}/status`,
+        { status }
+      );
+      return response.data.data;
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(orderKeys.detail(data.id), data);
+      queryClient.invalidateQueries({ queryKey: orderKeys.spotOrders(data.spotId) });
+    },
+    ...options
+  });
+}
+function useCancelOrder(options) {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (orderId) => {
+      const client = getApiClient();
+      const response = await client.post(
+        `/orders/${orderId}/cancel`
+      );
+      return response.data.data;
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(orderKeys.detail(data.id), data);
+      queryClient.invalidateQueries({ queryKey: orderKeys.list({ my: true }) });
+      queryClient.invalidateQueries({ queryKey: productKeys.bySpot(data.spotId) });
+    },
+    ...options
+  });
+}
+function useRedeem() {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (request) => {
+      const client = getApiClient();
+      const response = await client.post("/redemptions/redeem", request);
+      return response.data.data;
+    },
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: walletKeys.lookup(variables.qrCode)
+      });
+      if (variables.spotId) {
+        queryClient.invalidateQueries({
+          queryKey: walletKeys.spotRedemptions(variables.spotId)
+        });
+      }
+    }
+  });
+}
+function useVoidRedemption() {
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async ({
+      redemptionId,
+      reason
+    }) => {
+      const client = getApiClient();
+      const response = await client.put(`/redemptions/${redemptionId}/void`, { reason });
+      return response.data.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: walletKeys.all });
+      queryClient.invalidateQueries({ queryKey: walletKeys.redemptions() });
+    }
+  });
+}
+
+exports.clubKeys = clubKeys;
+exports.configureSDK = configureSDK;
+exports.conversationKeys = conversationKeys;
+exports.getApiClient = getApiClient;
+exports.getConfig = getConfig;
+exports.miscKeys = miscKeys;
+exports.notificationKeys = notificationKeys;
+exports.orderKeys = orderKeys;
+exports.paymentKeys = paymentKeys;
+exports.postKeys = postKeys;
+exports.productKeys = productKeys;
+exports.spotKeys = spotKeys;
+exports.templateKeys = templateKeys;
+exports.useAdjustStock = useAdjustStock;
+exports.useBlockUser = useBlockUser;
+exports.useBlockedUsers = useBlockedUsers;
+exports.useCancelOrder = useCancelOrder;
+exports.useCities = useCities;
+exports.useClaimSpot = useClaimSpot;
+exports.useClub = useClub;
+exports.useClubBySlug = useClubBySlug;
+exports.useClubMembership = useClubMembership;
+exports.useClubsBySpot = useClubsBySpot;
+exports.useClubsByUser = useClubsByUser;
+exports.useCompleteOnboardingStep = useCompleteOnboardingStep;
+exports.useConversation = useConversation;
+exports.useConversationMessages = useConversationMessages;
+exports.useConversations = useConversations;
+exports.useCreateClub = useCreateClub;
+exports.useCreateCoinbaseCharge = useCreateCoinbaseCharge;
+exports.useCreateConversation = useCreateConversation;
+exports.useCreateDirectConversation = useCreateDirectConversation;
+exports.useCreateOrder = useCreateOrder;
+exports.useCreatePost = useCreatePost;
+exports.useCreateProduct = useCreateProduct;
+exports.useCreateReply = useCreateReply;
+exports.useCreateSpot = useCreateSpot;
+exports.useCreateStripeIntent = useCreateStripeIntent;
+exports.useCurrentUser = useCurrentUser;
+exports.useDeleteAccount = useDeleteAccount;
+exports.useDeletePost = useDeletePost;
+exports.useDeleteProduct = useDeleteProduct;
+exports.useDeleteReply = useDeleteReply;
+exports.useFavoriteSpot = useFavoriteSpot;
+exports.useFulfillPost = useFulfillPost;
+exports.useInfiniteSpots = useInfiniteSpots;
+exports.useJoinClub = useJoinClub;
+exports.useLeaveClub = useLeaveClub;
+exports.useLifeSituations = useLifeSituations;
+exports.useMarkConversationAsRead = useMarkConversationAsRead;
+exports.useMarkNotificationsRead = useMarkNotificationsRead;
+exports.useMyOrders = useMyOrders;
+exports.useNotifications = useNotifications;
+exports.useOrder = useOrder;
+exports.useOwnedSpots = useOwnedSpots;
+exports.usePaymentConfig = usePaymentConfig;
+exports.usePost = usePost;
+exports.usePostResponses = usePostResponses;
+exports.usePostStatus = usePostStatus;
+exports.usePostUpvotes = usePostUpvotes;
+exports.usePosts = usePosts;
+exports.usePostsFeed = usePostsFeed;
+exports.useProduct = useProduct;
+exports.useProductBySlug = useProductBySlug;
+exports.useRateSpot = useRateSpot;
+exports.useRedeem = useRedeem;
+exports.useRedemptionLookup = useRedemptionLookup;
+exports.useRefreshToken = useRefreshToken;
+exports.useRegisterDeviceToken = useRegisterDeviceToken;
+exports.useRemoveDeviceToken = useRemoveDeviceToken;
+exports.useReportPost = useReportPost;
+exports.useReportSpot = useReportSpot;
+exports.useRespondToPost = useRespondToPost;
+exports.useSendMessage = useSendMessage;
+exports.useSendOtp = useSendOtp;
+exports.useSendTypingIndicator = useSendTypingIndicator;
+exports.useSpot = useSpot;
+exports.useSpotByQR = useSpotByQR;
+exports.useSpotBySlug = useSpotBySlug;
+exports.useSpotFavoriteStatus = useSpotFavoriteStatus;
+exports.useSpotImages = useSpotImages;
+exports.useSpotOrders = useSpotOrders;
+exports.useSpotPosts = useSpotPosts;
+exports.useSpotProducts = useSpotProducts;
+exports.useSpotRedemptions = useSpotRedemptions;
+exports.useSpots = useSpots;
+exports.useSubscribeToSpot = useSubscribeToSpot;
+exports.useTemplate = useTemplate;
+exports.useTemplateBySlug = useTemplateBySlug;
+exports.useTemplates = useTemplates;
+exports.useUnblockUser = useUnblockUser;
+exports.useUnreadNotificationCount = useUnreadNotificationCount;
+exports.useUnsubscribeFromSpot = useUnsubscribeFromSpot;
+exports.useUpdateClub = useUpdateClub;
+exports.useUpdateInterests = useUpdateInterests;
+exports.useUpdateOrderStatus = useUpdateOrderStatus;
+exports.useUpdatePost = useUpdatePost;
+exports.useUpdatePostStatus = useUpdatePostStatus;
+exports.useUpdateProduct = useUpdateProduct;
+exports.useUpdateProfile = useUpdateProfile;
+exports.useUpdateResponse = useUpdateResponse;
+exports.useUpdateSpot = useUpdateSpot;
+exports.useUpdateVibes = useUpdateVibes;
+exports.useUploadAvatar = useUploadAvatar;
+exports.useUpvotePost = useUpvotePost;
+exports.useUserActivity = useUserActivity;
+exports.useUserClubs = useUserClubs;
+exports.useUserFavorites = useUserFavorites;
+exports.useUserPosts = useUserPosts;
+exports.useUserSpotsSummary = useUserSpotsSummary;
+exports.useUserStats = useUserStats;
+exports.useUserSubscriptions = useUserSubscriptions;
+exports.useVerifyOtp = useVerifyOtp;
+exports.useVibes = useVibes;
+exports.useVoidRedemption = useVoidRedemption;
+exports.useWallet = useWallet;
+exports.useWalletHistory = useWalletHistory;
+exports.userKeys = userKeys;
+exports.walletKeys = walletKeys;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map