@gymspace/sdk 1.0.0

package/src/resources/invitations.ts

@@ -0,0 +1,38 @@
+import { BaseResource } from './base';
+import { 
+  Invitation, 
+  CreateInvitationDto, 
+  AcceptInvitationDto,
+  GetGymInvitationsParams 
+} from '../models/invitations';
+import { RequestOptions } from '../types';
+
+export class InvitationsResource extends BaseResource {
+  private basePath = 'invitations';
+
+  async createInvitation(
+    data: CreateInvitationDto, 
+    options?: RequestOptions
+  ): Promise<Invitation> {
+    return this.client.post<Invitation>(this.basePath, data, options);
+  }
+
+  async getGymInvitations(
+    params: GetGymInvitationsParams,
+    options?: RequestOptions
+  ): Promise<Invitation[]> {
+    return this.client.get<Invitation[]>(this.basePath, params, options);
+  }
+
+  async acceptInvitation(
+    token: string,
+    data: AcceptInvitationDto,
+    options?: RequestOptions
+  ): Promise<void> {
+    return this.client.post<void>(`${this.basePath}/${token}/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/leads.ts

@@ -0,0 +1,48 @@
+import { BaseResource } from './base';
+import { 
+  Lead, 
+  CreateLeadDto, 
+  UpdateLeadDto,
+  SearchLeadsParams,
+  LeadStats 
+} from '../models/leads';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class LeadsResource extends BaseResource {
+  private basePath = 'leads';
+
+  async createLead(data: CreateLeadDto, options?: RequestOptions): Promise<Lead> {
+    return this.client.post<Lead>(this.basePath, data, options);
+  }
+
+  async searchLeads(
+    params?: SearchLeadsParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<Lead>> {
+    return this.paginate<Lead>(this.basePath, params, options);
+  }
+
+  async getLead(id: string, options?: RequestOptions): Promise<Lead> {
+    return this.client.get<Lead>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateLead(
+    id: string,
+    data: UpdateLeadDto,
+    options?: RequestOptions
+  ): Promise<Lead> {
+    return this.client.put<Lead>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async getLeadStats(options?: RequestOptions): Promise<LeadStats> {
+    return this.client.get<LeadStats>(`${this.basePath}/stats/gym`, undefined, options);
+  }
+
+  async convertLead(id: string, options?: RequestOptions): Promise<{ clientId: string }> {
+    return this.client.post<{ clientId: string }>(
+      `${this.basePath}/${id}/convert`,
+      undefined,
+      options
+    );
+  }
+}

package/src/resources/membership-plans.ts

@@ -0,0 +1,54 @@
+import { BaseResource } from './base';
+import { 
+  MembershipPlan, 
+  CreateMembershipPlanDto, 
+  UpdateMembershipPlanDto, 
+  MembershipPlanStats,
+  GetMembershipPlansParams 
+} from '../models/membership-plans';
+import { RequestOptions } from '../types';
+
+export class MembershipPlansResource extends BaseResource {
+  private basePath = 'membership-plans';
+
+  async createMembershipPlan(
+    data: CreateMembershipPlanDto, 
+    options?: RequestOptions
+  ): Promise<MembershipPlan> {
+    return this.client.post<MembershipPlan>(this.basePath, data, options);
+  }
+
+  async getGymMembershipPlans(
+    params?: GetMembershipPlansParams,
+    options?: RequestOptions
+  ): Promise<MembershipPlan[]> {
+    return this.client.get<MembershipPlan[]>(this.basePath, params, options);
+  }
+
+  async getMembershipPlan(id: string, options?: RequestOptions): Promise<MembershipPlan> {
+    return this.client.get<MembershipPlan>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateMembershipPlan(
+    id: string,
+    data: UpdateMembershipPlanDto,
+    options?: RequestOptions
+  ): Promise<MembershipPlan> {
+    return this.client.put<MembershipPlan>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deleteMembershipPlan(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  async getMembershipPlanStats(
+    id: string, 
+    options?: RequestOptions
+  ): Promise<MembershipPlanStats> {
+    return this.client.get<MembershipPlanStats>(
+      `${this.basePath}/${id}/stats`, 
+      undefined, 
+      options
+    );
+  }
+}

package/src/resources/onboarding.ts

@@ -0,0 +1,58 @@
+import { BaseResource } from './base';
+import {
+  StartOnboardingData,
+  StartOnboardingResponse,
+  UpdateGymSettingsData,
+  ConfigureFeaturesData,
+  CompleteGuidedSetupData,
+  OnboardingStatus,
+  OnboardingResponse,
+} from '../models/onboarding';
+
+export class OnboardingResource extends BaseResource {
+  /**
+   * Creates owner account, organization, and initial gym
+   * Now also sends verification and organization codes via email
+   */
+  async start(data: StartOnboardingData): Promise<StartOnboardingResponse> {
+    const response = await this.client.post<StartOnboardingResponse>('/onboarding/start', data);
+    
+    // Store tokens after successful onboarding start
+    if (response.access_token && response.refresh_token) {
+      this.client.setTokens(response.access_token, response.refresh_token);
+    }
+    
+    return response;
+  }
+
+  /**
+   * Updates basic gym settings (step 2 of onboarding)
+   * Configure basic gym information like name, address, etc.
+   */
+  async updateGymSettings(data: UpdateGymSettingsData): Promise<OnboardingResponse> {
+    return this.client.put<OnboardingResponse>('/onboarding/gym-settings', data);
+  }
+
+  /**
+   * Configure gym features (step 3 of onboarding)
+   * Enable/disable various management features
+   */
+  async configureFeatures(data: ConfigureFeaturesData): Promise<OnboardingResponse> {
+    return this.client.put<OnboardingResponse>('/onboarding/configure-features', data);
+  }
+
+  /**
+   * Mark onboarding as complete
+   */
+  async completeSetup(data: CompleteGuidedSetupData): Promise<OnboardingResponse> {
+    return this.client.post<OnboardingResponse>('/onboarding/complete', data);
+  }
+
+  /**
+   * Get current onboarding status
+   * Check progress and next steps
+   */
+  async getStatus(gymId: string): Promise<OnboardingStatus> {
+    return this.client.get<OnboardingStatus>(`/onboarding/status/${gymId}`);
+  }
+}

package/src/resources/organizations.ts

@@ -0,0 +1,23 @@
+import { BaseResource } from './base';
+import { Organization, UpdateOrganizationDto, OrganizationStats } from '../models/organizations';
+import { RequestOptions } from '../types';
+
+export class OrganizationsResource extends BaseResource {
+  private basePath = 'organizations';
+
+  async getOrganization(id: string, options?: RequestOptions): Promise<Organization> {
+    return this.client.get<Organization>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateOrganization(
+    id: string, 
+    data: UpdateOrganizationDto, 
+    options?: RequestOptions
+  ): Promise<Organization> {
+    return this.client.put<Organization>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async getOrganizationStats(id: string, options?: RequestOptions): Promise<OrganizationStats> {
+    return this.client.get<OrganizationStats>(`${this.basePath}/${id}/stats`, undefined, options);
+  }
+}

package/src/resources/products.ts

@@ -0,0 +1,91 @@
+import { BaseResource } from './base';
+import { 
+  Product,
+  ProductCategory,
+  CreateProductDto, 
+  UpdateProductDto,
+  UpdateStockDto,
+  CreateProductCategoryDto,
+  UpdateProductCategoryDto,
+  SearchProductsParams
+} from '../models/products';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class ProductsResource extends BaseResource {
+  private basePath = 'products';
+
+  // Product Category Methods
+  async createCategory(
+    data: CreateProductCategoryDto, 
+    options?: RequestOptions
+  ): Promise<ProductCategory> {
+    return this.client.post<ProductCategory>(`${this.basePath}/categories`, data, options);
+  }
+
+  async getCategories(options?: RequestOptions): Promise<ProductCategory[]> {
+    return this.client.get<ProductCategory[]>(`${this.basePath}/categories`, undefined, options);
+  }
+
+  async updateCategory(
+    id: string,
+    data: UpdateProductCategoryDto,
+    options?: RequestOptions
+  ): Promise<ProductCategory> {
+    return this.client.put<ProductCategory>(`${this.basePath}/categories/${id}`, data, options);
+  }
+
+  async deleteCategory(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/categories/${id}`, options);
+  }
+
+  // Product Methods
+  async createProduct(data: CreateProductDto, options?: RequestOptions): Promise<Product> {
+    return this.client.post<Product>(this.basePath, data, options);
+  }
+
+  async searchProducts(
+    params?: SearchProductsParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<Product>> {
+    return this.paginate<Product>(this.basePath, params, options);
+  }
+
+  async getProduct(id: string, options?: RequestOptions): Promise<Product> {
+    return this.client.get<Product>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateProduct(
+    id: string,
+    data: UpdateProductDto,
+    options?: RequestOptions
+  ): Promise<Product> {
+    return this.client.put<Product>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deleteProduct(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  async toggleProductStatus(id: string, options?: RequestOptions): Promise<Product> {
+    return this.client.patch<Product>(`${this.basePath}/${id}/toggle-status`, undefined, options);
+  }
+
+  async updateStock(
+    id: string,
+    data: UpdateStockDto,
+    options?: RequestOptions
+  ): Promise<Product> {
+    return this.client.patch<Product>(`${this.basePath}/${id}/stock`, data, options);
+  }
+
+  async getLowStockProducts(
+    threshold: number = 10,
+    options?: RequestOptions
+  ): Promise<Product[]> {
+    return this.client.get<Product[]>(
+      `${this.basePath}/low-stock`,
+      { threshold },
+      options
+    );
+  }
+}

package/src/resources/public-catalog.ts

@@ -0,0 +1,61 @@
+import { BaseResource } from './base';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+import { PaginationQueryDto } from '../types';
+
+export interface SearchCatalogParams extends PaginationQueryDto {
+  search?: string;
+  city?: string;
+  state?: string;
+  latitude?: string;
+  longitude?: string;
+  radius?: string;
+}
+
+export interface GetFeaturedGymsParams {
+  limit: string;
+}
+
+export interface CatalogGym {
+  id: string;
+  name: string;
+  slug: string;
+  address?: string;
+  city?: string;
+  state?: string;
+  phone?: string;
+  email?: string;
+  amenities?: any;
+  settings?: any;
+}
+
+export interface CityWithGyms {
+  city: string;
+  state: string;
+  count: number;
+}
+
+export class PublicCatalogResource extends BaseResource {
+  private basePath = 'catalog';
+
+  async searchCatalog(
+    params?: SearchCatalogParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<CatalogGym>> {
+    return this.paginate<CatalogGym>(`${this.basePath}/search`, params, options);
+  }
+
+  async getFeaturedGyms(
+    params: GetFeaturedGymsParams,
+    options?: RequestOptions
+  ): Promise<CatalogGym[]> {
+    return this.client.get<CatalogGym[]>(`${this.basePath}/featured`, params, options);
+  }
+
+  async getCitiesWithGyms(options?: RequestOptions): Promise<CityWithGyms[]> {
+    return this.client.get<CityWithGyms[]>(`${this.basePath}/cities`, undefined, options);
+  }
+
+  async getGymBySlug(slug: string, options?: RequestOptions): Promise<CatalogGym> {
+    return this.client.get<CatalogGym>(`${this.basePath}/${slug}`, undefined, options);
+  }
+}

package/src/resources/sales.ts

@@ -0,0 +1,83 @@
+import { BaseResource } from './base';
+import { 
+  Sale,
+  CreateSaleDto, 
+  UpdateSaleDto,
+  UpdatePaymentStatusDto,
+  SearchSalesParams,
+  SalesStats,
+  TopSellingProduct
+} from '../models/sales';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class SalesResource extends BaseResource {
+  private basePath = 'sales';
+
+  async createSale(data: CreateSaleDto, options?: RequestOptions): Promise<Sale> {
+    return this.client.post<Sale>(this.basePath, data, options);
+  }
+
+  async searchSales(
+    params?: SearchSalesParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<Sale>> {
+    return this.paginate<Sale>(this.basePath, params, options);
+  }
+
+  async getSale(id: string, options?: RequestOptions): Promise<Sale> {
+    return this.client.get<Sale>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateSale(
+    id: string,
+    data: UpdateSaleDto,
+    options?: RequestOptions
+  ): Promise<Sale> {
+    return this.client.put<Sale>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async updatePaymentStatus(
+    id: string,
+    data: UpdatePaymentStatusDto,
+    options?: RequestOptions
+  ): Promise<Sale> {
+    return this.client.put<Sale>(`${this.basePath}/${id}/payment-status`, data, options);
+  }
+
+  async deleteSale(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  async getSalesStats(
+    startDate?: string,
+    endDate?: string,
+    options?: RequestOptions
+  ): Promise<SalesStats> {
+    const params: Record<string, string> = {};
+    if (startDate) params.startDate = startDate;
+    if (endDate) params.endDate = endDate;
+
+    return this.client.get<SalesStats>(
+      `${this.basePath}/stats`,
+      Object.keys(params).length > 0 ? params : undefined,
+      options
+    );
+  }
+
+  async getTopSellingProducts(
+    limit: number = 10,
+    startDate?: string,
+    endDate?: string,
+    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
+    );
+  }
+}

package/src/resources/suppliers.ts

@@ -0,0 +1,44 @@
+import { BaseResource } from './base';
+import { 
+  Supplier,
+  CreateSupplierDto, 
+  UpdateSupplierDto,
+  SearchSuppliersParams,
+  SuppliersStats
+} from '../models/suppliers';
+import { RequestOptions, PaginatedResponseDto } from '../types';
+
+export class SuppliersResource extends BaseResource {
+  private basePath = 'suppliers';
+
+  async createSupplier(data: CreateSupplierDto, options?: RequestOptions): Promise<Supplier> {
+    return this.client.post<Supplier>(this.basePath, data, options);
+  }
+
+  async searchSuppliers(
+    params?: SearchSuppliersParams,
+    options?: RequestOptions
+  ): Promise<PaginatedResponseDto<Supplier>> {
+    return this.paginate<Supplier>(this.basePath, params, options);
+  }
+
+  async getSupplier(id: string, options?: RequestOptions): Promise<Supplier> {
+    return this.client.get<Supplier>(`${this.basePath}/${id}`, undefined, options);
+  }
+
+  async updateSupplier(
+    id: string,
+    data: UpdateSupplierDto,
+    options?: RequestOptions
+  ): Promise<Supplier> {
+    return this.client.put<Supplier>(`${this.basePath}/${id}`, data, options);
+  }
+
+  async deleteSupplier(id: string, options?: RequestOptions): Promise<void> {
+    return this.client.delete<void>(`${this.basePath}/${id}`, options);
+  }
+
+  async getSuppliersStats(options?: RequestOptions): Promise<SuppliersStats> {
+    return this.client.get<SuppliersStats>(`${this.basePath}/stats`, undefined, options);
+  }
+}

package/src/resources/users.ts

@@ -0,0 +1,27 @@
+import { BaseResource } from './base';
+import { UserProfileDto, UpdateProfileDto } from '../models/users';
+import { RequestOptions } from '../types';
+
+export class UsersResource extends BaseResource {
+  /**
+   * Get the current user's profile
+   * @param options - Request options
+   * @returns User profile data
+   */
+  async getProfile(options?: RequestOptions): Promise<UserProfileDto> {
+    return this.client.get<UserProfileDto>('/users/profile', undefined, options);
+  }
+
+  /**
+   * Update the current user's profile
+   * @param data - Profile update data
+   * @param options - Request options
+   * @returns Updated user profile
+   */
+  async updateProfile(
+    data: UpdateProfileDto,
+    options?: RequestOptions
+  ): Promise<UserProfileDto> {
+    return this.client.put<UserProfileDto>('/users/profile', data, options);
+  }
+}

package/src/sdk.ts

@@ -0,0 +1,104 @@
+import { ApiClient } from './client';
+import { GymSpaceConfig } from './types';
+import {
+  AuthResource,
+  OrganizationsResource,
+  GymsResource,
+  ClientsResource,
+  MembershipPlansResource,
+  ContractsResource,
+  DashboardResource,
+  EvaluationsResource,
+  CheckInsResource,
+  InvitationsResource,
+  LeadsResource,
+  AssetsResource,
+  FilesResource,
+  PublicCatalogResource,
+  HealthResource,
+  OnboardingResource,
+  ProductsResource,
+  SalesResource,
+  SuppliersResource,
+  UsersResource,
+} from './resources';
+
+export class GymSpaceSdk {
+  private client: ApiClient;
+  
+  // Resources
+  public auth: AuthResource;
+  public organizations: OrganizationsResource;
+  public gyms: GymsResource;
+  public clients: ClientsResource;
+  public membershipPlans: MembershipPlansResource;
+  public contracts: ContractsResource;
+  public dashboard: DashboardResource;
+  public evaluations: EvaluationsResource;
+  public checkIns: CheckInsResource;
+  public invitations: InvitationsResource;
+  public leads: LeadsResource;
+  public assets: AssetsResource;
+  public files: FilesResource;
+  public publicCatalog: PublicCatalogResource;
+  public health: HealthResource;
+  public onboarding: OnboardingResource;
+  public products: ProductsResource;
+  public sales: SalesResource;
+  public suppliers: SuppliersResource;
+  public users: UsersResource;
+
+  constructor(config: GymSpaceConfig) {
+    this.client = new ApiClient(config);
+    
+    // Initialize resources
+    this.auth = new AuthResource(this.client);
+    this.organizations = new OrganizationsResource(this.client);
+    this.gyms = new GymsResource(this.client);
+    this.clients = new ClientsResource(this.client);
+    this.membershipPlans = new MembershipPlansResource(this.client);
+    this.contracts = new ContractsResource(this.client);
+    this.dashboard = new DashboardResource(this.client);
+    this.evaluations = new EvaluationsResource(this.client);
+    this.checkIns = new CheckInsResource(this.client);
+    this.invitations = new InvitationsResource(this.client);
+    this.leads = new LeadsResource(this.client);
+    this.assets = new AssetsResource(this.client);
+    this.files = new FilesResource(this.client);
+    this.publicCatalog = new PublicCatalogResource(this.client);
+    this.health = new HealthResource(this.client);
+    this.onboarding = new OnboardingResource(this.client);
+    this.products = new ProductsResource(this.client);
+    this.sales = new SalesResource(this.client);
+    this.suppliers = new SuppliersResource(this.client);
+    this.users = new UsersResource(this.client);
+  }
+
+  /**
+   * Set the authentication token
+   */
+  setAuthToken(token: string): void {
+    this.client.setAuthToken(token);
+  }
+
+  /**
+   * Set the current gym context
+   */
+  setGymId(gymId: string): void {
+    this.client.setGymId(gymId);
+  }
+
+  /**
+   * Clear authentication
+   */
+  clearAuth(): void {
+    this.client.clearAuth();
+  }
+
+  /**
+   * Get the underlying API client
+   */
+  getClient(): ApiClient {
+    return this.client;
+  }
+}

package/src/types.ts

@@ -0,0 +1,41 @@
+export interface GymSpaceConfig {
+  baseURL: string;
+  apiKey?: string;
+  refreshToken?: string;
+  timeout?: number;
+  headers?: Record<string, string>;
+}
+
+export interface RequestOptions {
+  gymId?: string;
+  headers?: Record<string, string>;
+}
+
+export interface PaginationParams {
+  limit?: number;
+  offset?: number;
+}
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  meta: {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrevious: boolean;
+  };
+}
+
+// Legacy alias for compatibility
+export type PaginatedResponseDto<T> = PaginatedResponse<T>;
+
+// Import specific types we need from shared
+import type { PaginationParams as SharedPaginationParams } from '@gymspace/shared';
+
+// Re-export as PaginationQueryDto for backward compatibility
+export type PaginationQueryDto = SharedPaginationParams;
+
+// Re-export shared types
+export * from '@gymspace/shared';