@gymspace/sdk 1.2.14 → 1.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gymspace/sdk",
-  "version": "1.2.14",
+  "version": "1.2.16",
   "description": "GymSpace TypeScript SDK for API integration",
   "author": "GymSpace Team",
   "license": "MIT",

package/src/client.ts

@@ -35,6 +35,28 @@ export class ApiClient {
         'Content-Type': 'application/json',
         ...config.headers,
       },
+      paramsSerializer: (params) => {
+        const parts: string[] = [];
+
+        Object.entries(params).forEach(([key, value]) => {
+          if (value === undefined || value === null) {
+            return;
+          }
+
+          // Convert arrays to comma-separated strings
+          if (Array.isArray(value)) {
+            if (value.length > 0) {
+              // Encode each array element individually, then join with comma
+              const encodedValues = value.map((v) => encodeURIComponent(String(v))).join(',');
+              parts.push(`${encodeURIComponent(key)}=${encodedValues}`);
+            }
+          } else {
+            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+          }
+        });
+
+        return parts.join('&');
+      },
     });
 
     this.setupInterceptors();
@@ -67,21 +89,21 @@ export class ApiClient {
         // Check if backend refreshed tokens
         const newAccessToken = response.headers['x-new-access-token'];
         const newRefreshToken = response.headers['x-new-refresh-token'];
-        
+
         if (newAccessToken) {
           console.log('Tokens refreshed by backend, updating SDK...');
           this.setAuthToken(newAccessToken);
-          
+
           if (newRefreshToken) {
             this.setRefreshToken(newRefreshToken);
           }
-          
+
           // Notify client about token refresh
           if (this.onTokenRefreshed) {
             this.onTokenRefreshed(newAccessToken, newRefreshToken);
           }
         }
-        
+
         return response;
       },
       async (error: AxiosError) => {

package/src/models/clients.ts

@@ -1,3 +1,12 @@
+// Tag-related types
+export interface ClientTag {
+  tag: {
+    id: string;
+    name: string;
+    color: string;
+  };
+}
+
 export interface CreateClientDto {
   name: string;
   email?: string;
@@ -78,6 +87,7 @@ export interface Client {
       name: string;
     };
   }>;
+  clientTags?: ClientTag[];
   _count?: {
     evaluations: number;
     checkIns: number;
@@ -135,4 +145,7 @@ export interface SearchClientsParams {
   includeContractStatus?: boolean;
   notCheckedInToday?: boolean;
   checkedInToday?: boolean;
+  tagIds?: string[];
+  tagOperator?: 'and' | 'or';
+  includeTags?: boolean;
 }

package/src/models/commissions.ts

@@ -0,0 +1,332 @@
+export enum CommissionRuleType {
+  PLAN = 'PLAN',
+  AMOUNT = 'AMOUNT',
+  PROMOTION = 'PROMOTION',
+}
+
+export enum CommissionStatus {
+  PENDING = 'PENDING',
+  CONFIRMED = 'CONFIRMED',
+  PAID = 'PAID',
+  REVERSED = 'REVERSED',
+}
+
+export enum CommissionChangeType {
+  CREATED = 'CREATED',
+  UPDATED = 'UPDATED',
+  DELETED = 'DELETED',
+}
+
+export enum CommissionEntityType {
+  CONFIG = 'CONFIG',
+  RULE = 'RULE',
+}
+
+export interface RuleCriteria {
+  planId?: string;
+  minAmount?: number;
+  maxAmount?: number;
+  planIds?: string[];
+}
+
+export interface CommissionConfigDto {
+  id: string;
+  gymId: string;
+  defaultPercentage: number;
+  reversalPeriodDays: number;
+  minimumContractDays: number;
+  isActive: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateCommissionConfigDto {
+  defaultPercentage: number;
+  reversalPeriodDays: number;
+  minimumContractDays: number;
+  isActive: boolean;
+}
+
+export interface UpdateCommissionConfigDto {
+  defaultPercentage?: number;
+  reversalPeriodDays?: number;
+  minimumContractDays?: number;
+  isActive?: boolean;
+}
+
+export interface CommissionRuleDto {
+  id: string;
+  gymId: string;
+  name: string;
+  type: CommissionRuleType;
+  percentage: number;
+  priority: number;
+  criteria: RuleCriteria;
+  startDate?: string;
+  endDate?: string;
+  description?: string;
+  isActive: boolean;
+  createdAt: string;
+  updatedAt: string;
+  usageCount: number;
+}
+
+export interface CreateCommissionRuleDto {
+  name: string;
+  type: CommissionRuleType;
+  percentage: number;
+  criteria?: RuleCriteria;
+  startDate?: string;
+  endDate?: string;
+  description?: string;
+}
+
+export interface UpdateCommissionRuleDto {
+  name?: string;
+  percentage?: number;
+  criteria?: RuleCriteria;
+  startDate?: string;
+  endDate?: string;
+  description?: string;
+  isActive?: boolean;
+}
+
+export interface CommissionRuleFiltersDto {
+  type?: CommissionRuleType;
+  isActive?: boolean;
+  search?: string;
+  page: number;
+  limit: number;
+}
+
+export interface CommissionCalculationDto {
+  id: string;
+  gymId: string;
+  contractId: string;
+  collaboratorId: string;
+  ruleId: string | null;
+  percentage: number;
+  baseAmount: number;
+  amount: number;
+  status: CommissionStatus;
+  saleDate: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CommissionFiltersDto {
+  status?: CommissionStatus;
+  collaboratorId?: string;
+  startDate?: string;
+  endDate?: string;
+  page: number;
+  limit: number;
+}
+
+export interface CommissionSummaryDto {
+  period: {
+    start: string;
+    end: string;
+  };
+  totals: {
+    totalCommissions: number;
+    totalContracts: number;
+    averageCommission: number;
+    totalPaid: number;
+    totalPending: number;
+  };
+  byStatus: {
+    status: CommissionStatus;
+    count: number;
+    total: number;
+  }[];
+}
+
+export interface SimulateCommissionDto {
+  collaboratorId: string;
+  planId: string;
+  baseAmount: number;
+  saleDate: string;
+}
+
+export interface CommissionSimulationDto {
+  percentage: number;
+  baseAmount: number;
+  amount: number;
+  appliedRule: {
+    id: string;
+    name: string;
+    type: CommissionRuleType;
+    percentage: number;
+  } | null;
+  isDefault: boolean;
+}
+
+export interface CommissionComparisonDto {
+  scenarios: CommissionSimulationDto[];
+  bestScenario: {
+    index: number;
+    amount: number;
+    difference: number;
+  };
+}
+
+export interface ReportFiltersDto {
+  startDate?: string;
+  endDate?: string;
+  period?: 'week' | 'month' | 'quarter' | 'year';
+  ruleId?: string;
+  collaboratorId?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface CommissionSummaryReportDto {
+  period: {
+    start: string;
+    end: string;
+  };
+  totals: {
+    totalCommissions: number;
+    totalContracts: number;
+    averageCommission: number;
+    totalPaid: number;
+    totalPending: number;
+  };
+  byStatus: {
+    status: string;
+    count: number;
+    total: number;
+  }[];
+  byRule: {
+    ruleId: string;
+    ruleName: string;
+    ruleType: string;
+    contractsCount: number;
+    totalCommissions: number;
+    averageCommission: number;
+  }[];
+  byCollaborator: {
+    collaboratorId: string;
+    collaboratorName: string;
+    contractsCount: number;
+    totalCommissions: number;
+    averageCommission: number;
+  }[];
+  trend: {
+    date: string;
+    commissions: number;
+    contracts: number;
+  }[];
+}
+
+export interface RuleReportDto {
+  ruleId: string;
+  ruleName: string;
+  ruleType: string;
+  percentage: number;
+  contractsCount: number;
+  totalCommissions: number;
+  averageCommission: number;
+  minCommission: number;
+  maxCommission: number;
+  effectiveness: {
+    usageRate: number;
+    conversionImpact: number;
+    roi: number;
+  };
+}
+
+export interface CollaboratorReportDto {
+  collaboratorId: string;
+  collaboratorName: string;
+  roleName: string;
+  contractsCount: number;
+  totalCommissions: number;
+  averageCommission: number;
+  totalPaid: number;
+  totalPending: number;
+  performance: {
+    rank: number;
+    percentile: number;
+    comparisonWithAverage: number;
+  };
+  rulesUsed: {
+    ruleId: string;
+    ruleName: string;
+    count: number;
+    total: number;
+  }[];
+}
+
+export interface PromotionReportFiltersDto {
+  promotionId?: string;
+  status?: 'active' | 'scheduled' | 'expired';
+  startDate?: string;
+  endDate?: string;
+}
+
+export interface PromotionReportDto {
+  promotionId: string;
+  promotionName: string;
+  percentage: number;
+  startDate: string;
+  endDate: string;
+  status: string;
+  impact: {
+    contractsCreated: number;
+    totalCommissions: number;
+    averageCommission: number;
+    comparisonWithNormal: {
+      normalCommissions: number;
+      promotionalCommissions: number;
+      additionalCost: number;
+      percentageIncrease: number;
+    };
+    salesIncrease: {
+      contractsBeforePromotion: number;
+      contractsDuringPromotion: number;
+      percentageIncrease: number;
+    };
+    roi: {
+      additionalRevenue: number;
+      additionalCost: number;
+      netBenefit: number;
+      roiPercentage: number;
+    };
+  };
+}
+
+export interface CommissionHistoryFiltersDto {
+  entityType?: CommissionEntityType;
+  changeType?: CommissionChangeType;
+  startDate?: string;
+  endDate?: string;
+  page: number;
+  limit: number;
+}
+
+export interface CommissionHistoryDto {
+  id: string;
+  configId: string | null;
+  ruleId: string | null;
+  changeType: CommissionChangeType;
+  entityType: CommissionEntityType;
+  previousValue: any;
+  newValue: any;
+  changedBy: {
+    id: string;
+    name: string;
+    email: string;
+  };
+  changedAt: string;
+  reason: string | null;
+  impact: string | null;
+}
+
+export interface PaginatedCommissionResult<T> {
+  items: T[];
+  total: number;
+  limit: number;
+  offset: number;
+}

package/src/models/index.ts

@@ -25,6 +25,7 @@ export * from './whatsapp';
 export * from './bulk-messaging';
 export * from './activities';
 export * from './tags';
+export * from './commissions';
 
 export interface ApiResponse<T> {
   data: T;

package/src/resources/commission-calculations.ts

@@ -0,0 +1,93 @@
+import { BaseResource } from './base';
+import {
+  CommissionCalculationDto,
+  CommissionFiltersDto,
+  CommissionSummaryDto,
+  SimulateCommissionDto,
+  CommissionSimulationDto,
+} from '../models/commissions';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class CommissionCalculationsResource extends BaseResource {
+  private basePath = 'commissions/calculations';
+
+  async createCalculation(
+    data: { contractId: string; collaboratorId: string },
+    options?: RequestOptions,
+  ): Promise<CommissionCalculationDto> {
+    return this.client.post<CommissionCalculationDto>(this.basePath, data, options);
+  }
+
+  async getCalculation(id: string, options?: RequestOptions): Promise<CommissionCalculationDto> {
+    return this.client.get<CommissionCalculationDto>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async getCalculations(
+    params?: CommissionFiltersDto,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<CommissionCalculationDto>> {
+    return this.paginate<CommissionCalculationDto>(this.basePath, params, options);
+  }
+
+  async getCollaboratorCalculations(
+    collaboratorId: string,
+    params?: CommissionFiltersDto,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<CommissionCalculationDto>> {
+    return this.paginate<CommissionCalculationDto>(
+      `${this.basePath}/collaborator/${collaboratorId}`,
+      params,
+      options,
+    );
+  }
+
+  async confirmCalculation(
+    id: string,
+    data: { note?: string },
+    options?: RequestOptions,
+  ): Promise<CommissionCalculationDto> {
+    return this.client.put<CommissionCalculationDto>(
+      `${this.basePath}/${id}/confirm`,
+      data,
+      options,
+    );
+  }
+
+  async reverseCalculation(
+    id: string,
+    data: { reason: string },
+    options?: RequestOptions,
+  ): Promise<CommissionCalculationDto> {
+    return this.client.put<CommissionCalculationDto>(
+      `${this.basePath}/${id}/reverse`,
+      data,
+      options,
+    );
+  }
+
+  async markAsPaid(
+    id: string,
+    data: { paidDate: string; note?: string },
+    options?: RequestOptions,
+  ): Promise<CommissionCalculationDto> {
+    return this.client.put<CommissionCalculationDto>(`${this.basePath}/${id}/paid`, data, options);
+  }
+
+  async simulate(
+    data: SimulateCommissionDto,
+    options?: RequestOptions,
+  ): Promise<CommissionSimulationDto> {
+    return this.client.post<CommissionSimulationDto>('commissions/simulator', data, options);
+  }
+
+  async getMyCommissions(
+    params?: CommissionFiltersDto,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<CommissionCalculationDto>> {
+    return this.paginate<CommissionCalculationDto>('commissions/me', params, options);
+  }
+
+  async getMyCommissionsSummary(options?: RequestOptions): Promise<CommissionSummaryDto> {
+    return this.client.get<CommissionSummaryDto>('commissions/me/summary', undefined, options);
+  }
+}

package/src/resources/commission-config.ts

@@ -0,0 +1,66 @@
+import { BaseResource } from './base';
+import {
+  CommissionConfigDto,
+  CreateCommissionConfigDto,
+  UpdateCommissionConfigDto,
+  CommissionHistoryDto,
+  CommissionHistoryFiltersDto,
+} from '../models/commissions';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class CommissionConfigResource extends BaseResource {
+  private basePath = 'commissions/config';
+
+  async createConfig(
+    data: CreateCommissionConfigDto,
+    options?: RequestOptions,
+  ): Promise<CommissionConfigDto> {
+    return this.client.post<CommissionConfigDto>(this.basePath, data, options);
+  }
+
+  async getActiveConfig(options?: RequestOptions): Promise<CommissionConfigDto> {
+    return this.client.get<CommissionConfigDto>(`${this.basePath}/active`, undefined, options);
+  }
+
+  async getConfig(id: string, options?: RequestOptions): Promise<CommissionConfigDto> {
+    return this.client.get<CommissionConfigDto>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async listConfigs(
+    params?: { page: number; limit: number },
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<CommissionConfigDto>> {
+    return this.paginate<CommissionConfigDto>(this.basePath, params, options);
+  }
+
+  async updateConfig(
+    id: string,
+    data: UpdateCommissionConfigDto,
+    options?: RequestOptions,
+  ): Promise<CommissionConfigDto> {
+    return this.client.put<CommissionConfigDto>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deactivateConfig(id: string, options?: RequestOptions): Promise<CommissionConfigDto> {
+    return this.client.put<CommissionConfigDto>(`${this.basePath}/${id}/deactivate`, {}, options);
+  }
+
+  async getConfigHistory(
+    id: string,
+    params?: CommissionHistoryFiltersDto,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<CommissionHistoryDto>> {
+    return this.paginate<CommissionHistoryDto>(`${this.basePath}/${id}/history`, params, options);
+  }
+
+  async validateConfig(
+    data: CreateCommissionConfigDto,
+    options?: RequestOptions,
+  ): Promise<{ valid: boolean; errors?: string[] }> {
+    return this.client.post<{ valid: boolean; errors?: string[] }>(
+      `${this.basePath}/validate`,
+      data,
+      options,
+    );
+  }
+}

package/src/resources/commission-promotions.ts

@@ -0,0 +1,76 @@
+import { BaseResource } from './base';
+import {
+  CommissionRuleDto,
+  CreateCommissionRuleDto,
+  UpdateCommissionRuleDto,
+  CommissionRuleFiltersDto,
+} from '../models/commissions';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class CommissionPromotionsResource extends BaseResource {
+  private basePath = 'commissions/promotions';
+
+  async createPromotion(
+    data: CreateCommissionRuleDto,
+    options?: RequestOptions,
+  ): Promise<CommissionRuleDto> {
+    return this.client.post<CommissionRuleDto>(this.basePath, data, options);
+  }
+
+  async getPromotion(id: string, options?: RequestOptions): Promise<CommissionRuleDto> {
+    return this.client.get<CommissionRuleDto>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async listPromotions(
+    params?: CommissionRuleFiltersDto,
+    options?: RequestOptions,
+  ): Promise<PaginatedResponseDto<CommissionRuleDto>> {
+    return this.paginate<CommissionRuleDto>(this.basePath, params, options);
+  }
+
+  async updatePromotion(
+    id: string,
+    data: UpdateCommissionRuleDto,
+    options?: RequestOptions,
+  ): Promise<CommissionRuleDto> {
+    return this.client.put<CommissionRuleDto>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deletePromotion(id: string, options?: RequestOptions): Promise<{ success: boolean }> {
+    return this.client.delete<{ success: boolean }>(`${this.basePath}/${id}`, options);
+  }
+
+  async activatePromotion(id: string, options?: RequestOptions): Promise<CommissionRuleDto> {
+    return this.client.put<CommissionRuleDto>(`${this.basePath}/${id}/activate`, {}, options);
+  }
+
+  async deactivatePromotion(id: string, options?: RequestOptions): Promise<CommissionRuleDto> {
+    return this.client.put<CommissionRuleDto>(`${this.basePath}/${id}/deactivate`, {}, options);
+  }
+
+  async validatePromotion(
+    data: CreateCommissionRuleDto,
+    options?: RequestOptions,
+  ): Promise<{ valid: boolean; errors?: string[]; conflicts?: CommissionRuleDto[] }> {
+    return this.client.post<{ valid: boolean; errors?: string[]; conflicts?: CommissionRuleDto[] }>(
+      `${this.basePath}/validate`,
+      data,
+      options,
+    );
+  }
+
+  async estimateImpact(
+    id: string,
+    options?: RequestOptions,
+  ): Promise<{
+    estimatedContracts: number;
+    estimatedCommissions: number;
+    estimatedCost: number;
+  }> {
+    return this.client.get<{
+      estimatedContracts: number;
+      estimatedCommissions: number;
+      estimatedCost: number;
+    }>(`${this.basePath}/${id}/impact`, undefined, options);
+  }
+}