@gymspace/sdk 1.0.0

package/src/resources/auth.ts

@@ -0,0 +1,137 @@
+import {
+  CurrentSessionResponse,
+  InvitationValidationResponse,
+  LoginDto,
+  LoginResponseDto,
+  RegisterCollaboratorDto,
+  RegisterOwnerDto,
+  ResendVerificationDto,
+  SubscriptionPlan,
+  VerifyEmailDto,
+  ChangePasswordDto,
+  ChangePasswordResponseDto,
+  RequestPasswordResetDto,
+  RequestPasswordResetResponseDto,
+  VerifyResetCodeDto,
+  VerifyResetCodeResponseDto,
+  ResetPasswordDto,
+  ResetPasswordResponseDto,
+  ResendResetCodeDto,
+  ResendResetCodeResponseDto,
+} from '../models/auth';
+import { RequestOptions } from '../types';
+import { BaseResource } from './base';
+
+export class AuthResource extends BaseResource {
+  private basePath = 'auth';
+
+  async registerOwner(data: RegisterOwnerDto, options?: RequestOptions): Promise<void> {
+    return this.client.post(`${this.basePath}/register/owner`, data, options);
+  }
+
+  async login(data: LoginDto, options?: RequestOptions): Promise<LoginResponseDto> {
+    return this.client.post<LoginResponseDto>(`${this.basePath}/login`, data, options);
+  }
+
+  async refreshToken(options?: RequestOptions): Promise<LoginResponseDto> {
+    return this.client.post<LoginResponseDto>(`${this.basePath}/refresh`, undefined, options);
+  }
+
+  async verifyEmail(
+    data: VerifyEmailDto,
+    options?: RequestOptions,
+  ): Promise<{ success: boolean; message: string }> {
+    return this.client.post(`${this.basePath}/verify-email`, data, options);
+  }
+
+  async resendVerification(
+    data: ResendVerificationDto,
+    options?: RequestOptions,
+  ): Promise<{ success: boolean; message: string }> {
+    console.log('the path', `${this.basePath}/resend-verification`);
+
+    return this.client.post(`${this.basePath}/resend-verification`, data, options);
+  }
+
+
+  async getSubscriptionPlans(options?: RequestOptions): Promise<{ data: SubscriptionPlan[] }> {
+    return this.client.get(`${this.basePath}/subscription-plans`, options);
+  }
+
+  async validateInvitation(
+    token: string,
+    options?: RequestOptions,
+  ): Promise<InvitationValidationResponse> {
+    return this.client.get(`${this.basePath}/invitation/${token}`, options);
+  }
+
+  async registerCollaborator(
+    data: RegisterCollaboratorDto,
+    options?: RequestOptions,
+  ): Promise<LoginResponseDto> {
+    return this.client.post<LoginResponseDto>(
+      `${this.basePath}/register/collaborator`,
+      data,
+      options,
+    );
+  }
+
+  async getCurrentSession(options?: RequestOptions): Promise<CurrentSessionResponse> {
+    return this.client.get<CurrentSessionResponse>(`${this.basePath}/current-session`, options);
+  }
+
+  async changePassword(
+    data: ChangePasswordDto,
+    options?: RequestOptions,
+  ): Promise<ChangePasswordResponseDto> {
+    return this.client.post<ChangePasswordResponseDto>(
+      `${this.basePath}/change-password`,
+      data,
+      options,
+    );
+  }
+
+  async requestPasswordReset(
+    data: RequestPasswordResetDto,
+    options?: RequestOptions,
+  ): Promise<RequestPasswordResetResponseDto> {
+    return this.client.post<RequestPasswordResetResponseDto>(
+      `${this.basePath}/password-reset/request`,
+      data,
+      options,
+    );
+  }
+
+  async verifyResetCode(
+    data: VerifyResetCodeDto,
+    options?: RequestOptions,
+  ): Promise<VerifyResetCodeResponseDto> {
+    return this.client.post<VerifyResetCodeResponseDto>(
+      `${this.basePath}/password-reset/verify-code`,
+      data,
+      options,
+    );
+  }
+
+  async resetPassword(
+    data: ResetPasswordDto,
+    options?: RequestOptions,
+  ): Promise<ResetPasswordResponseDto> {
+    return this.client.post<ResetPasswordResponseDto>(
+      `${this.basePath}/password-reset/reset`,
+      data,
+      options,
+    );
+  }
+
+  async resendResetCode(
+    data: ResendResetCodeDto,
+    options?: RequestOptions,
+  ): Promise<ResendResetCodeResponseDto> {
+    return this.client.post<ResendResetCodeResponseDto>(
+      `${this.basePath}/password-reset/resend-code`,
+      data,
+      options,
+    );
+  }
+}

package/src/resources/base.ts

@@ -0,0 +1,50 @@
+import { ApiClient } from '../client';
+import { RequestOptions, PaginatedResponseDto, PaginationQueryDto } from '../types';
+
+export abstract class BaseResource {
+  constructor(protected client: ApiClient) {}
+
+  protected async request<T>(
+    path: string,
+    options: {
+      method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+      body?: string;
+      headers?: Record<string, string>;
+    }
+  ): Promise<T> {
+    const data = options.body ? JSON.parse(options.body) : undefined;
+    
+    switch (options.method) {
+      case 'GET':
+        return this.client.get<T>(path, data, { headers: options.headers });
+      case 'POST':
+        return this.client.post<T>(path, data, { headers: options.headers });
+      case 'PUT':
+        return this.client.put<T>(path, data, { headers: options.headers });
+      case 'PATCH':
+        return this.client.patch<T>(path, data, { headers: options.headers });
+      case 'DELETE':
+        return this.client.delete<T>(path, { headers: options.headers });
+      default:
+        throw new Error(`Unsupported HTTP method: ${options.method}`);
+    }
+  }
+
+  protected buildPath(base: string, ...segments: (string | undefined)[]): string {
+    const parts = [base];
+    for (const segment of segments) {
+      if (segment !== undefined) {
+        parts.push(segment);
+      }
+    }
+    return parts.join('/');
+  }
+
+  protected async paginate<T>(
+    path: string,
+    params?: PaginationQueryDto & Record<string, any>,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<T>> {
+    return this.client.get<PaginatedResponseDto<T>>(path, params, options);
+  }
+}

package/src/resources/check-ins.ts

@@ -0,0 +1,63 @@
+import { BaseResource } from './base';
+import { 
+  CheckIn, 
+  CreateCheckInDto, 
+  SearchCheckInsParams,
+  GetCheckInStatsParams,
+  CheckInStats,
+  GetClientCheckInHistoryParams,
+  CurrentlyInGymResponse,
+  CheckInListResponse,
+  ClientCheckInHistory
+} from '../models/check-ins';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class CheckInsResource extends BaseResource {
+  private basePath = 'check-ins';
+
+  async createCheckIn(data: CreateCheckInDto, options?: RequestOptions): Promise<CheckIn> {
+    return this.client.post<CheckIn>(this.basePath, data, options);
+  }
+
+  async searchCheckIns(
+    params?: SearchCheckInsParams,
+    options?: RequestOptions
+  ): Promise<CheckInListResponse> {
+    return this.client.get<CheckInListResponse>(this.basePath, params, options);
+  }
+
+  async getCurrentlyInGym(options?: RequestOptions): Promise<CurrentlyInGymResponse> {
+    return this.client.get<CurrentlyInGymResponse>(`${this.basePath}/current`, undefined, options);
+  }
+
+  async getCheckIn(id: string, options?: RequestOptions): Promise<CheckIn> {
+    return this.client.get<CheckIn>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async deleteCheckIn(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  async getGymCheckInStats(
+    params: GetCheckInStatsParams,
+    options?: RequestOptions
+  ): Promise<CheckInStats> {
+    return this.client.get<CheckInStats>(
+      `${this.basePath}/stats/${params.period}`,
+      undefined,
+      options
+    );
+  }
+
+  async getClientCheckInHistory(
+    clientId: string,
+    params?: GetClientCheckInHistoryParams,
+    options?: RequestOptions
+  ): Promise<ClientCheckInHistory> {
+    return this.client.get<ClientCheckInHistory>(
+      `${this.basePath}/client/${clientId}/history`,
+      params,
+      options
+    );
+  }
+}

package/src/resources/clients.ts

@@ -0,0 +1,57 @@
+import { BaseResource } from './base';
+import { 
+  Client, 
+  CreateClientDto, 
+  UpdateClientDto, 
+  ClientStats,
+  SearchClientsParams,
+  ClientSearchForCheckInResponse
+} from '../models/clients';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class ClientsResource extends BaseResource {
+  private basePath = 'clients';
+
+  async createClient(data: CreateClientDto, options?: RequestOptions): Promise<Client> {
+    return this.client.post<Client>(this.basePath, data, options);
+  }
+
+  async searchClients(
+    params?: SearchClientsParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<Client>> {
+    return this.paginate<Client>(this.basePath, params, options);
+  }
+
+  async getClient(id: string, options?: RequestOptions): Promise<Client> {
+    return this.client.get<Client>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateClient(
+    id: string,
+    data: UpdateClientDto,
+    options?: RequestOptions
+  ): Promise<Client> {
+    return this.client.put<Client>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async toggleClientStatus(id: string, options?: RequestOptions): Promise<Client> {
+    return this.client.put<Client>(`${this.basePath}/${id}/toggle-status`, undefined, options);
+  }
+
+  async getClientStats(id: string, options?: RequestOptions): Promise<ClientStats> {
+    return this.client.get<ClientStats>(`${this.basePath}/${id}/stats`, undefined, options);
+  }
+
+  async searchClientsForCheckIn(
+    params?: SearchClientsParams,
+    options?: RequestOptions
+  ): Promise<ClientSearchForCheckInResponse> {
+    // This endpoint automatically includes contract status and only active clients
+    return this.client.get<ClientSearchForCheckInResponse>(
+      `${this.basePath}/search/check-in`,
+      params,
+      options
+    );
+  }
+}

package/src/resources/contracts.ts

@@ -0,0 +1,59 @@
+import { BaseResource } from './base';
+import { 
+  Contract, 
+  CreateContractDto, 
+  RenewContractDto, 
+  FreezeContractDto,
+  GetContractsParams 
+} from '../models/contracts';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class ContractsResource extends BaseResource {
+  private basePath = 'contracts';
+
+  async createContract(data: CreateContractDto, options?: RequestOptions): Promise<Contract> {
+    return this.client.post<Contract>(this.basePath, data, options);
+  }
+
+  async getGymContracts(
+    params?: GetContractsParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<Contract>> {
+    return this.paginate<Contract>(this.basePath, params, options);
+  }
+
+  async getContract(id: string, options?: RequestOptions): Promise<Contract> {
+    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 renewContract(
+    id: string,
+    data: RenewContractDto,
+    options?: RequestOptions
+  ): Promise<Contract> {
+    return this.client.post<Contract>(`${this.basePath}/${id}/renew`, data, options);
+  }
+
+  async freezeContract(
+    id: string,
+    data: FreezeContractDto,
+    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> {
+    return this.client.put<Contract>(`${this.basePath}/${id}/cancel`, data, options);
+  }
+}

package/src/resources/dashboard.ts

@@ -0,0 +1,30 @@
+import { BaseResource } from './base';
+import { DashboardStats, RecentActivity, ExpiringContract } from '../models/dashboard';
+
+export class DashboardResource extends BaseResource {
+  /**
+   * Get dashboard statistics
+   * @returns Dashboard statistics including clients, contracts, revenue, and check-ins
+   */
+  async getStats(): Promise<DashboardStats> {
+    return this.client.get<DashboardStats>('/dashboard/stats');
+  }
+
+  /**
+   * Get recent activity
+   * @param limit Maximum number of activities to return (default: 10)
+   * @returns List of recent activities in the gym
+   */
+  async getRecentActivity(limit: number = 10): Promise<RecentActivity[]> {
+    return this.client.get<RecentActivity[]>('/dashboard/recent-activity', { limit });
+  }
+
+  /**
+   * Get expiring contracts
+   * @param limit Maximum number of contracts to return (default: 10)
+   * @returns List of contracts expiring in the next 30 days
+   */
+  async getExpiringContracts(limit: number = 10): Promise<ExpiringContract[]> {
+    return this.client.get<ExpiringContract[]>('/dashboard/expiring-contracts', { limit });
+  }
+}

package/src/resources/evaluations.ts

@@ -0,0 +1,63 @@
+import { BaseResource } from './base';
+import { 
+  Evaluation, 
+  CreateEvaluationDto, 
+  UpdateEvaluationDto,
+  GetClientEvaluationsParams,
+  EvaluationReport
+} from '../models/evaluations';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class EvaluationsResource extends BaseResource {
+  private basePath = 'evaluations';
+
+  async createEvaluation(
+    data: CreateEvaluationDto, 
+    options?: RequestOptions
+  ): Promise<Evaluation> {
+    return this.client.post<Evaluation>(this.basePath, data, options);
+  }
+
+  async getEvaluation(id: string, options?: RequestOptions): Promise<Evaluation> {
+    return this.client.get<Evaluation>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateEvaluation(
+    id: string,
+    data: UpdateEvaluationDto,
+    options?: RequestOptions
+  ): Promise<Evaluation> {
+    return this.client.put<Evaluation>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deleteEvaluation(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  async getClientEvaluations(
+    clientId: string,
+    params?: GetClientEvaluationsParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<Evaluation>> {
+    return this.paginate<Evaluation>(
+      `${this.basePath}/client/${clientId}`,
+      params,
+      options
+    );
+  }
+
+  async getGymEvaluationStats(options?: RequestOptions): Promise<any> {
+    return this.client.get(`${this.basePath}/gym/stats`, undefined, options);
+  }
+
+  async generateEvaluationReport(
+    id: string,
+    options?: RequestOptions
+  ): Promise<EvaluationReport> {
+    return this.client.get<EvaluationReport>(
+      `${this.basePath}/${id}/report`,
+      undefined,
+      options
+    );
+  }
+}

package/src/resources/files.ts

@@ -0,0 +1,95 @@
+import { BaseResource } from './base';
+import type { FileResponseDto } from '../models/files';
+
+export class FilesResource extends BaseResource {
+  /**
+   * Upload a new file
+   */
+  async upload(data: {
+    file: File;
+    description?: string;
+    metadata?: Record<string, any>;
+  }): Promise<FileResponseDto> {
+    const formData = new FormData();
+    formData.append('file', data.file);
+
+    if (data.description) {
+      formData.append('description', data.description);
+    }
+
+    if (data.metadata) {
+      formData.append('metadata', JSON.stringify(data.metadata));
+    }
+
+    return await this.client.post<FileResponseDto>('/files/upload', formData, {
+      headers: {
+        'Content-Type': 'multipart/form-data',
+      },
+    });
+  }
+
+  /**
+   * Get all files for the current user
+   */
+  async findAll(): Promise<FileResponseDto[]> {
+    return await this.client.get<FileResponseDto[]>('/files');
+  }
+
+  /**
+   * Get a single file by ID
+   */
+  async findOne(id: string): Promise<FileResponseDto> {
+    return await this.client.get<FileResponseDto>(`/files/${id}`);
+  }
+
+  /**
+   * Get multiple files by IDs
+   */
+  async findByIds(ids: string[]): Promise<FileResponseDto[]> {
+    if (!ids || ids.length === 0) {
+      return [];
+    }
+
+    // The second parameter of get is the params directly
+    return await this.client.get<FileResponseDto[]>('/files/by-ids', {
+      ids: ids.join(',')
+    });
+  }
+
+  /**
+   * Delete a file
+   */
+  async delete(id: string): Promise<void> {
+    await this.client.delete(`/files/${id}`);
+  }
+
+  /**
+   * Download a file as a blob
+   */
+  async download(id: string): Promise<Blob> {
+    const response = await this.client.get<ArrayBuffer>(`/files/${id}/download`, {
+      responseType: 'arraybuffer',
+    });
+
+    return new Blob([response]);
+  }
+
+  /**
+   * Get the render URL for a file (for inline display)
+   * This returns the URL directly without making an API call
+   */
+  getRenderUrl(id: string): string {
+    return `${this.client.getBaseUrl()}/files/${id}/render`;
+  }
+
+  /**
+   * Get file blob for rendering/preview
+   */
+  async render(id: string): Promise<Blob> {
+    const response = await this.client.get<ArrayBuffer>(`/files/${id}/render`, {
+      responseType: 'arraybuffer',
+    });
+
+    return new Blob([response]);
+  }
+}

package/src/resources/gyms.ts

@@ -0,0 +1,61 @@
+import { BaseResource } from './base';
+import { Gym, CreateGymDto, UpdateGymDto, GymStats } 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 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> {
+    return this.client.put<Gym>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async getGymStats(id: string, options?: RequestOptions): Promise<GymStats> {
+    return this.client.get<GymStats>(`${this.basePath}/${id}/stats`, undefined, options);
+  }
+
+  async toggleGymStatus(id: string, options?: RequestOptions): Promise<Gym> {
+    return this.client.put<Gym>(`${this.basePath}/${id}/toggle-status`, undefined, options);
+  }
+
+  async updateCurrentGym(
+    data: Partial<{
+      name?: string;
+      address?: string;
+      phone?: string;
+      email?: string;
+      assetId?: string;
+    }>,
+    options?: RequestOptions
+  ): Promise<Gym> {
+    return this.client.put<Gym>(`${this.basePath}/current`, data, options);
+  }
+}

package/src/resources/health.ts

@@ -0,0 +1,28 @@
+import { BaseResource } from './base';
+import { RequestOptions } from '../types';
+
+export interface HealthResponse {
+  status: string;
+  timestamp: string;
+}
+
+export interface ReadyResponse {
+  status: string;
+  services: {
+    database: boolean;
+    cache: boolean;
+    storage: boolean;
+  };
+}
+
+export class HealthResource extends BaseResource {
+  private basePath = 'health';
+
+  async health(options?: RequestOptions): Promise<HealthResponse> {
+    return this.client.get<HealthResponse>(this.basePath, undefined, options);
+  }
+
+  async ready(options?: RequestOptions): Promise<ReadyResponse> {
+    return this.client.get<ReadyResponse>(`${this.basePath}/ready`, undefined, options);
+  }
+}

package/src/resources/index.ts

@@ -0,0 +1,20 @@
+export * from './auth';
+export * from './organizations';
+export * from './gyms';
+export * from './clients';
+export * from './membership-plans';
+export * from './contracts';
+export * from './dashboard';
+export * from './evaluations';
+export * from './check-ins';
+export * from './invitations';
+export * from './leads';
+export * from './assets';
+export * from './files';
+export * from './public-catalog';
+export * from './health';
+export * from './onboarding';
+export * from './products';
+export * from './sales';
+export * from './suppliers';
+export * from './users';