@spotsdev/sdk 1.0.0 → 1.2.0

package/dist/api/client.d.ts

@@ -1,4 +1,4 @@
-import { AxiosInstance } from 'axios';
+import { type AxiosInstance } from 'axios';
 export interface SDKConfig {
     baseURL: string;
     getAccessToken: () => string | null | Promise<string | null>;

package/dist/api/client.js

@@ -40,10 +40,14 @@ function createApiClient(sdkConfig) {
         if (token) {
             requestConfig.headers.Authorization = `Bearer ${token}`;
         }
+        // Debug logging
+        console.log(`[SDK] ${requestConfig.method?.toUpperCase()} ${sdkConfig.baseURL}${requestConfig.url}`);
         return requestConfig;
-    }, (error) => Promise.reject(error));
+    }, error => Promise.reject(error));
     // Response interceptor - handle 401
-    client.interceptors.response.use((response) => response, async (error) => {
+    client.interceptors.response.use(response => response, async (error) => {
+        console.log(`[SDK] Error: ${error.response?.status} ${error.config?.url}`, error.message);
+        // Handle auth token expiration (401)
         if (error.response?.status === 401) {
             if (sdkConfig.refreshAccessToken) {
                 try {
@@ -65,4 +69,4 @@ function createApiClient(sdkConfig) {
     });
     return client;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/entities.d.ts

@@ -0,0 +1,318 @@
+/**
+ * Spots SDK Entity Types
+ *
+ * These types mirror the Prisma schema entities but without @prisma/client dependency.
+ * This allows the SDK to work in React Native where Prisma is not available.
+ */
+export type SpotType = 'CAFE' | 'RESTAURANT' | 'BAR' | 'PARK' | 'BEACH' | 'COWORKING' | 'LIBRARY' | 'GYM' | 'MUSEUM' | 'GALLERY' | 'THEATER' | 'CINEMA' | 'MALL' | 'MARKET' | 'HOTEL' | 'HOSTEL' | 'OTHER';
+export type SpotPostType = 'CHECK_IN' | 'LOOKING_FOR' | 'OFFERING' | 'QUESTION' | 'EVENT' | 'RECOMMENDATION' | 'GENERAL';
+export type AccountStatus = 'ACTIVE' | 'SUSPENDED' | 'DELETED' | 'PENDING';
+export type ClaimStatus = 'PENDING' | 'APPROVED' | 'REJECTED';
+export type ResponseStatus = 'PENDING' | 'ACCEPTED' | 'DECLINED';
+export type ReportReason = 'SPAM' | 'HARASSMENT' | 'INAPPROPRIATE' | 'SCAM' | 'OTHER';
+export type ReportStatus = 'PENDING' | 'REVIEWED' | 'RESOLVED' | 'DISMISSED';
+export type NotificationType = 'POST_RESPONSE' | 'POST_REPLY' | 'POST_UPVOTE' | 'RESPONSE_ACCEPTED' | 'RESPONSE_DECLINED' | 'NEW_MESSAGE' | 'SYSTEM';
+export interface User {
+    id: string;
+    phone: string | null;
+    email: string | null;
+    name: string | null;
+    bio: string | null;
+    avatarUrl: string | null;
+    status: AccountStatus;
+    onboardingCompleted: boolean;
+    lastActiveAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Spot {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    address: string | null;
+    city: string | null;
+    country: string | null;
+    latitude: number | null;
+    longitude: number | null;
+    lat?: number | null;
+    lng?: number | null;
+    type: SpotType;
+    googlePlaceId: string | null;
+    website: string | null;
+    phone: string | null;
+    imageUrl: string | null;
+    ownerId: string | null;
+    isVerified: boolean;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+}
+export interface SpotPost {
+    id: string;
+    spotId: string;
+    userId: string;
+    postType: SpotPostType;
+    title: string;
+    content: string | null;
+    emoji: string | null;
+    expiresAt: Date | null;
+    status: 'ACTIVE' | 'FULFILLED' | 'EXPIRED' | 'DELETED';
+    upvoteCount: number;
+    responseCount: number;
+    replyCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+    user?: User;
+    spot?: Spot;
+}
+export interface PostReply {
+    id: string;
+    postId: string;
+    userId: string;
+    content: string;
+    createdAt: Date;
+    updatedAt: Date;
+    user?: User;
+}
+export interface PostResponse {
+    id: string;
+    postId: string;
+    userId: string;
+    note: string | null;
+    status: ResponseStatus;
+    createdAt: Date;
+    updatedAt: Date;
+    user?: User;
+    post?: SpotPost;
+}
+export interface PostUpvote {
+    id: string;
+    postId: string;
+    userId: string;
+    createdAt: Date;
+}
+/**
+ * PostUpvoter - user who upvoted a post (from /posts/:id/upvotes endpoint)
+ */
+export interface PostUpvoter {
+    id: string;
+    userId: string;
+    name: string | null;
+    avatarUrl: string | null;
+    createdAt: Date;
+}
+/**
+ * PostUpvotesResponse - response from /posts/:id/upvotes endpoint
+ */
+export interface PostUpvotesResponse {
+    data: PostUpvoter[];
+    meta: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        currentUserUpvoted: boolean;
+        isPostAuthor: boolean;
+    };
+}
+export interface PostReport {
+    id: string;
+    postId: string;
+    userId: string;
+    reason: ReportReason;
+    details: string | null;
+    status: ReportStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Club {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    imageUrl: string | null;
+    isPrivate: boolean;
+    createdById: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ClubMember {
+    id: string;
+    clubId: string;
+    userId: string;
+    role: 'MEMBER' | 'ADMIN' | 'OWNER';
+    joinedAt: Date;
+}
+export interface Conversation {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    participants?: User[];
+    messages?: Message[];
+}
+export interface Message {
+    id: string;
+    conversationId: string;
+    senderId: string;
+    content: string;
+    createdAt: Date;
+    sender?: User;
+}
+export interface Notification {
+    id: string;
+    userId: string;
+    type: NotificationType;
+    title: string;
+    body: string | null;
+    data: Record<string, unknown> | null;
+    isRead: boolean;
+    createdAt: Date;
+}
+export interface PostTemplate {
+    id: string;
+    postType: SpotPostType;
+    emoji: string;
+    title: string;
+    placeholder: string | null;
+    isActive: boolean;
+    sortOrder: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Vibe {
+    id: string;
+    name: string;
+    emoji: string | null;
+    createdAt: Date;
+}
+export interface Interest {
+    id: string;
+    name: string;
+    emoji: string | null;
+    category: string | null;
+    createdAt: Date;
+}
+export interface Intention {
+    id: string;
+    name: string;
+    emoji: string | null;
+    createdAt: Date;
+}
+export interface LifeSituation {
+    id: string;
+    name: string;
+    emoji: string | null;
+    createdAt: Date;
+}
+export interface FavoriteSpot {
+    id: string;
+    userId: string;
+    spotId: string;
+    createdAt: Date;
+    spot?: Spot;
+}
+export interface SpotImage {
+    id: string;
+    spotId: string;
+    url: string;
+    caption: string | null;
+    sortOrder: number;
+    createdAt: Date;
+}
+export interface SpotVibe {
+    id: string;
+    spotId: string;
+    vibeId: string;
+    vibe?: Vibe;
+}
+export interface SpotIntention {
+    id: string;
+    spotId: string;
+    intentionId: string;
+    intention?: Intention;
+}
+export interface SpotClaim {
+    id: string;
+    spotId: string;
+    userId: string;
+    status: ClaimStatus;
+    verificationMethod: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface SpotSubscription {
+    id: string;
+    spotId: string;
+    userId: string;
+    createdAt: Date;
+    spot?: Spot;
+}
+export interface City {
+    id: string;
+    name: string;
+    country: string;
+    latitude: number;
+    longitude: number;
+    timezone: string | null;
+    createdAt: Date;
+}
+/**
+ * Paginated response with meta information
+ */
+export interface PaginatedResponse<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+export interface PaginationMeta {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+}
+export type ProductType = 'PHYSICAL' | 'DIGITAL' | 'SERVICE' | 'BUNDLE';
+export type ProductStatus = 'DRAFT' | 'ACTIVE' | 'SOLD_OUT' | 'ARCHIVED';
+export type OrderStatus = 'PENDING' | 'CONFIRMED' | 'PREPARING' | 'READY' | 'COMPLETED' | 'CANCELLED' | 'REFUNDED';
+export interface Product {
+    id: string;
+    spotId: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    type: ProductType;
+    status: ProductStatus;
+    price: number;
+    currency: string;
+    imageUrl: string | null;
+    images: string[];
+    stock: number | null;
+    maxQuantity: number;
+    sortOrder: number;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Order {
+    id: string;
+    spotId: string;
+    userId: string;
+    status: OrderStatus;
+    subtotal: number;
+    tax: number;
+    total: number;
+    currency: string;
+    notes: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface OrderItem {
+    id: string;
+    orderId: string;
+    productId: string;
+    quantity: number;
+    unitPrice: number;
+    total: number;
+    createdAt: Date;
+}

package/dist/api/entities.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Spots SDK Entity Types
+ *
+ * These types mirror the Prisma schema entities but without @prisma/client dependency.
+ * This allows the SDK to work in React Native where Prisma is not available.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entities.js","sourceRoot":"","sources":["../../src/api/entities.ts"],"names":[],"mappings":";AAAA;;;;;GAKG","sourcesContent":["/**\n * Spots SDK Entity Types\n *\n * These types mirror the Prisma schema entities but without @prisma/client dependency.\n * This allows the SDK to work in React Native where Prisma is not available.\n */\n\n// ============================================================================\n// ENUMS\n// ============================================================================\n\nexport type SpotType =\n  | 'CAFE'\n  | 'RESTAURANT'\n  | 'BAR'\n  | 'PARK'\n  | 'BEACH'\n  | 'COWORKING'\n  | 'LIBRARY'\n  | 'GYM'\n  | 'MUSEUM'\n  | 'GALLERY'\n  | 'THEATER'\n  | 'CINEMA'\n  | 'MALL'\n  | 'MARKET'\n  | 'HOTEL'\n  | 'HOSTEL'\n  | 'OTHER'\n\nexport type SpotPostType =\n  | 'CHECK_IN'\n  | 'LOOKING_FOR'\n  | 'OFFERING'\n  | 'QUESTION'\n  | 'EVENT'\n  | 'RECOMMENDATION'\n  | 'GENERAL'\n\nexport type AccountStatus = 'ACTIVE' | 'SUSPENDED' | 'DELETED' | 'PENDING'\n\nexport type ClaimStatus = 'PENDING' | 'APPROVED' | 'REJECTED'\n\nexport type ResponseStatus = 'PENDING' | 'ACCEPTED' | 'DECLINED'\n\nexport type ReportReason =\n  | 'SPAM'\n  | 'HARASSMENT'\n  | 'INAPPROPRIATE'\n  | 'SCAM'\n  | 'OTHER'\n\nexport type ReportStatus = 'PENDING' | 'REVIEWED' | 'RESOLVED' | 'DISMISSED'\n\nexport type NotificationType =\n  | 'POST_RESPONSE'\n  | 'POST_REPLY'\n  | 'POST_UPVOTE'\n  | 'RESPONSE_ACCEPTED'\n  | 'RESPONSE_DECLINED'\n  | 'NEW_MESSAGE'\n  | 'SYSTEM'\n\n// ============================================================================\n// ENTITY INTERFACES\n// ============================================================================\n\nexport interface User {\n  id: string\n  phone: string | null\n  email: string | null\n  name: string | null\n  bio: string | null\n  avatarUrl: string | null\n  status: AccountStatus\n  onboardingCompleted: boolean\n  lastActiveAt: Date | null\n  createdAt: Date\n  updatedAt: Date\n}\n\nexport interface Spot {\n  id: string\n  name: string\n  slug: string\n  description: string | null\n  address: string | null\n  city: string | null\n  country: string | null\n  latitude: number | null\n  longitude: number | null\n  // Aliases for backwards compatibility\n  lat?: number | null\n  lng?: number | null\n  type: SpotType\n  googlePlaceId: string | null\n  website: string | null\n  phone: string | null\n  imageUrl: string | null\n  ownerId: string | null\n  isVerified: boolean\n  // Dates as strings for JSON serialization compatibility\n  createdAt: Date | string\n  updatedAt: Date | string\n}\n\nexport interface SpotPost {\n  id: string\n  spotId: string\n  userId: string\n  postType: SpotPostType\n  title: string\n  content: string | null\n  emoji: string | null\n  expiresAt: Date | null\n  status: 'ACTIVE' | 'FULFILLED' | 'EXPIRED' | 'DELETED'\n  upvoteCount: number\n  responseCount: number\n  replyCount: number\n  createdAt: Date\n  updatedAt: Date\n  // Relations (optional, populated by API)\n  user?: User\n  spot?: Spot\n}\n\nexport interface PostReply {\n  id: string\n  postId: string\n  userId: string\n  content: string\n  createdAt: Date\n  updatedAt: Date\n  user?: User\n}\n\nexport interface PostResponse {\n  id: string\n  postId: string\n  userId: string\n  note: string | null\n  status: ResponseStatus\n  createdAt: Date\n  updatedAt: Date\n  user?: User\n  post?: SpotPost\n}\n\nexport interface PostUpvote {\n  id: string\n  postId: string\n  userId: string\n  createdAt: Date\n}\n\n/**\n * PostUpvoter - user who upvoted a post (from /posts/:id/upvotes endpoint)\n */\nexport interface PostUpvoter {\n  id: string\n  userId: string\n  name: string | null\n  avatarUrl: string | null\n  createdAt: Date\n}\n\n/**\n * PostUpvotesResponse - response from /posts/:id/upvotes endpoint\n */\nexport interface PostUpvotesResponse {\n  data: PostUpvoter[]\n  meta: {\n    total: number\n    limit: number\n    offset: number\n    hasMore: boolean\n    currentUserUpvoted: boolean\n    isPostAuthor: boolean\n  }\n}\n\nexport interface PostReport {\n  id: string\n  postId: string\n  userId: string\n  reason: ReportReason\n  details: string | null\n  status: ReportStatus\n  createdAt: Date\n  updatedAt: Date\n}\n\nexport interface Club {\n  id: string\n  name: string\n  slug: string\n  description: string | null\n  imageUrl: string | null\n  isPrivate: boolean\n  createdById: string\n  createdAt: Date\n  updatedAt: Date\n}\n\nexport interface ClubMember {\n  id: string\n  clubId: string\n  userId: string\n  role: 'MEMBER' | 'ADMIN' | 'OWNER'\n  joinedAt: Date\n}\n\nexport interface Conversation {\n  id: string\n  createdAt: Date\n  updatedAt: Date\n  participants?: User[]\n  messages?: Message[]\n}\n\nexport interface Message {\n  id: string\n  conversationId: string\n  senderId: string\n  content: string\n  createdAt: Date\n  sender?: User\n}\n\nexport interface Notification {\n  id: string\n  userId: string\n  type: NotificationType\n  title: string\n  body: string | null\n  data: Record<string, unknown> | null\n  isRead: boolean\n  createdAt: Date\n}\n\nexport interface PostTemplate {\n  id: string\n  postType: SpotPostType\n  emoji: string\n  title: string\n  placeholder: string | null\n  isActive: boolean\n  sortOrder: number\n  createdAt: Date\n  updatedAt: Date\n}\n\nexport interface Vibe {\n  id: string\n  name: string\n  emoji: string | null\n  createdAt: Date\n}\n\nexport interface Interest {\n  id: string\n  name: string\n  emoji: string | null\n  category: string | null\n  createdAt: Date\n}\n\nexport interface Intention {\n  id: string\n  name: string\n  emoji: string | null\n  createdAt: Date\n}\n\nexport interface LifeSituation {\n  id: string\n  name: string\n  emoji: string | null\n  createdAt: Date\n}\n\nexport interface FavoriteSpot {\n  id: string\n  userId: string\n  spotId: string\n  createdAt: Date\n  spot?: Spot\n}\n\nexport interface SpotImage {\n  id: string\n  spotId: string\n  url: string\n  caption: string | null\n  sortOrder: number\n  createdAt: Date\n}\n\nexport interface SpotVibe {\n  id: string\n  spotId: string\n  vibeId: string\n  vibe?: Vibe\n}\n\nexport interface SpotIntention {\n  id: string\n  spotId: string\n  intentionId: string\n  intention?: Intention\n}\n\nexport interface SpotClaim {\n  id: string\n  spotId: string\n  userId: string\n  status: ClaimStatus\n  verificationMethod: string | null\n  createdAt: Date\n  updatedAt: Date\n}\n\nexport interface SpotSubscription {\n  id: string\n  spotId: string\n  userId: string\n  createdAt: Date\n  spot?: Spot\n}\n\nexport interface City {\n  id: string\n  name: string\n  country: string\n  latitude: number\n  longitude: number\n  timezone: string | null\n  createdAt: Date\n}\n\n// ============================================================================\n// API RESPONSE TYPES\n// ============================================================================\n\n// NOTE: ApiResponse is re-exported from @spots/types in types.ts\n\n/**\n * Paginated response with meta information\n */\nexport interface PaginatedResponse<T> {\n  data: T[]\n  meta: PaginationMeta\n}\n\nexport interface PaginationMeta {\n  total: number\n  page: number\n  limit: number\n  totalPages: number\n  hasNextPage: boolean\n  hasPreviousPage: boolean\n}\n\n// ============================================================================\n// MARKETPLACE TYPES\n// ============================================================================\n\nexport type ProductType = 'PHYSICAL' | 'DIGITAL' | 'SERVICE' | 'BUNDLE'\n\nexport type ProductStatus = 'DRAFT' | 'ACTIVE' | 'SOLD_OUT' | 'ARCHIVED'\n\nexport type OrderStatus =\n  | 'PENDING'\n  | 'CONFIRMED'\n  | 'PREPARING'\n  | 'READY'\n  | 'COMPLETED'\n  | 'CANCELLED'\n  | 'REFUNDED'\n\nexport interface Product {\n  id: string\n  spotId: string\n  name: string\n  slug: string\n  description: string | null\n  type: ProductType\n  status: ProductStatus\n  price: number\n  currency: string\n  imageUrl: string | null\n  images: string[]\n  stock: number | null\n  maxQuantity: number\n  sortOrder: number\n  metadata: Record<string, unknown> | null\n  createdAt: Date\n  updatedAt: Date\n}\n\nexport interface Order {\n  id: string\n  spotId: string\n  userId: string\n  status: OrderStatus\n  subtotal: number\n  tax: number\n  total: number\n  currency: string\n  notes: string | null\n  metadata: Record<string, unknown> | null\n  createdAt: Date\n  updatedAt: Date\n}\n\nexport interface OrderItem {\n  id: string\n  orderId: string\n  productId: string\n  quantity: number\n  unitPrice: number\n  total: number\n  createdAt: Date\n}\n"]}

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

@@ -3,12 +3,12 @@
  *
  * TanStack Query hooks for club mutation operations.
  */
-import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import type { Club } from '../types';
+import { type UseMutationOptions, type UseMutationResult } from '@tanstack/react-query';
+import { type Club } from '../types';
 /**
  * Create a new club
  *
- * @endpoint POST /api/v1/clubs
+ * @endpoint POST /clubs
  */
 export declare function useCreateClub(options?: Omit<UseMutationOptions<Club, Error, {
     spotId: string;
@@ -22,7 +22,7 @@ export declare function useCreateClub(options?: Omit<UseMutationOptions<Club, Er
 /**
  * Update a club
  *
- * @endpoint PUT /api/v1/clubs/{id}
+ * @endpoint PUT /clubs/{id}
  */
 export declare function useUpdateClub(options?: Omit<UseMutationOptions<Club, Error, {
     clubId: string;
@@ -36,12 +36,12 @@ export declare function useUpdateClub(options?: Omit<UseMutationOptions<Club, Er
 /**
  * Join a club
  *
- * @endpoint POST /api/v1/clubs/{id}/join
+ * @endpoint POST /clubs/{id}/join
  */
 export declare function useJoinClub(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
 /**
  * Leave a club
  *
- * @endpoint POST /api/v1/clubs/{id}/leave
+ * @endpoint POST /clubs/{id}/leave
  */
 export declare function useLeaveClub(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;

package/dist/api/mutations/clubs.js

@@ -19,18 +19,20 @@ const users_1 = require("../queries/users");
 /**
  * Create a new club
  *
- * @endpoint POST /api/v1/clubs
+ * @endpoint POST /clubs
  */
 function useCreateClub(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/clubs', data);
+            const response = await client.post('/clubs', data);
             return response.data.data;
         },
         onSuccess: (_, variables) => {
-            queryClient.invalidateQueries({ queryKey: clubs_1.clubKeys.bySpot(variables.spotId) });
+            queryClient.invalidateQueries({
+                queryKey: clubs_1.clubKeys.bySpot(variables.spotId),
+            });
         },
         ...options,
     });
@@ -38,14 +40,14 @@ function useCreateClub(options) {
 /**
  * Update a club
  *
- * @endpoint PUT /api/v1/clubs/{id}
+ * @endpoint PUT /clubs/{id}
  */
 function useUpdateClub(options) {
     const queryClient = (0, react_query_1.useQueryClient)();
     return (0, react_query_1.useMutation)({
         mutationFn: async ({ clubId, ...data }) => {
             const client = (0, client_1.getApiClient)();
-            const response = await client.put(`/api/v1/clubs/${clubId}`, data);
+            const response = await client.put(`/clubs/${clubId}`, data);
             return response.data.data;
         },
         onSuccess: (data, variables) => {
@@ -57,14 +59,14 @@ function useUpdateClub(options) {
 /**
  * Join a club
  *
- * @endpoint POST /api/v1/clubs/{id}/join
+ * @endpoint POST /clubs/{id}/join
  */
 function useJoinClub(options) {
     const queryClient = (0, react_query_1.useQueryClient)();
     return (0, react_query_1.useMutation)({
         mutationFn: async (clubId) => {
             const client = (0, client_1.getApiClient)();
-            await client.post(`/api/v1/clubs/${clubId}/join`);
+            await client.post(`/clubs/${clubId}/join`);
         },
         onSuccess: (_, clubId) => {
             queryClient.invalidateQueries({ queryKey: clubs_1.clubKeys.detail(clubId) });
@@ -76,14 +78,14 @@ function useJoinClub(options) {
 /**
  * Leave a club
  *
- * @endpoint POST /api/v1/clubs/{id}/leave
+ * @endpoint POST /clubs/{id}/leave
  */
 function useLeaveClub(options) {
     const queryClient = (0, react_query_1.useQueryClient)();
     return (0, react_query_1.useMutation)({
         mutationFn: async (clubId) => {
             const client = (0, client_1.getApiClient)();
-            await client.post(`/api/v1/clubs/${clubId}/leave`);
+            await client.post(`/clubs/${clubId}/leave`);
         },
         onSuccess: (_, clubId) => {
             queryClient.invalidateQueries({ queryKey: clubs_1.clubKeys.detail(clubId) });
@@ -92,4 +94,4 @@ function useLeaveClub(options) {
         ...options,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,18 +3,18 @@
  *
  * TanStack Query hooks for conversation/messaging mutation operations.
  */
-import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
-import type { Conversation, Message, CreateConversationRequest, SendMessageRequest } from '../types';
+import { type UseMutationOptions, type UseMutationResult } from '@tanstack/react-query';
+import { type Conversation, type CreateConversationRequest, type Message, type SendMessageRequest } from '../types';
 /**
  * Create a new conversation
  *
- * @endpoint POST /api/v1/conversations
+ * @endpoint POST /conversations
  */
 export declare function useCreateConversation(options?: Omit<UseMutationOptions<Conversation, Error, CreateConversationRequest>, 'mutationFn'>): UseMutationResult<Conversation, Error, CreateConversationRequest>;
 /**
  * Create or get direct conversation with a user
  *
- * @endpoint POST /api/v1/conversations/direct
+ * @endpoint POST /conversations/direct
  */
 export declare function useCreateDirectConversation(options?: Omit<UseMutationOptions<Conversation, Error, {
     userId: string;
@@ -24,7 +24,7 @@ export declare function useCreateDirectConversation(options?: Omit<UseMutationOp
 /**
  * Send a message in a conversation
  *
- * @endpoint POST /api/v1/conversations/{id}/messages
+ * @endpoint POST /conversations/{id}/messages
  */
 export declare function useSendMessage(options?: Omit<UseMutationOptions<Message, Error, {
     conversationId: string;
@@ -34,12 +34,12 @@ export declare function useSendMessage(options?: Omit<UseMutationOptions<Message
 /**
  * Mark conversation as read
  *
- * @endpoint PUT /api/v1/conversations/{id}/read
+ * @endpoint PUT /conversations/{id}/read
  */
 export declare function useMarkConversationAsRead(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
 /**
  * Send typing indicator
  *
- * @endpoint POST /api/v1/conversations/{id}/typing
+ * @endpoint POST /conversations/{id}/typing
  */
 export declare function useSendTypingIndicator(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;