@gymspace/sdk 1.0.0 → 1.0.2

package/src/models/subscriptions.ts

@@ -0,0 +1,74 @@
+export interface SubscriptionPlan {
+  id: string;
+  name: string;
+  price: any;
+  billingFrequency: string;
+  maxGyms: number;
+  maxClientsPerGym: number;
+  maxUsersPerGym: number;
+  features: any;
+  description?: string;
+}
+
+export interface Subscription {
+  id: string;
+  organizationId: string;
+  subscriptionPlanId: string;
+  subscriptionPlan?: SubscriptionPlan;
+  status: string;
+  startDate: Date;
+  endDate: Date;
+  isActive: boolean;
+}
+
+export interface AvailablePlanDto {
+  id: string;
+  name: string;
+  description?: string;
+  price: any;
+  billingFrequency: string;
+  maxGyms: number;
+  maxClientsPerGym: number;
+  maxUsersPerGym: number;
+  features: any;
+  isFreePlan: boolean;
+}
+
+export interface SubscriptionStatusDto {
+  organizationId: string;
+  currentPlan: SubscriptionPlan | null;
+  status: string;
+  startDate: Date | null;
+  endDate: Date | null;
+  usage: {
+    gyms: {
+      current: number;
+      limit: number;
+    };
+    clientsPerGym: {
+      [gymId: string]: {
+        current: number;
+        limit: number;
+      };
+    };
+    usersPerGym: {
+      [gymId: string]: {
+        current: number;
+        limit: number;
+      };
+    };
+  };
+  canUpgrade: boolean;
+  canDowngrade: boolean;
+}
+
+export interface AffiliateOrganizationDto {
+  subscriptionPlanId: string;
+}
+
+export interface CheckLimitResponse {
+  canPerform: boolean;
+  currentUsage: number;
+  limit: number;
+  message?: string;
+}

package/src/resources/auth.ts

@@ -33,8 +33,8 @@ export class AuthResource extends BaseResource {
     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 refreshToken(refreshToken: string, options?: RequestOptions): Promise<LoginResponseDto> {
+    return this.client.post<LoginResponseDto>(`${this.basePath}/refresh`, { refresh_token: refreshToken }, options);
   }
 
   async verifyEmail(

package/src/resources/clients.ts

@@ -4,6 +4,7 @@ import {
   CreateClientDto, 
   UpdateClientDto, 
   ClientStats,
+  ClientStat,
   SearchClientsParams,
   ClientSearchForCheckInResponse
 } from '../models/clients';
@@ -20,6 +21,7 @@ export class ClientsResource extends BaseResource {
     params?: SearchClientsParams,
     options?: RequestOptions
   ): Promise<PaginatedResponseDto<Client>> {
+    
     return this.paginate<Client>(this.basePath, params, options);
   }
 
@@ -43,6 +45,18 @@ export class ClientsResource extends BaseResource {
     return this.client.get<ClientStats>(`${this.basePath}/${id}/stats`, undefined, options);
   }
 
+  async getClientStat(id: string, statKey: string, options?: RequestOptions): Promise<ClientStat> {
+    return this.client.get<ClientStat>(`${this.basePath}/${id}/stats/${statKey}`, undefined, options);
+  }
+
+  async getClientStatsByCategory(id: string, category: string, options?: RequestOptions): Promise<ClientStat[]> {
+    return this.client.get<ClientStat[]>(`${this.basePath}/${id}/stats/category/${category}`, undefined, options);
+  }
+
+  async getAvailableStats(options?: RequestOptions): Promise<ClientStat[]> {
+    return this.client.get<ClientStat[]>(`${this.basePath}/stats/available`, undefined, options);
+  }
+
   async searchClientsForCheckIn(
     params?: SearchClientsParams,
     options?: RequestOptions

package/src/resources/dashboard.ts

@@ -1,30 +1,82 @@
 import { BaseResource } from './base';
-import { DashboardStats, RecentActivity, ExpiringContract } from '../models/dashboard';
+import {
+  DashboardStats,
+  ExpiringContract,
+  ContractsRevenue,
+  SalesRevenue,
+  Debts,
+  CheckIns,
+  NewClients,
+  DateRangeParams,
+} from '../models/dashboard';
 
 export class DashboardResource extends BaseResource {
   /**
-   * Get dashboard statistics
-   * @returns Dashboard statistics including clients, contracts, revenue, and check-ins
+   * Get dashboard statistics (lightweight counts only)
+   * @returns Dashboard statistics including client and contract counts
    */
   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
+   * Get contracts revenue within date range
+   * @param params Optional date range parameters
+   * @returns Contracts revenue data for the specified period
    */
-  async getRecentActivity(limit: number = 10): Promise<RecentActivity[]> {
-    return this.client.get<RecentActivity[]>('/dashboard/recent-activity', { limit });
+  async getContractsRevenue(params?: DateRangeParams): Promise<ContractsRevenue> {
+    return this.client.get<ContractsRevenue>('/dashboard/contracts-revenue', params);
   }
 
   /**
-   * Get expiring contracts
+   * Get sales revenue within date range
+   * @param params Optional date range parameters
+   * @returns Sales revenue data for the specified period
+   */
+  async getSalesRevenue(params?: DateRangeParams): Promise<SalesRevenue> {
+    return this.client.get<SalesRevenue>('/dashboard/sales-revenue', params);
+  }
+
+  /**
+   * Get total debts within date range
+   * @param params Optional date range parameters
+   * @returns Outstanding debts data for the specified period
+   */
+  async getDebts(params?: DateRangeParams): Promise<Debts> {
+    return this.client.get<Debts>('/dashboard/debts', params);
+  }
+
+  /**
+   * Get check-ins count within date range
+   * @param params Optional date range parameters
+   * @returns Check-ins data for the specified period
+   */
+  async getCheckIns(params?: DateRangeParams): Promise<CheckIns> {
+    return this.client.get<CheckIns>('/dashboard/check-ins', params);
+  }
+
+  /**
+   * Get new clients count within date range
+   * @param params Optional date range parameters
+   * @returns New clients data for the specified period
+   */
+  async getNewClients(params?: DateRangeParams): Promise<NewClients> {
+    return this.client.get<NewClients>('/dashboard/new-clients', params);
+  }
+
+  /**
+   * Get expiring contracts within date range
    * @param limit Maximum number of contracts to return (default: 10)
-   * @returns List of contracts expiring in the next 30 days
+   * @param params Optional date range parameters
+   * @returns List of contracts expiring in the specified period
    */
-  async getExpiringContracts(limit: number = 10): Promise<ExpiringContract[]> {
-    return this.client.get<ExpiringContract[]>('/dashboard/expiring-contracts', { limit });
+  async getExpiringContracts(
+    limit: number = 10,
+    params?: DateRangeParams,
+  ): Promise<ExpiringContract[]> {
+    return this.client.get<ExpiringContract[]>('/dashboard/expiring-contracts', {
+      limit,
+      ...params,
+    });
   }
 }

package/src/resources/gyms.ts

@@ -1,5 +1,5 @@
 import { BaseResource } from './base';
-import { Gym, CreateGymDto, UpdateGymDto, GymStats } from '../models/gyms';
+import { Gym, CreateGymDto, UpdateGymDto, GymStats, UpdateGymScheduleDto, UpdateGymSocialMediaDto } from '../models/gyms';
 import { RequestOptions } from '../types';
 
 export class GymsResource extends BaseResource {
@@ -58,4 +58,20 @@ export class GymsResource extends BaseResource {
   ): Promise<Gym> {
     return this.client.put<Gym>(`${this.basePath}/current`, data, options);
   }
+
+  async updateGymSchedule(
+    id: string,
+    data: UpdateGymScheduleDto,
+    options?: RequestOptions
+  ): Promise<Gym> {
+    return this.client.put<Gym>(`${this.basePath}/${id}/schedule`, data, options);
+  }
+
+  async updateGymSocialMedia(
+    id: string,
+    data: UpdateGymSocialMediaDto,
+    options?: RequestOptions
+  ): Promise<Gym> {
+    return this.client.put<Gym>(`${this.basePath}/${id}/social-media`, data, options);
+  }
 }

package/src/resources/index.ts

@@ -17,4 +17,6 @@ export * from './onboarding';
 export * from './products';
 export * from './sales';
 export * from './suppliers';
-export * from './users';
+export * from './users';
+export * from './subscriptions';
+export * from './payment-methods';

package/src/resources/payment-methods.ts

@@ -0,0 +1,48 @@
+import { BaseResource } from './base';
+import { 
+  PaymentMethod,
+  CreatePaymentMethodDto, 
+  UpdatePaymentMethodDto,
+  SearchPaymentMethodsParams,
+  PaymentMethodStats
+} from '../models/payment-methods';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class PaymentMethodsResource extends BaseResource {
+  private basePath = 'payment-methods';
+
+  async createPaymentMethod(data: CreatePaymentMethodDto, options?: RequestOptions): Promise<PaymentMethod> {
+    return this.client.post<PaymentMethod>(this.basePath, data, options);
+  }
+
+  async searchPaymentMethods(
+    params?: SearchPaymentMethodsParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<PaymentMethod>> {
+    return this.paginate<PaymentMethod>(this.basePath, params, options);
+  }
+
+  async getPaymentMethod(id: string, options?: RequestOptions): Promise<PaymentMethod> {
+    return this.client.get<PaymentMethod>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updatePaymentMethod(
+    id: string,
+    data: UpdatePaymentMethodDto,
+    options?: RequestOptions
+  ): Promise<PaymentMethod> {
+    return this.client.put<PaymentMethod>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deletePaymentMethod(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  async togglePaymentMethod(id: string, options?: RequestOptions): Promise<PaymentMethod> {
+    return this.client.put<PaymentMethod>(`${this.basePath}/${id}/toggle`, undefined, options);
+  }
+
+  async getPaymentMethodStats(options?: RequestOptions): Promise<PaymentMethodStats> {
+    return this.client.get<PaymentMethodStats>(`${this.basePath}/stats`, undefined, options);
+  }
+}

package/src/resources/products.ts

@@ -2,7 +2,9 @@ import { BaseResource } from './base';
 import { 
   Product,
   ProductCategory,
+  StockMovement,
   CreateProductDto, 
+  CreateServiceDto,
   UpdateProductDto,
   UpdateStockDto,
   CreateProductCategoryDto,
@@ -43,6 +45,10 @@ export class ProductsResource extends BaseResource {
     return this.client.post<Product>(this.basePath, data, options);
   }
 
+  async createService(data: CreateServiceDto, options?: RequestOptions): Promise<Product> {
+    return this.client.post<Product>(`${this.basePath}/services`, data, options);
+  }
+
   async searchProducts(
     params?: SearchProductsParams,
     options?: RequestOptions
@@ -88,4 +94,11 @@ export class ProductsResource extends BaseResource {
       options
     );
   }
+
+  async getProductStockMovements(
+    id: string,
+    options?: RequestOptions
+  ): Promise<StockMovement[]> {
+    return this.client.get<StockMovement[]>(`${this.basePath}/${id}/stock-movements`, undefined, options);
+  }
 }

package/src/resources/sales.ts

@@ -6,7 +6,8 @@ import {
   UpdatePaymentStatusDto,
   SearchSalesParams,
   SalesStats,
-  TopSellingProduct
+  TopSellingProduct,
+  CustomerSalesReport
 } from '../models/sales';
 import { RequestOptions, PaginatedResponseDto } from '../types';
 
@@ -38,10 +39,10 @@ export class SalesResource extends BaseResource {
 
   async updatePaymentStatus(
     id: string,
-    data: UpdatePaymentStatusDto,
+    paymentStatus: 'paid' | 'unpaid',
     options?: RequestOptions
   ): Promise<Sale> {
-    return this.client.put<Sale>(`${this.basePath}/${id}/payment-status`, data, options);
+    return this.client.put<Sale>(`${this.basePath}/${id}/payment-status`, { paymentStatus }, options);
   }
 
   async deleteSale(id: string, options?: RequestOptions): Promise<void> {
@@ -80,4 +81,20 @@ export class SalesResource extends BaseResource {
       options
     );
   }
+
+  async getSalesByCustomer(
+    startDate?: string,
+    endDate?: string,
+    options?: RequestOptions
+  ): Promise<CustomerSalesReport> {
+    const params: Record<string, string> = {};
+    if (startDate) params.startDate = startDate;
+    if (endDate) params.endDate = endDate;
+
+    return this.client.get<CustomerSalesReport>(
+      `${this.basePath}/reports/by-customer`,
+      Object.keys(params).length > 0 ? params : undefined,
+      options
+    );
+  }
 }

package/src/resources/subscriptions.ts

@@ -0,0 +1,65 @@
+import {
+  AvailablePlanDto,
+  SubscriptionStatusDto,
+  AffiliateOrganizationDto,
+  CheckLimitResponse,
+} from '../models/subscriptions';
+import { RequestOptions } from '../types';
+import { BaseResource } from './base';
+
+export class SubscriptionsResource extends BaseResource {
+  private basePath = 'subscriptions';
+
+  /**
+   * Get available subscription plans (currently only free plans)
+   */
+  async getAvailablePlans(options?: RequestOptions): Promise<AvailablePlanDto[]> {
+    return this.client.get<AvailablePlanDto[]>(`${this.basePath}/plans`, undefined, options);
+  }
+
+  /**
+   * Get subscription status for an organization
+   */
+  async getSubscriptionStatus(
+    organizationId: string,
+    options?: RequestOptions,
+  ): Promise<SubscriptionStatusDto> {
+    return this.client.get<SubscriptionStatusDto>(
+      `${this.basePath}/organizations/${organizationId}/status`,
+      undefined,
+      options,
+    );
+  }
+
+  /**
+   * Affiliate organization to a subscription plan
+   */
+  async affiliateOrganization(
+    organizationId: string,
+    data: AffiliateOrganizationDto,
+    options?: RequestOptions,
+  ): Promise<SubscriptionStatusDto> {
+    return this.client.post<SubscriptionStatusDto>(
+      `${this.basePath}/organizations/${organizationId}/affiliate`,
+      data,
+      options,
+    );
+  }
+
+  /**
+   * Check subscription limits
+   * @param organizationId Organization ID
+   * @param limitType Type of limit to check: 'gyms', 'clients', or 'users'
+   */
+  async checkSubscriptionLimit(
+    organizationId: string,
+    limitType: 'gyms' | 'clients' | 'users',
+    options?: RequestOptions,
+  ): Promise<CheckLimitResponse> {
+    return this.client.get<CheckLimitResponse>(
+      `${this.basePath}/organizations/${organizationId}/limits/${limitType}`,
+      undefined,
+      options,
+    );
+  }
+}

package/src/sdk.ts

@@ -21,6 +21,8 @@ import {
   SalesResource,
   SuppliersResource,
   UsersResource,
+  SubscriptionsResource,
+  PaymentMethodsResource,
 } from './resources';
 
 export class GymSpaceSdk {
@@ -47,6 +49,8 @@ export class GymSpaceSdk {
   public sales: SalesResource;
   public suppliers: SuppliersResource;
   public users: UsersResource;
+  public subscriptions: SubscriptionsResource;
+  public paymentMethods: PaymentMethodsResource;
 
   constructor(config: GymSpaceConfig) {
     this.client = new ApiClient(config);
@@ -72,6 +76,8 @@ export class GymSpaceSdk {
     this.sales = new SalesResource(this.client);
     this.suppliers = new SuppliersResource(this.client);
     this.users = new UsersResource(this.client);
+    this.subscriptions = new SubscriptionsResource(this.client);
+    this.paymentMethods = new PaymentMethodsResource(this.client);
   }
 
   /**
@@ -81,6 +87,13 @@ export class GymSpaceSdk {
     this.client.setAuthToken(token);
   }
 
+  /**
+   * Set both access and refresh tokens
+   */
+  setTokens(accessToken: string, refreshToken: string): void {
+    this.client.setTokens(accessToken, refreshToken);
+  }
+
   /**
    * Set the current gym context
    */