@gymspace/sdk 1.2.5 → 1.2.9

package/src/resources/contracts.ts

@@ -1,10 +1,10 @@
 import { BaseResource } from './base';
-import { 
-  Contract, 
-  CreateContractDto, 
-  RenewContractDto, 
+import {
+  Contract,
+  CreateContractDto,
+  RenewContractDto,
   FreezeContractDto,
-  GetContractsParams 
+  GetContractsParams,
 } from '../models/contracts';
 import { RequestOptions, PaginatedResponseDto } from '../types';
 
@@ -17,7 +17,7 @@ export class ContractsResource extends BaseResource {
 
   async getGymContracts(
     params?: GetContractsParams,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<PaginatedResponseDto<Contract>> {
     return this.paginate<Contract>(this.basePath, params, options);
   }
@@ -26,21 +26,14 @@ export class ContractsResource extends BaseResource {
     return this.client.get<Contract>(`${this.basePath}/${id}`, undefined, options);
   }
 
-  async getClientContracts(
-    clientId: string,
-    options?: RequestOptions
-  ): Promise<Contract[]> {
-    return this.client.get<Contract[]>(
-      `${this.basePath}/client/${clientId}`, 
-      undefined, 
-      options
-    );
+  async getClientContracts(clientId: string, options?: RequestOptions): Promise<Contract[]> {
+    return this.client.get<Contract[]>(`${this.basePath}/client/${clientId}`, undefined, options);
   }
 
   async renewContract(
     id: string,
     data: RenewContractDto,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<Contract> {
     return this.client.post<Contract>(`${this.basePath}/${id}/renew`, data, options);
   }
@@ -48,12 +41,27 @@ export class ContractsResource extends BaseResource {
   async freezeContract(
     id: string,
     data: FreezeContractDto,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<Contract> {
     return this.client.post<Contract>(`${this.basePath}/${id}/freeze`, data, options);
   }
 
-  async cancelContract(id: string, data: { reason: string }, options?: RequestOptions): Promise<Contract> {
+  async cancelContract(
+    id: string,
+    data: { reason: string },
+    options?: RequestOptions,
+  ): Promise<Contract> {
     return this.client.put<Contract>(`${this.basePath}/${id}/cancel`, data, options);
   }
-}
+
+  async resendWhatsAppNotification(
+    contractId: string,
+    options?: RequestOptions,
+  ): Promise<{ success: boolean; message: string }> {
+    return this.client.post<{ success: boolean; message: string }>(
+      `${this.basePath}/${contractId}/resend-whatsapp`,
+      {},
+      options,
+    );
+  }
+}

package/src/resources/dashboard.ts

@@ -8,6 +8,7 @@ import {
   CheckIns,
   NewClients,
   DateRangeParams,
+  CheckInsList,
 } from '../models/dashboard';
 
 export class DashboardResource extends BaseResource {
@@ -79,4 +80,13 @@ export class DashboardResource extends BaseResource {
       ...params,
     });
   }
-}
+
+  /**
+   * Get detailed list of check-ins within date range
+   * @param params Optional date range parameters (defaults to current day)
+   * @returns Detailed list of check-ins with client and registeredBy information
+   */
+  async getCheckInsList(params?: DateRangeParams): Promise<CheckInsList> {
+    return this.client.get<CheckInsList>('/dashboard/check-ins/list', params);
+  }
+}

package/src/resources/index.ts

@@ -23,4 +23,6 @@ export * from './users';
 export * from './subscriptions';
 export * from './subscription-plans';
 export * from './admin-subscription-management';
-export * from './payment-methods';
+export * from './payment-methods';
+export * from './whatsapp';
+export * from './whatsapp-templates';

package/src/resources/invitations.ts

@@ -1,45 +1,42 @@
 import { BaseResource } from './base';
-import {
+import type {
   Invitation,
   CreateInvitationDto,
   AcceptInvitationDto,
   ValidateByCodeDto,
-  GetGymInvitationsParams
-} from '../models/invitations';
+} from '@gymspace/shared';
 import { RequestOptions } from '../types';
 
+export interface GetGymInvitationsParams {
+  gymId: string;
+}
+
 export class InvitationsResource extends BaseResource {
   private basePath = 'invitations';
 
-  async createInvitation(
-    data: CreateInvitationDto,
-    options?: RequestOptions
-  ): Promise<Invitation> {
+  async createInvitation(data: CreateInvitationDto, options?: RequestOptions): Promise<Invitation> {
     return this.client.post<Invitation>(this.basePath, data, options);
   }
 
   async getGymInvitations(
     params: GetGymInvitationsParams,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<Invitation[]> {
     return this.client.get<Invitation[]>(this.basePath, params, options);
   }
 
   async validateByCode(
     data: ValidateByCodeDto,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<{ email: string; gymName: string; roleName: string; token: string }> {
     return this.client.post(`${this.basePath}/validate-by-code`, data, options);
   }
 
-  async acceptInvitation(
-    data: AcceptInvitationDto,
-    options?: RequestOptions
-  ): Promise<void> {
+  async acceptInvitation(data: AcceptInvitationDto, options?: RequestOptions): Promise<void> {
     return this.client.post<void>(`${this.basePath}/accept`, data, options);
   }
 
   async cancelInvitation(id: string, options?: RequestOptions): Promise<void> {
     return this.client.put<void>(`${this.basePath}/${id}/cancel`, undefined, options);
   }
-}
+}

package/src/resources/roles.ts

@@ -1,5 +1,6 @@
 import { BaseResource } from './base';
-import { Role, PermissionsGroup } from '../models/roles';
+import type { Role } from '@gymspace/shared';
+import type { PermissionsGroup } from '../models/roles';
 import { RequestOptions } from '../types';
 
 export class RolesResource extends BaseResource {

package/src/resources/sales.ts

@@ -8,7 +8,7 @@ import {
   SearchSalesParams,
   SalesStats,
   TopSellingProduct,
-  CustomerSalesReport
+  CustomerSalesReport,
 } from '../models/sales';
 import { RequestOptions, PaginatedResponseDto } from '../types';
 
@@ -21,7 +21,7 @@ export class SalesResource extends BaseResource {
 
   async searchSales(
     params?: SearchSalesParams,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<PaginatedResponseDto<Sale>> {
     return this.paginate<Sale>(this.basePath, params, options);
   }
@@ -30,27 +30,23 @@ export class SalesResource extends BaseResource {
     return this.client.get<Sale>(`${this.basePath}/${id}`, undefined, options);
   }
 
-  async updateSale(
-    id: string,
-    data: UpdateSaleDto,
-    options?: RequestOptions
-  ): Promise<Sale> {
+  async updateSale(id: string, data: UpdateSaleDto, options?: RequestOptions): Promise<Sale> {
     return this.client.put<Sale>(`${this.basePath}/${id}`, data, options);
   }
 
   async updatePaymentStatus(
     id: string,
     paymentStatus: 'paid' | 'unpaid',
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<Sale> {
-    return this.client.put<Sale>(`${this.basePath}/${id}/payment-status`, { paymentStatus }, options);
+    return this.client.put<Sale>(
+      `${this.basePath}/${id}/payment-status`,
+      { paymentStatus },
+      options,
+    );
   }
 
-  async paySale(
-    id: string,
-    data: PaySaleDto,
-    options?: RequestOptions
-  ): Promise<Sale> {
+  async paySale(id: string, data: PaySaleDto, options?: RequestOptions): Promise<Sale> {
     return this.client.post<Sale>(`${this.basePath}/${id}/payment`, data, options);
   }
 
@@ -61,7 +57,7 @@ export class SalesResource extends BaseResource {
   async getSalesStats(
     startDate?: string,
     endDate?: string,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<SalesStats> {
     const params: Record<string, string> = {};
     if (startDate) params.startDate = startDate;
@@ -70,7 +66,7 @@ export class SalesResource extends BaseResource {
     return this.client.get<SalesStats>(
       `${this.basePath}/stats`,
       Object.keys(params).length > 0 ? params : undefined,
-      options
+      options,
     );
   }
 
@@ -78,23 +74,19 @@ export class SalesResource extends BaseResource {
     limit: number = 10,
     startDate?: string,
     endDate?: string,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<TopSellingProduct[]> {
     const params: Record<string, string | number> = { limit };
     if (startDate) params.startDate = startDate;
     if (endDate) params.endDate = endDate;
 
-    return this.client.get<TopSellingProduct[]>(
-      `${this.basePath}/top-products`,
-      params,
-      options
-    );
+    return this.client.get<TopSellingProduct[]>(`${this.basePath}/top-products`, params, options);
   }
 
   async getSalesByCustomer(
     startDate?: string,
     endDate?: string,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<CustomerSalesReport> {
     const params: Record<string, string> = {};
     if (startDate) params.startDate = startDate;
@@ -103,7 +95,18 @@ export class SalesResource extends BaseResource {
     return this.client.get<CustomerSalesReport>(
       `${this.basePath}/reports/by-customer`,
       Object.keys(params).length > 0 ? params : undefined,
-      options
+      options,
+    );
+  }
+
+  async resendWhatsAppNotification(
+    saleId: string,
+    options?: RequestOptions,
+  ): Promise<{ success: boolean; message: string }> {
+    return this.client.post<{ success: boolean; message: string }>(
+      `${this.basePath}/${saleId}/resend-whatsapp`,
+      {},
+      options,
     );
   }
-}
+}

package/src/resources/whatsapp-templates.ts

@@ -0,0 +1,80 @@
+import { BaseResource } from './base';
+import {
+  WhatsAppTemplate,
+  CreateTemplateDto,
+  UpdateTemplateDto,
+  SearchTemplatesDto,
+  PreviewTemplateResponse,
+} from '../models/whatsapp';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+// Import TemplateCode type from shared (re-exported via types)
+type TemplateCode = string;
+
+export class WhatsAppTemplatesResource extends BaseResource {
+  private basePath = 'whatsapp/templates';
+
+  /**
+   * Create a new WhatsApp template
+   */
+  async create(data: CreateTemplateDto, options?: RequestOptions): Promise<WhatsAppTemplate> {
+    return this.client.post<WhatsAppTemplate>(this.basePath, data, options);
+  }
+
+  /**
+   * Get all WhatsApp templates with pagination and filters
+   */
+  async findAll(
+    params?: SearchTemplatesDto,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<WhatsAppTemplate>> {
+    return this.paginate<WhatsAppTemplate>(this.basePath, params, options);
+  }
+
+  /**
+   * Get a specific WhatsApp template by ID
+   */
+  async findOne(id: string, options?: RequestOptions): Promise<WhatsAppTemplate> {
+    return this.client.get<WhatsAppTemplate>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  /**
+   * Get a WhatsApp template by code
+   */
+  async findByCode(code: TemplateCode, options?: RequestOptions): Promise<WhatsAppTemplate> {
+    return this.client.get<WhatsAppTemplate>(`${this.basePath}/code/${code}`, undefined, options);
+  }
+
+  /**
+   * Update a WhatsApp template
+   */
+  async update(
+    id: string,
+    data: UpdateTemplateDto,
+    options?: RequestOptions,
+  ): Promise<WhatsAppTemplate> {
+    return this.client.put<WhatsAppTemplate>(`${this.basePath}/${id}`, data, options);
+  }
+
+  /**
+   * Delete a WhatsApp template
+   */
+  async remove(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  /**
+   * Preview a template with variables
+   */
+  async preview(
+    id: string,
+    variables: Record<string, any>,
+    options?: RequestOptions,
+  ): Promise<PreviewTemplateResponse> {
+    return this.client.post<PreviewTemplateResponse>(
+      `${this.basePath}/${id}/preview`,
+      variables,
+      options,
+    );
+  }
+}

package/src/resources/whatsapp.ts

@@ -0,0 +1,97 @@
+import { BaseResource } from './base';
+import {
+  WhatsAppConfig,
+  WhatsAppMessage,
+  CreateWhatsAppConfigDto,
+  UpdateWhatsAppConfigDto,
+  SendWhatsAppMessageDto,
+  SearchWhatsAppMessagesDto,
+  ConnectionStatusResponse,
+  InitializeConnectionResponse,
+  Contact,
+  DisconnectResponse,
+} from '../models/whatsapp';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class WhatsAppResource extends BaseResource {
+  private basePath = 'whatsapp';
+
+  /**
+   * Get WhatsApp configuration for the current gym
+   */
+  async getConfig(options?: RequestOptions): Promise<WhatsAppConfig> {
+    return this.client.get<WhatsAppConfig>(`${this.basePath}/config`, undefined, options);
+  }
+
+  /**
+   * Initialize WhatsApp connection
+   * Returns QR code if needed
+   */
+  async initializeConnection(options?: RequestOptions): Promise<InitializeConnectionResponse> {
+    return this.client.post<InitializeConnectionResponse>(
+      `${this.basePath}/initialize`,
+      {},
+      options,
+    );
+  }
+
+  /**
+   * Update WhatsApp configuration
+   */
+  async updateConfig(
+    data: UpdateWhatsAppConfigDto,
+    options?: RequestOptions,
+  ): Promise<WhatsAppConfig> {
+    return this.client.put<WhatsAppConfig>(`${this.basePath}/config`, data, options);
+  }
+
+  /**
+   * Get WhatsApp connection status
+   */
+  async getConnectionStatus(options?: RequestOptions): Promise<ConnectionStatusResponse> {
+    return this.client.get<ConnectionStatusResponse>(
+      `${this.basePath}/connection-status`,
+      undefined,
+      options,
+    );
+  }
+
+  /**
+   * Send a WhatsApp message
+   */
+  async sendMessage(
+    data: SendWhatsAppMessageDto,
+    options?: RequestOptions,
+  ): Promise<WhatsAppMessage> {
+    return this.client.post<WhatsAppMessage>(`${this.basePath}/send-message`, data, options);
+  }
+
+  /**
+   * Get WhatsApp messages with pagination and filters
+   */
+  async getMessages(
+    params?: SearchWhatsAppMessagesDto,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<WhatsAppMessage>> {
+    return this.paginate<WhatsAppMessage>(`${this.basePath}/messages`, params, options);
+  }
+
+  /**
+   * Get a specific WhatsApp message by ID
+   */
+  async getMessage(id: string, options?: RequestOptions): Promise<WhatsAppMessage> {
+    return this.client.get<WhatsAppMessage>(`${this.basePath}/messages/${id}`, undefined, options);
+  }
+
+  async listContacts(options?: RequestOptions): Promise<Contact[]> {
+    return this.client.get<Contact[]>(`${this.basePath}/contacts`, undefined, options);
+  }
+
+  /**
+   * Disconnect WhatsApp instance
+   * Logs out from WhatsApp without deleting the instance
+   */
+  async disconnect(options?: RequestOptions): Promise<DisconnectResponse> {
+    return this.client.post<DisconnectResponse>(`${this.basePath}/disconnect`, {}, options);
+  }
+}

package/src/sdk.ts

@@ -1,5 +1,6 @@
 import { ApiClient } from './client';
 import { GymSpaceConfig } from './types';
+import { createAgentFetch } from './utils/agent-fetch';
 import {
   AuthResource,
   OrganizationsResource,
@@ -27,11 +28,14 @@ import {
   SubscriptionPlansResource,
   AdminSubscriptionManagementResource,
   PaymentMethodsResource,
+  WhatsAppResource,
+  WhatsAppTemplatesResource,
 } from './resources';
 
 export class GymSpaceSdk {
   public client: ApiClient;
-  
+  private expoFetch?: typeof globalThis.fetch;
+
   // Resources
   public auth: AuthResource;
   public organizations: OrganizationsResource;
@@ -59,10 +63,12 @@ export class GymSpaceSdk {
   public subscriptionPlans: SubscriptionPlansResource;
   public adminSubscriptionManagement: AdminSubscriptionManagementResource;
   public paymentMethods: PaymentMethodsResource;
+  public whatsapp: WhatsAppResource;
+  public whatsappTemplates: WhatsAppTemplatesResource;
 
   constructor(config: GymSpaceConfig) {
     this.client = new ApiClient(config);
-    
+
     // Initialize resources
     this.auth = new AuthResource(this.client);
     this.organizations = new OrganizationsResource(this.client);
@@ -90,6 +96,8 @@ export class GymSpaceSdk {
     this.subscriptionPlans = new SubscriptionPlansResource(this.client);
     this.adminSubscriptionManagement = new AdminSubscriptionManagementResource(this.client);
     this.paymentMethods = new PaymentMethodsResource(this.client);
+    this.whatsapp = new WhatsAppResource(this.client);
+    this.whatsappTemplates = new WhatsAppTemplatesResource(this.client);
   }
 
   /**
@@ -127,10 +135,27 @@ export class GymSpaceSdk {
     this.client.clearAuth();
   }
 
+  /**
+   * Set Expo fetch for React Native environments
+   * Should be called once during app initialization
+   */
+  setExpoFetch(fetchFn: typeof globalThis.fetch): void {
+    this.expoFetch = fetchFn;
+  }
+
+  /**
+   * Create a fetch function for agent endpoints
+   * Uses the /agent/* proxy that includes request context
+   * Automatically uses Expo fetch if set
+   */
+  createAgentFetch() {
+    return createAgentFetch(this.client, this.expoFetch);
+  }
+
   /**
    * Get the underlying API client
    */
   getClient(): ApiClient {
     return this.client;
   }
-}
+}

package/src/types.ts

@@ -37,5 +37,5 @@ import type { PaginationParams as SharedPaginationParams } from '@gymspace/share
 // Re-export as PaginationQueryDto for backward compatibility
 export type PaginationQueryDto = SharedPaginationParams;
 
-// Re-export shared types
-export * from '@gymspace/shared';
+// Re-export shared types (including constants and enums)
+export * from '@gymspace/shared';

package/src/utils/agent-fetch.ts

@@ -0,0 +1,25 @@
+import { ApiClient } from '../client';
+
+export function createAgentFetch(apiClient: ApiClient, customFetch?: typeof globalThis.fetch) {
+  const fetchFn = customFetch || fetch;
+
+  return async (path: string, options?: RequestInit) => {
+    const fullUrl = `${apiClient.getBaseUrl()}/agent${path}`;
+
+    // Get gymId from axios instance headers
+    const axiosInstance = (apiClient as any).axiosInstance;
+    const gymId = axiosInstance?.defaults?.headers?.common?.['X-Gym-Id'];
+
+    const headers = {
+      'Content-Type': 'application/json',
+      ...(apiClient.getAccessToken() && { Authorization: `Bearer ${apiClient.getAccessToken()}` }),
+      ...(gymId && { 'X-Gym-Id': gymId }),
+      ...(options?.headers || {}),
+    };
+
+    return fetchFn(fullUrl, {
+      ...options,
+      headers,
+    });
+  };
+}