@gymspace/sdk 1.2.12 → 1.2.14

package/src/models/tags.ts

@@ -0,0 +1,151 @@
+// Request DTOs
+export interface CreateTagDto {
+  name: string;
+  color?: string;
+  description?: string;
+}
+
+export interface UpdateTagDto {
+  name?: string;
+  color?: string;
+  description?: string;
+}
+
+export interface AssignTagsDto {
+  tagIds: string[];
+}
+
+export interface RemoveTagsDto {
+  tagIds: string[];
+}
+
+// Response types
+export interface Tag {
+  id: string;
+  gymId: string;
+  name: string;
+  color?: string;
+  description?: string;
+  clientCount?: number;
+  createdAt: string;
+  updatedAt: string;
+  createdBy?: {
+    id: string;
+    name: string;
+  };
+}
+
+export interface TagWithAssignment extends Tag {
+  assignedAt?: string;
+  assignedBy?: {
+    id: string;
+    name: string;
+  };
+}
+
+// Query/Filter params
+export interface SearchTagsParams {
+  page?: number;
+  limit?: number;
+  search?: string;
+  includeCount?: boolean;
+  sortBy?: 'name' | 'createdAt' | 'clientCount';
+  sortOrder?: 'asc' | 'desc';
+}
+
+export interface GetTagClientsParams {
+  page?: number;
+  limit?: number;
+  search?: string;
+  status?: 'active' | 'inactive';
+}
+
+// Response types for specific operations
+export interface AssignTagsResponse {
+  message: string;
+  assigned: number;
+  skipped: number;
+  client: {
+    id: string;
+    name: string;
+    tags: TagWithAssignment[];
+  };
+}
+
+export interface RemoveTagsResponse {
+  message: string;
+  removed: number;
+  notFound: number;
+  client: {
+    id: string;
+    name: string;
+    tags: TagWithAssignment[];
+  };
+}
+
+export interface DeleteTagResponse {
+  message: string;
+  deletedCount: number;
+  affectedClients: number;
+}
+
+export interface ClientTagsResponse {
+  client: {
+    id: string;
+    name: string;
+    clientNumber: string;
+  };
+  tags: TagWithAssignment[];
+  total: number;
+}
+
+export interface TagClientsResponse {
+  data: Array<{
+    id: string;
+    clientNumber: string;
+    name: string;
+    email?: string;
+    phone?: string;
+    status: string;
+    assignedAt: string;
+    assignedBy: {
+      id: string;
+      name: string;
+    };
+  }>;
+  meta: {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+  };
+  tag: {
+    id: string;
+    name: string;
+    color?: string;
+  };
+}
+
+export interface TagStatsResponse {
+  totalTags: number;
+  totalAssignments: number;
+  averageTagsPerClient: number;
+  mostUsedTags: Array<{
+    id: string;
+    name: string;
+    color?: string;
+    clientCount: number;
+  }>;
+  leastUsedTags: Array<{
+    id: string;
+    name: string;
+    color?: string;
+    clientCount: number;
+  }>;
+  unusedTags: Array<{
+    id: string;
+    name: string;
+    color?: string;
+    clientCount: number;
+  }>;
+}

package/src/resources/activities.ts

@@ -0,0 +1,113 @@
+import { BaseResource } from './base';
+import {
+  Activity,
+  CreateActivityDto,
+  UpdateActivityDto,
+  SearchActivitiesParams,
+  CreateActivityNotificationDto,
+  UpdateActivityNotificationDto,
+  ActivityNotification,
+  ActivityStats,
+  ActivityStatsParams,
+  EligibleClientsResponse,
+  DeleteActivityParams,
+} from '../models/activities';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class ActivitiesResource extends BaseResource {
+  private basePath = 'activities';
+
+  async createActivity(data: CreateActivityDto, options?: RequestOptions): Promise<Activity> {
+    return this.client.post<Activity>(this.basePath, data, options);
+  }
+
+  async searchActivities(
+    params?: SearchActivitiesParams,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<Activity>> {
+    return this.paginate<Activity>(this.basePath, params as any, options);
+  }
+
+  async getActivity(id: string, options?: RequestOptions): Promise<Activity> {
+    return this.client.get<Activity>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateActivity(
+    id: string,
+    data: UpdateActivityDto,
+    options?: RequestOptions,
+  ): Promise<Activity> {
+    return this.client.patch<Activity>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deleteActivity(
+    id: string,
+    params?: DeleteActivityParams,
+    options?: RequestOptions,
+  ): Promise<void> {
+    const queryString = params?.deleteRecurrence ? '?deleteRecurrence=true' : '';
+    return this.client.delete<void>(`${this.basePath}/${id}${queryString}`, options);
+  }
+
+  async createNotification(
+    activityId: string,
+    data: CreateActivityNotificationDto,
+    options?: RequestOptions,
+  ): Promise<ActivityNotification> {
+    return this.client.post<ActivityNotification>(
+      `${this.basePath}/${activityId}/notifications`,
+      data,
+      options,
+    );
+  }
+
+  async getNotifications(
+    activityId: string,
+    options?: RequestOptions,
+  ): Promise<{ data: ActivityNotification[] }> {
+    return this.client.get<{ data: ActivityNotification[] }>(
+      `${this.basePath}/${activityId}/notifications`,
+      undefined,
+      options,
+    );
+  }
+
+  async updateNotification(
+    activityId: string,
+    notificationId: string,
+    data: UpdateActivityNotificationDto,
+    options?: RequestOptions,
+  ): Promise<ActivityNotification> {
+    return this.client.patch<ActivityNotification>(
+      `${this.basePath}/${activityId}/notifications/${notificationId}`,
+      data,
+      options,
+    );
+  }
+
+  async deleteNotification(
+    activityId: string,
+    notificationId: string,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return this.client.delete<void>(
+      `${this.basePath}/${activityId}/notifications/${notificationId}`,
+      options,
+    );
+  }
+
+  async getStats(params?: ActivityStatsParams, options?: RequestOptions): Promise<ActivityStats> {
+    return this.client.get<ActivityStats>(`${this.basePath}/stats`, params, options);
+  }
+
+  async getEligibleClients(
+    activityId: string,
+    options?: RequestOptions,
+  ): Promise<EligibleClientsResponse> {
+    return this.client.get<EligibleClientsResponse>(
+      `${this.basePath}/${activityId}/eligible-clients`,
+      undefined,
+      options,
+    );
+  }
+}

package/src/resources/bulk-messaging.ts

@@ -0,0 +1,83 @@
+import { BaseResource } from './base';
+import { RequestOptions } from '../types';
+import {
+  BulkTemplate,
+  CreateBulkTemplateDto,
+  UpdateBulkTemplateDto,
+  BulkMessageVariable,
+  SendBulkMessagesDto,
+  BulkMessageResultDto,
+  BulkLogsResponseDto,
+  GenerateAIMessageDto,
+  GenerateAIMessageResponseDto,
+} from '../models/bulk-messaging';
+
+export class BulkMessagingResource extends BaseResource {
+  private basePath = 'whatsapp/bulk-messaging';
+  private templatesPath = 'whatsapp/bulk-templates';
+
+  async createTemplate(
+    data: CreateBulkTemplateDto,
+    options?: RequestOptions,
+  ): Promise<BulkTemplate> {
+    return this.client.post<BulkTemplate>(this.templatesPath, data, options);
+  }
+
+  async getTemplates(options?: RequestOptions): Promise<BulkTemplate[]> {
+    return this.client.get<BulkTemplate[]>(this.templatesPath, undefined, options);
+  }
+
+  async getTemplate(id: string, options?: RequestOptions): Promise<BulkTemplate> {
+    return this.client.get<BulkTemplate>(`${this.templatesPath}/${id}`, undefined, options);
+  }
+
+  async updateTemplate(
+    id: string,
+    data: UpdateBulkTemplateDto,
+    options?: RequestOptions,
+  ): Promise<BulkTemplate> {
+    return this.client.put<BulkTemplate>(`${this.templatesPath}/${id}`, data, options);
+  }
+
+  async deleteTemplate(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.templatesPath}/${id}`, options);
+  }
+
+  async getAvailableVariables(options?: RequestOptions): Promise<BulkMessageVariable[]> {
+    return this.client.get<BulkMessageVariable[]>(
+      `${this.basePath}/available-variables`,
+      undefined,
+      options,
+    );
+  }
+
+  /**
+   * Generate AI message with streaming support
+   * Note: This proxies to the agent endpoint for streaming responses
+   */
+  async generateAIMessage(
+    data: GenerateAIMessageDto,
+    options?: RequestOptions,
+  ): Promise<GenerateAIMessageResponseDto> {
+    return this.client.post<GenerateAIMessageResponseDto>(
+      `${this.basePath}/generate-ai`,
+      data,
+      options,
+    );
+  }
+
+  /**
+   * Send bulk messages to multiple clients
+   * Note: SDK sends clientIds, API fetches full client and gym data before sending to agent
+   */
+  async send(data: SendBulkMessagesDto, options?: RequestOptions): Promise<BulkMessageResultDto> {
+    return this.client.post<BulkMessageResultDto>(`${this.basePath}/send`, data, options);
+  }
+
+  /**
+   * Get logs for a bulk message send operation
+   */
+  async getLogs(sendId: string, options?: RequestOptions): Promise<BulkLogsResponseDto> {
+    return this.client.get<BulkLogsResponseDto>(`${this.basePath}/logs`, { sendId }, options);
+  }
+}

package/src/resources/check-ins.ts

@@ -1,27 +1,40 @@
 import { BaseResource } from './base';
-import { 
-  CheckIn, 
-  CreateCheckInDto, 
+import {
+  CheckIn,
+  CreateCheckInDto,
   SearchCheckInsParams,
   GetCheckInStatsParams,
   CheckInStats,
   GetClientCheckInHistoryParams,
   CurrentlyInGymResponse,
   CheckInListResponse,
-  ClientCheckInHistory
+  ClientCheckInHistory,
 } from '../models/check-ins';
 import { RequestOptions, PaginatedResponseDto } from '../types';
 
 export class CheckInsResource extends BaseResource {
   private basePath = 'check-ins';
 
+  /**
+   * Creates a new check-in for a client.
+   *
+   * **Permissions Required:**
+   * - Gym owners with full gym access
+   * - Active collaborators with CHECKINS_CREATE permission
+   *
+   * @param data - The check-in data including client ID and optional notes
+   * @param options - Optional request configuration
+   * @returns The created check-in record with client and user details
+   * @throws {ValidationError} When client is not found or already checked in
+   * @throws {AuthorizationError} When user lacks required permissions
+   */
   async createCheckIn(data: CreateCheckInDto, options?: RequestOptions): Promise<CheckIn> {
     return this.client.post<CheckIn>(this.basePath, data, options);
   }
 
   async searchCheckIns(
     params?: SearchCheckInsParams,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<CheckInListResponse> {
     return this.client.get<CheckInListResponse>(this.basePath, params, options);
   }
@@ -34,30 +47,49 @@ export class CheckInsResource extends BaseResource {
     return this.client.get<CheckIn>(`${this.basePath}/${id}`, undefined, options);
   }
 
+  /**
+   * Deletes a check-in record.
+   *
+   * **Permissions Required:**
+   * - Gym owners with full gym access
+   * - Active collaborators with CHECKINS_CREATE permission
+   *
+   * **Business Rules:**
+   * - Only check-ins from today can be deleted
+   * - The same permission level required for creation is required for deletion
+   * - Cannot delete check-ins from previous days
+   *
+   * @param id - The ID of the check-in to delete
+   * @param options - Optional request configuration
+   * @returns Promise that resolves when the check-in is successfully deleted
+   * @throws {NotFoundError} When the check-in is not found
+   * @throws {AuthorizationError} When user lacks required permissions
+   * @throws {ValidationError} When trying to delete a check-in from a previous day
+   */
   async deleteCheckIn(id: string, options?: RequestOptions): Promise<void> {
     return this.client.delete<void>(`${this.basePath}/${id}`, options);
   }
 
   async getGymCheckInStats(
     params: GetCheckInStatsParams,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<CheckInStats> {
     return this.client.get<CheckInStats>(
       `${this.basePath}/stats/${params.period}`,
       undefined,
-      options
+      options,
     );
   }
 
   async getClientCheckInHistory(
     clientId: string,
     params?: GetClientCheckInHistoryParams,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<ClientCheckInHistory> {
     return this.client.get<ClientCheckInHistory>(
       `${this.basePath}/client/${clientId}/history`,
       params,
-      options
+      options,
     );
   }
-}
+}

package/src/resources/contracts.ts

@@ -4,7 +4,13 @@ import {
   CreateContractDto,
   RenewContractDto,
   FreezeContractDto,
+  CancelContractDto,
+  SuspendContractDto,
+  ResumeContractDto,
+  ReactivateContractDto,
   GetContractsParams,
+  ContractLifecycleEvent,
+  CancellationAnalytics,
 } from '../models/contracts';
 import { RequestOptions, PaginatedResponseDto } from '../types';
 
@@ -48,12 +54,58 @@ export class ContractsResource extends BaseResource {
 
   async cancelContract(
     id: string,
-    data: { reason: string },
+    data: CancelContractDto,
     options?: RequestOptions,
   ): Promise<Contract> {
     return this.client.put<Contract>(`${this.basePath}/${id}/cancel`, data, options);
   }
 
+  async suspendContract(
+    id: string,
+    data: SuspendContractDto,
+    options?: RequestOptions,
+  ): Promise<Contract> {
+    return this.client.post<Contract>(`${this.basePath}/${id}/suspend`, data, options);
+  }
+
+  async resumeContract(
+    id: string,
+    data: ResumeContractDto,
+    options?: RequestOptions,
+  ): Promise<Contract> {
+    return this.client.post<Contract>(`${this.basePath}/${id}/resume`, data, options);
+  }
+
+  async reactivateContract(
+    id: string,
+    data: ReactivateContractDto,
+    options?: RequestOptions,
+  ): Promise<Contract> {
+    return this.client.post<Contract>(`${this.basePath}/${id}/reactivate`, data, options);
+  }
+
+  async getLifecycleHistory(
+    id: string,
+    options?: RequestOptions,
+  ): Promise<ContractLifecycleEvent[]> {
+    return this.client.get<ContractLifecycleEvent[]>(
+      `${this.basePath}/${id}/lifecycle-history`,
+      undefined,
+      options,
+    );
+  }
+
+  async getCancellationAnalytics(
+    params?: { startDate?: string; endDate?: string },
+    options?: RequestOptions,
+  ): Promise<CancellationAnalytics> {
+    return this.client.get<CancellationAnalytics>(
+      `${this.basePath}/analytics/cancellation-reasons`,
+      params,
+      options,
+    );
+  }
+
   async resendWhatsAppNotification(
     contractId: string,
     options?: RequestOptions,

package/src/resources/gyms.ts

@@ -1,40 +1,32 @@
 import { BaseResource } from './base';
-import { Gym, CreateGymDto, UpdateGymDto, GymStats, UpdateGymScheduleDto, UpdateGymSocialMediaDto } from '../models/gyms';
+import {
+  Gym,
+  CreateGymDto,
+  UpdateGymDto,
+  GymStats,
+  UpdateGymScheduleDto,
+  UpdateGymSocialMediaDto,
+  UpdateGymInventorySettingsDto,
+  UpdateGymContractSettingsDto,
+} from '../models/gyms';
 import { RequestOptions } from '../types';
 
 export class GymsResource extends BaseResource {
   private basePath = 'gyms';
 
-  async createGym(
-    data: CreateGymDto, 
-    options?: RequestOptions
-  ): Promise<Gym> {
-    return this.client.post<Gym>(
-      this.basePath, 
-      data, 
-      options
-    );
+  async createGym(data: CreateGymDto, options?: RequestOptions): Promise<Gym> {
+    return this.client.post<Gym>(this.basePath, data, options);
   }
 
-  async getOrganizationGyms(
-    options?: RequestOptions
-  ): Promise<Gym[]> {
-    return this.client.get<Gym[]>(
-      this.basePath,
-      undefined,
-      options
-    );
+  async getOrganizationGyms(options?: RequestOptions): Promise<Gym[]> {
+    return this.client.get<Gym[]>(this.basePath, undefined, options);
   }
 
   async getGym(id: string, options?: RequestOptions): Promise<Gym> {
     return this.client.get<Gym>(`${this.basePath}/${id}`, undefined, options);
   }
 
-  async updateGym(
-    id: string,
-    data: UpdateGymDto,
-    options?: RequestOptions
-  ): Promise<Gym> {
+  async updateGym(id: string, data: UpdateGymDto, options?: RequestOptions): Promise<Gym> {
     return this.client.put<Gym>(`${this.basePath}/${id}`, data, options);
   }
 
@@ -54,7 +46,7 @@ export class GymsResource extends BaseResource {
       email?: string;
       assetId?: string;
     }>,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<Gym> {
     return this.client.put<Gym>(`${this.basePath}/current`, data, options);
   }
@@ -62,7 +54,7 @@ export class GymsResource extends BaseResource {
   async updateGymSchedule(
     id: string,
     data: UpdateGymScheduleDto,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<Gym> {
     return this.client.put<Gym>(`${this.basePath}/${id}/schedule`, data, options);
   }
@@ -70,8 +62,54 @@ export class GymsResource extends BaseResource {
   async updateGymSocialMedia(
     id: string,
     data: UpdateGymSocialMediaDto,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<Gym> {
     return this.client.put<Gym>(`${this.basePath}/${id}/social-media`, data, options);
   }
-}
+
+  /**
+   * Update current gym inventory settings (stock configuration)
+   * Uses gym from context (x-gym-id header)
+   * @param data Inventory settings data
+   * @param options Request options
+   * @returns Updated gym with new settings
+   *
+   * @example
+   * ```typescript
+   * const gym = await sdk.gyms.updateInventorySettings({
+   *   defaultMinStock: 15,
+   *   defaultMaxStock: 1000,
+   *   enableLowStockAlerts: true
+   * });
+   * ```
+   */
+  async updateInventorySettings(
+    data: UpdateGymInventorySettingsDto,
+    options?: RequestOptions,
+  ): Promise<Gym> {
+    return this.client.patch<Gym>(`${this.basePath}/current/inventory-settings`, data, options);
+  }
+
+  /**
+   * Update current gym contract expiration settings
+   * Uses gym from context (x-gym-id header)
+   * @param data Contract settings data
+   * @param options Request options
+   * @returns Updated gym with new settings
+   *
+   * @example
+   * ```typescript
+   * const gym = await sdk.gyms.updateContractSettings({
+   *   expiringSoonDays: 7,
+   *   gracePeriodDays: 0,
+   *   enableExpirationNotifications: true
+   * });
+   * ```
+   */
+  async updateContractSettings(
+    data: UpdateGymContractSettingsDto,
+    options?: RequestOptions,
+  ): Promise<Gym> {
+    return this.client.patch<Gym>(`${this.basePath}/current/contract-settings`, data, options);
+  }
+}

package/src/resources/index.ts

@@ -23,4 +23,7 @@ export * from './subscription-plans';
 export * from './admin-subscription-management';
 export * from './payment-methods';
 export * from './whatsapp';
-export * from './whatsapp-templates';
+export * from './whatsapp-templates';
+export * from './bulk-messaging';
+export * from './activities';
+export * from './tags';

package/src/resources/subscription-plans.ts

@@ -65,6 +65,14 @@ export interface UpdateSubscriptionPlanDto {
 
 export class SubscriptionPlansResource extends BaseResource {
   private basePath = 'admin/subscription-plans';
+  private publicBasePath = 'subscription-plans/public';
+
+  /**
+   * List all active subscription plans (Public - no authentication required)
+   */
+  async listPublicPlans(options?: RequestOptions): Promise<SubscriptionPlanDto[]> {
+    return this.client.get<SubscriptionPlanDto[]>(`${this.publicBasePath}`, undefined, options);
+  }
 
   /**
    * List all subscription plans (Super Admin only)
@@ -107,4 +115,4 @@ export class SubscriptionPlansResource extends BaseResource {
   async deletePlan(id: string, options?: RequestOptions): Promise<{ success: boolean }> {
     return this.client.delete<{ success: boolean }>(`${this.basePath}/${id}`, options);
   }
-}
+}