whio-api-sdk 1.0.193-bet-staging → 1.0.195-beta-staging

package/src/sdk/sdk.ts

@@ -1,1312 +1,624 @@
-// sdk.ts
-import {
-  LoginResponse,
-  LoginCredentials,
-  SDKConfig,
-  User,
-  AssignTeamRoleDto,
-  CreateTeamDto,
-  UpdateTeamDto,
-  CreateTemplateDto,
-  UpdateTemplateDto,
-  GenerateTranscriptionSummaryDto,
-  UpdateTranscriptionSummaryDto,
-  CreateTranscriptionSummaryDto,
-  AssignOrganizationRoleDto,
-  CreateUserTemplateDto,
-  UpdateUserTemplateDto,
-  CreateUserDto,
-  UpdateUserDto,
-  CreateOrganizationDto,
-  UpdateOrganizationDto,
-  CreateTemplateCategoryDto,
-  UpdateTemplateCategoryDto,
-  AssignTeamTemplateDto,
-  OrganizationRoleType,
-  RoleType,
-  Organization,
-  TemplateCategory,
-  Template,
-  Team,
-  UserTemplate,
-  TranscriptionSummary,
-  TranscriptionAudioUploadResponse,
-  ChangePasswordDto,
-  AdminChangePasswordDto,
-  PasswordChangeResponse,
-  Session,
-  CreateSessionDto,
-  UpdateSessionDto,
-  Agent,
-  CreateAgentDto,
-  UpdateAgentDto,
-  AudioFile,
-  AudioFileStatus,
-  CreateAudioFileDto,
-  UpdateAudioFileDto,
-  UploadAudioFileDto,
-  AgentSettings,
-  CreateAgentSettingsDto,
-  UpdateAgentSettingsDto,
-  Workflow,
-  CreateWorkflowDto,
-  UpdateWorkflowDto,
-  Base64AudioFile,
-  CreateBase64AudioFileDto,
-  UpdateBase64AudioFileDto,
-  AddBase64ChunkResponse,
-  Log,
-  LogsResponse,
-  LogStats,
-  FilterLogsDto,
-  CreateLogDto,
-  DebugSessionSummary,
-} from './types';
-import urls from './urls';
-import { jwtDecode } from 'jwt-decode';
-
-export class ApiSDK {
-  private baseUrl: string;
-  private storage: SDKConfig['storage'];
-  private accessToken: string | null = null;
-  private refreshToken: string | null = null;
-  private user: User | null = null;
+// Main SDK class that composes all domain modules
+import { SDKConfig } from './types';
+import { BaseClient } from './modules/base-client';
+import { AuthModule } from './modules/auth.module';
+import { UserModule } from './modules/user.module';
+import { OrganizationModule } from './modules/organization.module';
+import { TeamModule } from './modules/team.module';
+import { TemplateModule } from './modules/template.module';
+import { SessionModule } from './modules/session.module';
+import { AgentModule } from './modules/agent.module';
+import { AudioModule } from './modules/audio.module';
+import { WorkflowModule } from './modules/workflow.module';
+import { LogModule } from './modules/log.module';
+import { DebugModule } from './modules/debug.module';
+import { ExternalIntegrationModule } from './modules/external-integration.module';
+
+/**
+ * Main SDK class that provides access to all domain-specific modules
+ */
+export class ApiSDK extends BaseClient {
+  public readonly auth: AuthModule;
+  public readonly users: UserModule;
+  public readonly organizations: OrganizationModule;
+  public readonly teams: TeamModule;
+  public readonly templates: TemplateModule;
+  public readonly sessions: SessionModule;
+  public readonly agents: AgentModule;
+  public readonly audio: AudioModule;
+  public readonly workflows: WorkflowModule;
+  public readonly logs: LogModule;
+  public readonly debug: DebugModule;
+  public readonly externalIntegrations: ExternalIntegrationModule;
 
   constructor(config: SDKConfig = {}) {
-    this.baseUrl = config.baseUrl || '/api';
-    this.storage = config.storage;
-    this.initialize();
-  }
-
-  public async fetchConfig(url: string): Promise<void> {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch config from ${url}`);
-    }
-    const conf = await response.json();
-    this.baseUrl = conf.baseUrl || this.baseUrl;
-  }
-
-  private async getToken() {
-    const accessToken = await this.storage!.getItem('access_token');
-    this.accessToken = accessToken ? JSON.parse(accessToken) : null;
-    if (!this.accessToken) {
-      throw new Error('Access token not found');
-    }
-
-    // Check if token is expired or expiring soon
-    if (this.isTokenExpired(this.accessToken)) {
-      // Try to refresh the token
-      if (this.refreshToken) {
-        await this.refreshAccessToken();
-      } else {
-        throw new Error('Access token expired and no refresh token available');
-      }
-    }
-  } 
-
-  private async initialize() {
-    const accessToken = await this.storage!.getItem('access_token');
-    const refreshToken = await this.storage!.getItem('refresh_token');
-    const userString = await this.storage!.getItem('user');
-    this.user = userString ? JSON.parse(userString) : null;
-    this.accessToken = accessToken ? JSON.parse(accessToken) : null;
-    this.refreshToken = refreshToken ? JSON.parse(refreshToken) : null;
-  }
-
-  private async request<T>(
-    endpoint: string,
-    method: string = 'GET',
-    body?: any,
-    headers: Record<string, string> = {},
-    noToken: boolean = false,
-  ): Promise<T> {
-    const url = `${this.baseUrl}${endpoint}`;
-    const defaultHeaders: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'ngrok-skip-browser-warning': 'true'
-    };
-
-    if (noToken) {
-      defaultHeaders['Authorization'] = '';
-    } else {
-      // If no token is available, try to get it
-      await this.getToken();
-    }
-
-
-    if (this.accessToken) {
-      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
-    }
-
-    const response = await fetch(url, {
-      method,
-      headers: { ...defaultHeaders, ...headers },
-      body: body ? JSON.stringify(body) : undefined,
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(
-        errorData.message || `Request failed with status ${response.status}`
-      );
-    }
-
-    return response.json();
-  }
-
-  private async fileUploadRequest<T>(
-    endpoint: string,
-    body?: FormData,
-    headers: Record<string, string> = {}
-  ): Promise<T> {
-    const url = `${this.baseUrl}${endpoint}`;
-    const defaultHeaders: Record<string, string> = {
-      'ngrok-skip-browser-warning': 'true'
-    };
-
-    if (this.accessToken) {
-      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
-    }
-
-    // Don't set Content-Type for FormData - let browser set it with boundary
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: { ...defaultHeaders, ...headers },
-      body,
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(
-        errorData.message || `Request failed with status ${response.status}`
-      );
-    }
-
-    return response.json();
-  }
-
-  public async login(credentials: LoginCredentials): Promise<LoginResponse> {
-    try {
-      const response = await this.request<LoginResponse>(
-        '/auth/login',
-        'POST',
-        credentials,
-        {},
-        true
-      );
-      this.accessToken = response.access_token;
-      this.refreshToken = response.refresh_token;
-      
-      this.user = response.user;
-
-      await this.storage!.setItem('access_token', JSON.stringify(response.access_token));
-      await this.storage!.setItem('refresh_token', JSON.stringify(response.refresh_token));
-      await this.storage!.setItem('user', JSON.stringify(response.user));
-
-      return response;
-    } catch (error) {
-      await this.clearAuth();
-      throw error;
-    }
-  }
-
-  public async logout(): Promise<void> {
-    await this.clearAuth();
-  }
-
-  private async clearAuth(): Promise<void> {
-    this.accessToken = null;
-    this.refreshToken = null;
-    this.user = null;
-    await this.storage!.removeItem('access_token');
-    await this.storage!.removeItem('refresh_token');
-    await this.storage!.removeItem('user');
-  }
-
-  private isTokenExpired(token: string, bufferMinutes: number = 5): boolean {
-    try {
-      const decoded: any = jwtDecode(token);
-      const currentTime = Date.now() / 1000;
-      const bufferTime = bufferMinutes * 60;
-      
-      return decoded.exp <= (currentTime + bufferTime);
-    } catch (error) {
-      // If we can't decode the token, consider it expired
-      return true;
-    }
-  }
-
-  private async refreshAccessToken(): Promise<void> {
-    if (!this.refreshToken) {
-      throw new Error('No refresh token available');
-    }
-
-    try {
-      const response = await this.request<LoginResponse>(
-        '/auth/refresh',
-        'POST',
-        { refresh_token: this.refreshToken },
-        {},
-        true // Skip token validation for this request
-      );
-
-      this.accessToken = response.access_token;
-      this.refreshToken = response.refresh_token;
-      this.user = response.user;
-
-      await this.storage!.setItem('access_token', JSON.stringify(response.access_token));
-      await this.storage!.setItem('refresh_token', JSON.stringify(response.refresh_token));
-      await this.storage!.setItem('user', JSON.stringify(response.user));
-    } catch (error) {
-      await this.clearAuth();
-      throw new Error('Failed to refresh access token');
-    }
-  }
-
-  public isAuthenticated(): boolean {
-    return !!this.accessToken;
-  }
-
-  public getCurrentUser(): User | null {
-    return this.user;
-  }
-
-  public getAccessToken(): string | null {
-    return this.accessToken;
-  }
-
-  public getRefreshToken(): string | null {
-    return this.refreshToken;
+    super(config);
+
+    // Initialize all domain modules with the same config
+    this.auth = new AuthModule(config);
+    this.users = new UserModule(config);
+    this.organizations = new OrganizationModule(config);
+    this.teams = new TeamModule(config);
+    this.templates = new TemplateModule(config);
+    this.sessions = new SessionModule(config);
+    this.agents = new AgentModule(config);
+    this.audio = new AudioModule(config);
+    this.workflows = new WorkflowModule(config);
+    this.logs = new LogModule(config);
+    this.debug = new DebugModule(config);
+    this.externalIntegrations = new ExternalIntegrationModule(config);
   }
 
-  public async createUser(
-    firstName: string, lastName: string,
-    email: string, password: string): Promise<User> {
+  // ======================
+  // BACKWARD COMPATIBILITY LAYER
+  // Delegate methods to appropriate modules to maintain existing API
+  // ======================
 
-    const createUserDto: CreateUserDto = {
-      firstName,
-      lastName,
-      email,
-      password,
-      organizationId: this.user?.organizationId,
-    };
-
-    const user = await this.request<User>(
-      urls.users,
-      'POST',
-      createUserDto
-    );
-    return user;
-  }
-
-  private async assignRoleToUser(userId: string, roleName: OrganizationRoleType, organizationId?: string): Promise<User> {
-    const orgId = organizationId || this.user?.organizationId;
-    const organization = await this.request<Organization>(
-      `${urls.organizations}/${orgId}`,
-      'GET'
-    );
-    const orgRoleEditor = organization.roles!.find(
-      r => r.name === roleName);
-    const assignRoleDto:AssignOrganizationRoleDto = {
-      userId: userId,
-      organizationRoleId: orgRoleEditor!.id,
-    };
-    this.request(urls.userOrganizationRoles, 'POST', assignRoleDto);
-    const userWithOrgRole = await this.request<User>(
-      `${urls.user}/${userId}`,
-      'GET'
-    );
-    return userWithOrgRole;
-  }
-
-  public async assignEditorToRoleToUser(userId: string, organizationId?: string): Promise<User> {
-    return this.assignRoleToUser(userId, OrganizationRoleType.EDITOR, organizationId);
-  }
-
-  public async assignAdminToRoleToUser(userId: string, organizationId?: string): Promise<User> {
-    return this.assignRoleToUser(userId, OrganizationRoleType.ADMIN, organizationId);
-  }
-
-  public async assignDisabledToRoleToUser(userId: string, organizationId?: string): Promise<User> {
-    return this.assignRoleToUser(userId, OrganizationRoleType.DISABLED, organizationId);
-  }
-
-  public async createEditorUser(firstName: string, lastName: string,
-    email: string, password: string): Promise<User> {
-    const user = await this.createUser(firstName, lastName, email, password);
-    const userWithOrgRole = await this.assignEditorToRoleToUser(user.id);
-    return userWithOrgRole;
-  }
-
-  public async createAdminUser(firstName: string, lastName: string,
-    email: string, password: string): Promise<User> {
-    const user = await this.createUser(firstName, lastName, email, password);
-    const userWithOrgRole = await this.assignAdminToRoleToUser(user.id);
-    return userWithOrgRole;
-  }
-
-  public async createDisabledUser(firstName: string, lastName: string,
-    email: string, password: string): Promise<User> {
-    const user = await this.createUser(firstName, lastName, email, password);
-    const userWithOrgRole = await this.assignDisabledToRoleToUser(user.id);
-    return userWithOrgRole;
-  }
-
-  public async createTeam(name: string, description: string): Promise<Team> {
-    const teamDto: CreateTeamDto = {
-      name,
-      description,
-      organizationId: this.user!.organizationId,
-    };
-    return this.request(urls.teams, 'POST', teamDto);
-  }
-
-  public async updateTeam(id: string, name: string, description: string): Promise<Team> {
-    const teamDto: UpdateTeamDto = {
-      name,
-      description,
-    };
-    return this.request<Team>(`${urls.teams}/${id}`, 'PATCH', teamDto);
-  }
-
-  public async addUserToTeam(teamId: string, userId: string, roleName: string): Promise<any> {
-    const assignRoleDto: AssignTeamRoleDto = {
-      teamId,
-      userId,
-      name: roleName,
-    };
-    return this.request(urls.teamRoles, 'POST', assignRoleDto);
-  }
-
-  public async removeUserFromTeam(teamId: string, userId: string): Promise<void> {
-    await this.request(`${urls.teamRoles}/user/${userId}/team/${teamId}`, 'DELETE');
-  }
-  public async createTemplate(title: string, content: string, categoryId?: string, workflowId?: string, agentId?: string): Promise<Template> {
-    let finalCategoryId = categoryId;
-    if (!finalCategoryId) {
-      const templateCategories = await this.request<TemplateCategory[]>(
-        urls.templateCategories,
-        'GET'
-      );
-      finalCategoryId = templateCategories[0]?.id;
-      if (!finalCategoryId) {
-        throw new Error('No template categories available. Please create one first.');
-      }
-    }
-    
-    const createTemplateDto: CreateTemplateDto = {
-      title,
-      content,
-      isGlobal: false,
-      categoryId: finalCategoryId,
-      createdById: this.user!.id,
-      organizationId: this.user!.organizationId,
-      workflowId,
-      agentId,
-    };
-    return this.request<Template>(urls.templates, 'POST', createTemplateDto);
-  }
-
-  public async createUserTemplate(
-    title: string, content: string, originalTemplateId: string | undefined): Promise<UserTemplate> {
-      const createUserTemplateDto: CreateUserTemplateDto = {
-        title,
-        content,
-        originalTemplateId,
-        userId: this.user!.id,
-      };
-      return this.request(urls.userTemplates, 'POST', createUserTemplateDto);
-  }
-
-  public async updateTemplate(
-    title: string, content: string, id: string, workflowId?: string, agentId?: string): Promise<Template> {
-      const templateDto: UpdateTemplateDto = {
-        title,
-        content,
-        isGlobal: false,
-        organizationId: this.user!.organizationId,
-        workflowId,
-        agentId,
-      };
-      return this.request<Template>(
-        `${urls.templates}/${id}`,
-        'PATCH',
-        templateDto,
-      );
-  }
-
-  public async updateUserTemplate(
-    title: string, content: string, id: string): Promise<UserTemplate> {
-      const userTemplateDto: UpdateUserTemplateDto = {
-        title,
-        content,
-      };
-      return this.request<UserTemplate>(
-        `${urls.userTemplates}/${id}`,
-        'PATCH',
-        userTemplateDto,
-      );
-  }
-
-  public async getTemplates(): Promise<Template[]> {
-    return this.request<Template[]>(urls.templates, 'GET');
-  }
-
-  public async getTemplatesByOrganization(): Promise<Template[]> {
-    return this.request<Template[]>(`${urls.templates}/organization`, 'GET');
-  }
-
-  public async getUserTemplates(): Promise<UserTemplate[]> {
-    const url = `${urls.userTemplates}/user/${this.user!.id}`;
-    return this.request<UserTemplate[]>(url, 'GET');
+  // Auth methods
+  public async login(...args: Parameters<AuthModule['login']>) {
+    return this.auth.login(...args);
   }
 
-  // ======================
-  // trANSCRIPTION SUMMARY METHODS
-  // ====================== 
-
-  public async generateTranscriptionSummary(
-    templateId: string, sessionId: string): Promise<TranscriptionSummary> {
-    const generateSummaryDto: GenerateTranscriptionSummaryDto = {
-      templateId,
-      userId: this.user!.id,
-      fromUserTemplate: false,
-      sessionId: sessionId,
-    };
-    const transcriptionSummary:TranscriptionSummary = await this.request(
-      urls.transcriptionSummary,
-      'POST',
-      generateSummaryDto
-    );
-    return transcriptionSummary;
-  }
-
-  public async getByOrganizationTranscriptionSummaries(
-    organizationId: string): Promise<TranscriptionSummary[]> {
-    return this.request<TranscriptionSummary[]>(
-      `${urls.transcriptionSummaries}/organization/${organizationId}`,
-      'GET'
-    );
-  }
-
-  public async generateTranscriptionSummaryFromUserTemplate(
-    userTemplateId: string, sessionId: string): Promise<TranscriptionSummary> {
-    const generateSummaryDto: GenerateTranscriptionSummaryDto = {
-      templateId: userTemplateId,
-      userId: this.user!.id,
-      fromUserTemplate: true,
-      sessionId: sessionId,
-    };
-    const transcriptionSummary: TranscriptionSummary = await this.request(
-      urls.transcriptionSummary,
-      'POST',
-      generateSummaryDto
-    );
-    return transcriptionSummary;
-  }
-
-  public async updateTranscriptionSummary(
-    id: string, content: string): Promise<TranscriptionSummary> {
-      const updateSummaryDto: UpdateTranscriptionSummaryDto = {
-        content,
-      };
-      return this.request<TranscriptionSummary>(
-        `${urls.transcriptionSummary}/${id}`,
-        'PATCH',
-        updateSummaryDto,
-      );
-  }
-
-  public async uploadLargeAudioFile(formData: FormData): Promise<string> {
-    const uploadId: string = await this.fileUploadRequest(
-      urls.uploadAudioLarge,
-      formData
-    );
-    const uploadIds: string = await this.storage!.getItem('uploadIds') || '[]';
-    const uploadIdsArray = JSON.parse(uploadIds);
-    await this.storage!.setItem('uploadIds', JSON.stringify([...uploadIdsArray, uploadId]));
-    return uploadId;
-  }
-
-  public async uploadAudioFile(formData: FormData): Promise<TranscriptionAudioUploadResponse | null> {
-    const data: TranscriptionAudioUploadResponse = await this.fileUploadRequest(
-      urls.uploadAudio,
-      formData,
-    );
-    return data;
-  }
-
-  public async transcribeBase64Audio(base64String: string): Promise<string> {
-    const transcript = await this.request<any>(
-      urls.transcribeBase64Audio,
-      'POST',
-      { base64Audio: base64String });
-    return transcript.transcript;
+  public async logout(...args: Parameters<AuthModule['logout']>) {
+    return this.auth.logout(...args);
   }
 
-  // ======================
-  // AUTH METHODS
-  // ======================
+  public async getProfile(...args: Parameters<AuthModule['getProfile']>) {
+    return this.auth.getProfile(...args);
+  }
 
-  public async getProfile(): Promise<User> {
-    return this.request<User>(urls.profile, 'GET');
+  public async changePassword(...args: Parameters<AuthModule['changePassword']>) {
+    return this.auth.changePassword(...args);
   }
 
-  public async changePassword(currentPassword: string, newPassword: string): Promise<PasswordChangeResponse> {
-    const dto: ChangePasswordDto = {
-      currentPassword,
-      newPassword,
-    };
-    return this.request<PasswordChangeResponse>(urls.changePassword, 'PATCH', dto);
+  public async adminChangePassword(...args: Parameters<AuthModule['adminChangePassword']>) {
+    return this.auth.adminChangePassword(...args);
   }
 
-  public async adminChangePassword(userId: string, newPassword: string): Promise<PasswordChangeResponse> {
-    const dto: AdminChangePasswordDto = {
-      userId,
-      newPassword,
-    };
-    return this.request<PasswordChangeResponse>(urls.adminChangePassword, 'PATCH', dto);
+  // User methods
+  public async createUser(...args: Parameters<UserModule['createUser']>) {
+    return this.users.createUser(...args);
   }
 
-  // ======================
-  // ORGANIZATION METHODS
-  // ======================
+  public async assignEditorToRoleToUser(...args: Parameters<UserModule['assignEditorToRoleToUser']>) {
+    return this.users.assignEditorToRoleToUser(...args);
+  }
 
-  public async createOrganization(name: string, description?: string): Promise<Organization> {
-    const dto: CreateOrganizationDto = { name, description };
-    return this.request<Organization>(urls.organizations, 'POST', dto);
+  public async assignAdminToRoleToUser(...args: Parameters<UserModule['assignAdminToRoleToUser']>) {
+    return this.users.assignAdminToRoleToUser(...args);
   }
 
-  public async getOrganizations(): Promise<Organization[]> {
-    return this.request<Organization[]>(urls.organizations, 'GET');
+  public async assignDisabledToRoleToUser(...args: Parameters<UserModule['assignDisabledToRoleToUser']>) {
+    return this.users.assignDisabledToRoleToUser(...args);
   }
 
-  public async getOrganization(id: string): Promise<Organization> {
-    return this.request<Organization>(`${urls.organizations}/${id}`, 'GET');
+  public async createEditorUser(...args: Parameters<UserModule['createEditorUser']>) {
+    return this.users.createEditorUser(...args);
   }
 
-  public async updateOrganization(id: string, name?: string, description?: string): Promise<Organization> {
-    const dto: UpdateOrganizationDto = { name, description };
-    return this.request<Organization>(`${urls.organizations}/${id}`, 'PATCH', dto);
+  public async createAdminUser(...args: Parameters<UserModule['createAdminUser']>) {
+    return this.users.createAdminUser(...args);
   }
 
-  public async deleteOrganization(id: string): Promise<void> {
-    await this.request(`${urls.organizations}/${id}`, 'DELETE');
+  public async createDisabledUser(...args: Parameters<UserModule['createDisabledUser']>) {
+    return this.users.createDisabledUser(...args);
   }
 
-  public async addUserToOrganization(organizationId: string, userId: string): Promise<void> {
-    await this.request(`${urls.organizations}/${organizationId}/users/${userId}`, 'POST');
+  public async getUsers(...args: Parameters<UserModule['getUsers']>) {
+    return this.users.getUsers(...args);
   }
 
-  public async removeUserFromOrganization(organizationId: string, userId: string): Promise<void> {
-    await this.request(`${urls.organizations}/${organizationId}/users/${userId}`, 'DELETE');
+  public async getUser(...args: Parameters<UserModule['getUser']>) {
+    return this.users.getUser(...args);
   }
 
-  // ======================
-  // USER METHODS
-  // ======================
+  public async getUsersByOrganization(...args: Parameters<UserModule['getUsersByOrganization']>) {
+    return this.users.getUsersByOrganization(...args);
+  }
 
-  public async getUsers(): Promise<User[]> {
-    return this.request<User[]>(urls.users, 'GET');
+  public async updateUser(...args: Parameters<UserModule['updateUser']>) {
+    return this.users.updateUser(...args);
   }
 
-  public async getUser(id: string): Promise<User> {
-    return this.request<User>(`${urls.users}/${id}`, 'GET');
+  public async deleteUser(...args: Parameters<UserModule['deleteUser']>) {
+    return this.users.deleteUser(...args);
   }
 
-  public async getUsersByOrganization(organizationId: string): Promise<User[]> {
-    return this.request<User[]>(`${urls.users}/organization/${organizationId}`, 'GET');
+  // Organization methods
+  public async createOrganization(...args: Parameters<OrganizationModule['createOrganization']>) {
+    return this.organizations.createOrganization(...args);
   }
 
-  public async updateUser(id: string, data: UpdateUserDto): Promise<User> {
-    return this.request<User>(`${urls.users}/${id}`, 'PATCH', data);
+  public async getOrganizations(...args: Parameters<OrganizationModule['getOrganizations']>) {
+    return this.organizations.getOrganizations(...args);
   }
 
-  public async deleteUser(id: string): Promise<void> {
-    await this.request(`${urls.users}/${id}`, 'DELETE');
+  public async getOrganization(...args: Parameters<OrganizationModule['getOrganization']>) {
+    return this.organizations.getOrganization(...args);
   }
 
-  // ======================
-  // TEAM METHODS
-  // ======================
+  public async updateOrganization(...args: Parameters<OrganizationModule['updateOrganization']>) {
+    return this.organizations.updateOrganization(...args);
+  }
 
-  public async getTeams(): Promise<Team[]> {
-    return this.request<Team[]>(urls.teams, 'GET');
+  public async deleteOrganization(...args: Parameters<OrganizationModule['deleteOrganization']>) {
+    return this.organizations.deleteOrganization(...args);
   }
 
-  public async getTeam(id: string): Promise<Team> {
-    return this.request<Team>(`${urls.teams}/${id}`, 'GET');
+  public async addUserToOrganization(...args: Parameters<OrganizationModule['addUserToOrganization']>) {
+    return this.organizations.addUserToOrganization(...args);
   }
 
-  public async getTeamsByOrganization(organizationId: string): Promise<Team[]> {
-    return this.request<Team[]>(`${urls.teams}/organization/${organizationId}`, 'GET');
+  public async removeUserFromOrganization(...args: Parameters<OrganizationModule['removeUserFromOrganization']>) {
+    return this.organizations.removeUserFromOrganization(...args);
   }
 
-  public async deleteTeam(id: string): Promise<void> {
-    await this.request(`${urls.teams}/${id}`, 'DELETE');
+  public async linkExternalIntegration(...args: Parameters<OrganizationModule['linkExternalIntegration']>) {
+    return this.organizations.linkExternalIntegration(...args);
   }
 
-  // ======================
-  // TEMPLATE CATEGORY METHODS
-  // ======================
+  public async unlinkExternalIntegration(...args: Parameters<OrganizationModule['unlinkExternalIntegration']>) {
+    return this.organizations.unlinkExternalIntegration(...args);
+  }
 
-  public async getTemplateCategories(): Promise<TemplateCategory[]> {
-    return this.request<TemplateCategory[]>(urls.templateCategories, 'GET');
+  // Team methods
+  public async createTeam(...args: Parameters<TeamModule['createTeam']>) {
+    return this.teams.createTeam(...args);
   }
 
-  public async getTemplateCategory(id: string): Promise<TemplateCategory> {
-    return this.request<TemplateCategory>(`${urls.templateCategories}/${id}`, 'GET');
+  public async updateTeam(...args: Parameters<TeamModule['updateTeam']>) {
+    return this.teams.updateTeam(...args);
   }
 
-  public async createTemplateCategory(name: string): Promise<TemplateCategory> {
-    const dto: CreateTemplateCategoryDto = { name };
-    return this.request<TemplateCategory>(urls.templateCategories, 'POST', dto);
+  public async addUserToTeam(...args: Parameters<TeamModule['addUserToTeam']>) {
+    return this.teams.addUserToTeam(...args);
   }
 
-  public async updateTemplateCategory(id: string, name: string): Promise<TemplateCategory> {
-    const dto: UpdateTemplateCategoryDto = { name };
-    return this.request<TemplateCategory>(`${urls.templateCategories}/${id}`, 'PATCH', dto);
+  public async removeUserFromTeam(...args: Parameters<TeamModule['removeUserFromTeam']>) {
+    return this.teams.removeUserFromTeam(...args);
   }
 
-  public async deleteTemplateCategory(id: string): Promise<void> {
-    await this.request(`${urls.templateCategories}/${id}`, 'DELETE');
+  public async getTeams(...args: Parameters<TeamModule['getTeams']>) {
+    return this.teams.getTeams(...args);
   }
 
-  // ======================
-  // ENHANCED TEMPLATE METHODS
-  // ======================
+  public async getTeam(...args: Parameters<TeamModule['getTeam']>) {
+    return this.teams.getTeam(...args);
+  }
 
-  public async getTemplate(id: string): Promise<Template> {
-    return this.request<Template>(`${urls.templates}/${id}`, 'GET');
+  public async getTeamsByOrganization(...args: Parameters<TeamModule['getTeamsByOrganization']>) {
+    return this.teams.getTeamsByOrganization(...args);
   }
 
-  public async deleteTemplate(id: string): Promise<void> {
-    await this.request(`${urls.templates}/${id}`, 'DELETE');
+  public async deleteTeam(...args: Parameters<TeamModule['deleteTeam']>) {
+    return this.teams.deleteTeam(...args);
   }
 
-  public async getUserTemplate(id: string): Promise<UserTemplate> {
-    return this.request<UserTemplate>(`${urls.userTemplates}/${id}`, 'GET');
+  public async removeUserFromTeamFixed(...args: Parameters<TeamModule['removeUserFromTeamFixed']>) {
+    return this.teams.removeUserFromTeamFixed(...args);
   }
 
-  public async deleteUserTemplate(id: string): Promise<void> {
-    await this.request(`${urls.userTemplates}/${id}`, 'DELETE');
+  // Template methods
+  public async createTemplate(...args: Parameters<TemplateModule['createTemplate']>) {
+    return this.templates.createTemplate(...args);
   }
 
-  // ======================
-  // TEAM TEMPLATE METHODS
-  // ======================
+  public async updateTemplate(...args: Parameters<TemplateModule['updateTemplate']>) {
+    return this.templates.updateTemplate(...args);
+  }
 
-  public async assignTemplateToTeam(teamId: string, templateId: string): Promise<void> {
-    const dto: AssignTeamTemplateDto = { teamId, templateId };
-    await this.request(urls.teamTemplates, 'POST', dto);
+  public async getTemplates(...args: Parameters<TemplateModule['getTemplates']>) {
+    return this.templates.getTemplates(...args);
   }
 
-  public async removeTemplateFromTeam(teamId: string, templateId: string): Promise<void> {
-    await this.request(`${urls.teamTemplates}/team/${teamId}/template/${templateId}`, 'DELETE');
+  public async getTemplatesByOrganization(...args: Parameters<TemplateModule['getTemplatesByOrganization']>) {
+    return this.templates.getTemplatesByOrganization(...args);
   }
 
-  // ======================
-  // TRANSCRIPTION SUMMARY METHODS
-  // ======================
+  public async getTemplate(...args: Parameters<TemplateModule['getTemplate']>) {
+    return this.templates.getTemplate(...args);
+  }
 
-  public async getTranscriptionSummaries(): Promise<TranscriptionSummary[]> {
-    return this.request<TranscriptionSummary[]>(urls.transcriptionSummaries, 'GET');
+  public async deleteTemplate(...args: Parameters<TemplateModule['deleteTemplate']>) {
+    return this.templates.deleteTemplate(...args);
   }
 
-  public async getTranscriptionSummary(id: string): Promise<TranscriptionSummary> {
-    return this.request<TranscriptionSummary>(`${urls.transcriptionSummaries}/${id}`, 'GET');
+  public async createUserTemplate(...args: Parameters<TemplateModule['createUserTemplate']>) {
+    return this.templates.createUserTemplate(...args);
   }
 
-  public async getTranscriptionSummariesByUser(userId: string): Promise<TranscriptionSummary[]> {
-    return this.request<TranscriptionSummary[]>(`${urls.transcriptionSummaries}/user/${userId}`, 'GET');
+  public async updateUserTemplate(...args: Parameters<TemplateModule['updateUserTemplate']>) {
+    return this.templates.updateUserTemplate(...args);
   }
 
-  public async deleteTranscriptionSummary(id: string): Promise<void> {
-    await this.request(`${urls.transcriptionSummaries}/${id}`, 'DELETE');
+  public async getUserTemplates(...args: Parameters<TemplateModule['getUserTemplates']>) {
+    return this.templates.getUserTemplates(...args);
   }
 
-  // ======================
-  // ENHANCED TEAM ROLE METHODS
-  // ======================
+  public async getUserTemplate(...args: Parameters<TemplateModule['getUserTemplate']>) {
+    return this.templates.getUserTemplate(...args);
+  }
 
-  public async removeUserFromTeamFixed(teamId: string, userId: string): Promise<void> {
-    await this.request(`${urls.teamRoles}/user/${userId}/team/${teamId}`, 'DELETE');
+  public async deleteUserTemplate(...args: Parameters<TemplateModule['deleteUserTemplate']>) {
+    return this.templates.deleteUserTemplate(...args);
   }
 
-  // ======================
-  // SESSION METHODS
-  // ======================
+  public async getTemplateCategories(...args: Parameters<TemplateModule['getTemplateCategories']>) {
+    return this.templates.getTemplateCategories(...args);
+  }
 
-  public async createSession(sessionData: CreateSessionDto): Promise<Session> {
-    return this.request<Session>(urls.sessions, 'POST', sessionData);
+  public async getTemplateCategory(...args: Parameters<TemplateModule['getTemplateCategory']>) {
+    return this.templates.getTemplateCategory(...args);
   }
 
-  public async getSessions(): Promise<Session[]> {
-    return this.request<Session[]>(`${urls.sessions}/my-sessions`, 'GET');
+  public async createTemplateCategory(...args: Parameters<TemplateModule['createTemplateCategory']>) {
+    return this.templates.createTemplateCategory(...args);
   }
 
-  public async getSession(id: string): Promise<Session> {
-    return this.request<Session>(`${urls.sessions}/${id}`, 'GET');
+  public async updateTemplateCategory(...args: Parameters<TemplateModule['updateTemplateCategory']>) {
+    return this.templates.updateTemplateCategory(...args);
   }
 
-  public async getSessionsByUser(userId: string): Promise<Session[]> {
-    return this.request<Session[]>(`${urls.sessions}/user/${userId}`, 'GET');
+  public async deleteTemplateCategory(...args: Parameters<TemplateModule['deleteTemplateCategory']>) {
+    return this.templates.deleteTemplateCategory(...args);
   }
 
-  public async getSessionsByOrganization(): Promise<Session[]> {
-    return this.request<Session[]>(`${urls.sessions}/organization`, 'GET');
+  public async assignTemplateToTeam(...args: Parameters<TemplateModule['assignTemplateToTeam']>) {
+    return this.templates.assignTemplateToTeam(...args);
   }
 
-  public async updateSession(id: string, sessionData: UpdateSessionDto): Promise<Session> {
-    return this.request<Session>(`${urls.sessions}/${id}`, 'PATCH', sessionData);
+  public async removeTemplateFromTeam(...args: Parameters<TemplateModule['removeTemplateFromTeam']>) {
+    return this.templates.removeTemplateFromTeam(...args);
   }
 
-  public async deleteSession(id: string): Promise<void> {
-    await this.request(`${urls.sessions}/${id}`, 'DELETE');
+  public async generateTranscriptionSummary(...args: Parameters<TemplateModule['generateTranscriptionSummary']>) {
+    return this.templates.generateTranscriptionSummary(...args);
   }
 
-  public async setPrimaryTranscriptionSummary(sessionId: string, summaryId: string): Promise<Session> {
-    return this.request<Session>(`${urls.sessions}/${sessionId}/primary-summary/${summaryId}`, 'PATCH');
+  public async generateTranscriptionSummaryFromUserTemplate(...args: Parameters<TemplateModule['generateTranscriptionSummaryFromUserTemplate']>) {
+    return this.templates.generateTranscriptionSummaryFromUserTemplate(...args);
   }
 
-  public async rerunTranscription(sessionId: string): Promise<{ message: string; sessionId: string }> {
-    return this.request<{ message: string; sessionId: string }>(`${urls.sessions}/${sessionId}/rerun-transcription`, 'POST');
+  public async updateTranscriptionSummary(...args: Parameters<TemplateModule['updateTranscriptionSummary']>) {
+    return this.templates.updateTranscriptionSummary(...args);
   }
 
-  // ======================
-  // AGENT METHODS
-  // ======================
+  public async getTranscriptionSummaries(...args: Parameters<TemplateModule['getTranscriptionSummaries']>) {
+    return this.templates.getTranscriptionSummaries(...args);
+  }
 
-  public async createAgent(name: string, templateTextReplacement?: string): Promise<Agent> {
-    const dto: CreateAgentDto = { name, templateTextReplacement };
-    return this.request<Agent>(urls.agents, 'POST', dto);
+  public async getTranscriptionSummary(...args: Parameters<TemplateModule['getTranscriptionSummary']>) {
+    return this.templates.getTranscriptionSummary(...args);
   }
 
-  public async getAgents(): Promise<Agent[]> {
-    return this.request<Agent[]>(urls.agents, 'GET');
+  public async getTranscriptionSummariesByUser(...args: Parameters<TemplateModule['getTranscriptionSummariesByUser']>) {
+    return this.templates.getTranscriptionSummariesByUser(...args);
   }
 
-  public async getAgent(id: string): Promise<Agent> {
-    return this.request<Agent>(`${urls.agents}/${id}`, 'GET');
+  public async getByOrganizationTranscriptionSummaries(...args: Parameters<TemplateModule['getByOrganizationTranscriptionSummaries']>) {
+    return this.templates.getByOrganizationTranscriptionSummaries(...args);
   }
 
-  public async updateAgent(id: string, name: string, templateTextReplacement?: string): Promise<Agent> {
-    const dto: UpdateAgentDto = { name, templateTextReplacement };
-    return this.request<Agent>(`${urls.agents}/${id}`, 'PATCH', dto);
+  public async deleteTranscriptionSummary(...args: Parameters<TemplateModule['deleteTranscriptionSummary']>) {
+    return this.templates.deleteTranscriptionSummary(...args);
   }
 
-  public async deleteAgent(id: string): Promise<void> {
-    await this.request(`${urls.agents}/${id}`, 'DELETE');
+  public async uploadLargeAudioFile(...args: Parameters<TemplateModule['uploadLargeAudioFile']>) {
+    return this.templates.uploadLargeAudioFile(...args);
   }
 
-  public async addAgentToOrganization(agentId: string, organizationId: string): Promise<void> {
-    await this.request(`${urls.agents}/${agentId}/organizations/${organizationId}`, 'POST');
+  public async uploadAudioFile(...args: Parameters<TemplateModule['uploadAudioFile']>) {
+    return this.templates.uploadAudioFile(...args);
   }
 
-  public async removeAgentFromOrganization(agentId: string, organizationId: string): Promise<void> {
-    await this.request(`${urls.agents}/${agentId}/organizations/${organizationId}`, 'DELETE');
+  public async transcribeBase64Audio(...args: Parameters<TemplateModule['transcribeBase64Audio']>) {
+    return this.templates.transcribeBase64Audio(...args);
   }
 
-  // ======================
-  // AGENT SETTINGS METHODS
-  // ======================
+  // Session methods
+  public async createSession(...args: Parameters<SessionModule['createSession']>) {
+    return this.sessions.createSession(...args);
+  }
 
-  public async createAgentSettings(settingsData: CreateAgentSettingsDto): Promise<AgentSettings> {
-    return this.request<AgentSettings>(urls.agentSettings, 'POST', settingsData);
+  public async getSessions(...args: Parameters<SessionModule['getSessions']>) {
+    return this.sessions.getSessions(...args);
   }
 
-  public async getAgentSettings(organizationId?: string, agentId?: string): Promise<AgentSettings[]> {
-    const params = new URLSearchParams();
-    if (organizationId) params.append('organizationId', organizationId);
-    if (agentId) params.append('agentId', agentId);
-    
-    const queryString = params.toString();
-    const endpoint = queryString ? `${urls.agentSettings}?${queryString}` : urls.agentSettings;
-    
-    return this.request<AgentSettings[]>(endpoint, 'GET');
+  public async getSession(...args: Parameters<SessionModule['getSession']>) {
+    return this.sessions.getSession(...args);
   }
 
-  public async getAgentSettingsById(id: string): Promise<AgentSettings> {
-    return this.request<AgentSettings>(`${urls.agentSettings}/${id}`, 'GET');
+  public async getSessionsByUser(...args: Parameters<SessionModule['getSessionsByUser']>) {
+    return this.sessions.getSessionsByUser(...args);
   }
 
-  public async getAgentSettingsByAgentAndOrganization(agentId: string, organizationId: string): Promise<AgentSettings> {
-    return this.request<AgentSettings>(`${urls.agentSettings}/agent/${agentId}/organization/${organizationId}`, 'GET');
+  public async getSessionsByOrganization(...args: Parameters<SessionModule['getSessionsByOrganization']>) {
+    return this.sessions.getSessionsByOrganization(...args);
   }
 
-  public async updateAgentSettings(id: string, settingsData: UpdateAgentSettingsDto): Promise<AgentSettings> {
-    return this.request<AgentSettings>(`${urls.agentSettings}/${id}`, 'PATCH', settingsData);
+  public async updateSession(...args: Parameters<SessionModule['updateSession']>) {
+    return this.sessions.updateSession(...args);
   }
 
-  public async deleteAgentSettings(id: string): Promise<void> {
-    await this.request(`${urls.agentSettings}/${id}`, 'DELETE');
+  public async deleteSession(...args: Parameters<SessionModule['deleteSession']>) {
+    return this.sessions.deleteSession(...args);
   }
 
-  // ======================
-  // AUDIO FILE METHODS
-  // ======================
+  public async setPrimaryTranscriptionSummary(...args: Parameters<SessionModule['setPrimaryTranscriptionSummary']>) {
+    return this.sessions.setPrimaryTranscriptionSummary(...args);
+  }
 
-  public async uploadAudioFileToSession(sessionId: string, file: File | Blob, fileName?: string, culturalTranscription?: string): Promise<AudioFile> {
-    const formData = new FormData();
-    formData.append('file', file, fileName);
-    
-    if (culturalTranscription) {
-      formData.append('cultural_transcription', culturalTranscription);
-    }
-    
-    return this.fileUploadRequest<AudioFile>(`${urls.audioFiles}/upload/${sessionId}`, formData);
+  public async rerunTranscription(...args: Parameters<SessionModule['rerunTranscription']>) {
+    return this.sessions.rerunTranscription(...args);
   }
 
-  public async uploadAudioFileWithTranscriptionQueue(sessionId: string, file: File | Blob, options?: { fileName?: string; culturalTranscription?: string }): Promise<AudioFile> {
-    const formData = new FormData();
-    formData.append('file', file, options?.fileName);
-    
-    if (options?.culturalTranscription) {
-      formData.append('cultural_transcription', options.culturalTranscription);
-    }
-    
-    // This will automatically trigger the transcription queue
-    return this.fileUploadRequest<AudioFile>(`${urls.audioFiles}/upload/${sessionId}`, formData);
+  // Agent methods
+  public async createAgent(...args: Parameters<AgentModule['createAgent']>) {
+    return this.agents.createAgent(...args);
   }
 
-  public async getMyAudioFiles(): Promise<AudioFile[]> {
-    return this.request<AudioFile[]>(`${urls.audioFiles}/my-files`, 'GET');
+  public async getAgents(...args: Parameters<AgentModule['getAgents']>) {
+    return this.agents.getAgents(...args);
   }
 
-  public async getAllAudioFiles(): Promise<AudioFile[]> {
-    return this.request<AudioFile[]>(`${urls.audioFiles}/all`, 'GET');
+  public async getAgent(...args: Parameters<AgentModule['getAgent']>) {
+    return this.agents.getAgent(...args);
   }
 
-  public async getOrganizationAudioFiles(): Promise<AudioFile[]> {
-    return this.request<AudioFile[]>(`${urls.audioFiles}/organization`, 'GET');
+  public async updateAgent(...args: Parameters<AgentModule['updateAgent']>) {
+    return this.agents.updateAgent(...args);
   }
 
-  public async getAudioFilesBySession(sessionId: string): Promise<AudioFile[]> {
-    return this.request<AudioFile[]>(`${urls.audioFiles}/session/${sessionId}`, 'GET');
+  public async deleteAgent(...args: Parameters<AgentModule['deleteAgent']>) {
+    return this.agents.deleteAgent(...args);
   }
 
-  public async getAudioFile(id: string): Promise<AudioFile> {
-    return this.request<AudioFile>(`${urls.audioFiles}/${id}`, 'GET');
+  public async addAgentToOrganization(...args: Parameters<AgentModule['addAgentToOrganization']>) {
+    return this.agents.addAgentToOrganization(...args);
   }
 
-  public async updateAudioFile(id: string, updates: UpdateAudioFileDto): Promise<AudioFile> {
-    return this.request<AudioFile>(`${urls.audioFiles}/${id}`, 'PATCH', updates);
+  public async removeAgentFromOrganization(...args: Parameters<AgentModule['removeAgentFromOrganization']>) {
+    return this.agents.removeAgentFromOrganization(...args);
   }
 
-  public async deleteAudioFile(id: string): Promise<void> {
-    await this.request(`${urls.audioFiles}/${id}`, 'DELETE');
+  public async createAgentSettings(...args: Parameters<AgentModule['createAgentSettings']>) {
+    return this.agents.createAgentSettings(...args);
   }
 
-  public async downloadAudioFile(id: string): Promise<Blob> {
-    // For file downloads, we need a different approach than JSON requests
-    const url = `${this.baseUrl}${urls.audioFiles}/${id}/download`;
-    
-    // Get token first
-    await this.getToken();
-    
-    const defaultHeaders: Record<string, string> = {
-      'ngrok-skip-browser-warning': 'true'
-    };
+  public async getAgentSettings(...args: Parameters<AgentModule['getAgentSettings']>) {
+    return this.agents.getAgentSettings(...args);
+  }
 
-    if (this.accessToken) {
-      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
-    }
+  public async getAgentSettingsById(...args: Parameters<AgentModule['getAgentSettingsById']>) {
+    return this.agents.getAgentSettingsById(...args);
+  }
 
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: defaultHeaders,
-    });
+  public async getAgentSettingsByAgentAndOrganization(...args: Parameters<AgentModule['getAgentSettingsByAgentAndOrganization']>) {
+    return this.agents.getAgentSettingsByAgentAndOrganization(...args);
+  }
 
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(
-        errorData.message || `Download failed with status ${response.status}`
-      );
-    }
+  public async updateAgentSettings(...args: Parameters<AgentModule['updateAgentSettings']>) {
+    return this.agents.updateAgentSettings(...args);
+  }
 
-    return response.blob();
+  public async deleteAgentSettings(...args: Parameters<AgentModule['deleteAgentSettings']>) {
+    return this.agents.deleteAgentSettings(...args);
   }
 
-  public async downloadAudioFileAsUrl(id: string): Promise<string> {
-    const blob = await this.downloadAudioFile(id);
-    return URL.createObjectURL(blob);
+  // Audio methods
+  public async uploadAudioFileToSession(...args: Parameters<AudioModule['uploadAudioFileToSession']>) {
+    return this.audio.uploadAudioFileToSession(...args);
   }
 
-  // ======================
-  // TRANSCRIPTION QUEUE HELPER METHODS
-  // ======================
+  public async uploadAudioFileWithTranscriptionQueue(...args: Parameters<AudioModule['uploadAudioFileWithTranscriptionQueue']>) {
+    return this.audio.uploadAudioFileWithTranscriptionQueue(...args);
+  }
 
-  public async getTranscribedAudioFiles(): Promise<AudioFile[]> {
-    const audioFiles = await this.getMyAudioFiles();
-    return audioFiles.filter(file => file.status === AudioFileStatus.TRANSCRIBED && file.transcription);
+  public async getMyAudioFiles(...args: Parameters<AudioModule['getMyAudioFiles']>) {
+    return this.audio.getMyAudioFiles(...args);
   }
 
-  public async getProcessingAudioFiles(): Promise<AudioFile[]> {
-    const audioFiles = await this.getMyAudioFiles();
-    return audioFiles.filter(file => file.status === AudioFileStatus.PROCESSING);
+  public async getAllAudioFiles(...args: Parameters<AudioModule['getAllAudioFiles']>) {
+    return this.audio.getAllAudioFiles(...args);
   }
 
-  public async getFailedAudioFiles(): Promise<AudioFile[]> {
-    const audioFiles = await this.getMyAudioFiles();
-    return audioFiles.filter(file => file.status === AudioFileStatus.FAILED);
+  public async getOrganizationAudioFiles(...args: Parameters<AudioModule['getOrganizationAudioFiles']>) {
+    return this.audio.getOrganizationAudioFiles(...args);
   }
 
-  // ======================
-  // BASE64 AUDIO FILE METHODS
-  // ======================
+  public async getAudioFilesBySession(...args: Parameters<AudioModule['getAudioFilesBySession']>) {
+    return this.audio.getAudioFilesBySession(...args);
+  }
 
-  public async createBase64AudioFile(dto: CreateBase64AudioFileDto): Promise<Base64AudioFile> {
-    return this.request<Base64AudioFile>(`${urls.audioFiles}/base64`, 'POST', dto);
+  public async getAudioFile(...args: Parameters<AudioModule['getAudioFile']>) {
+    return this.audio.getAudioFile(...args);
   }
 
-  public async getAllBase64AudioFiles(): Promise<Base64AudioFile[]> {
-    return this.request<Base64AudioFile[]>(`${urls.audioFiles}/base64/all`, 'GET');
+  public async updateAudioFile(...args: Parameters<AudioModule['updateAudioFile']>) {
+    return this.audio.updateAudioFile(...args);
   }
 
-  public async getBase64AudioFilesBySession(sessionId: string): Promise<Base64AudioFile[]> {
-    return this.request<Base64AudioFile[]>(`${urls.audioFiles}/base64/session/${sessionId}`, 'GET');
+  public async deleteAudioFile(...args: Parameters<AudioModule['deleteAudioFile']>) {
+    return this.audio.deleteAudioFile(...args);
   }
 
-  public async getBase64AudioFile(id: string): Promise<Base64AudioFile> {
-    return this.request<Base64AudioFile>(`${urls.audioFiles}/base64/${id}`, 'GET');
+  public async downloadAudioFile(...args: Parameters<AudioModule['downloadAudioFile']>) {
+    return this.audio.downloadAudioFile(...args);
   }
 
-  public async updateBase64AudioFile(id: string, updates: UpdateBase64AudioFileDto): Promise<Base64AudioFile> {
-    return this.request<Base64AudioFile>(`${urls.audioFiles}/base64/${id}`, 'PATCH', updates);
+  public async downloadAudioFileAsUrl(...args: Parameters<AudioModule['downloadAudioFileAsUrl']>) {
+    return this.audio.downloadAudioFileAsUrl(...args);
   }
 
-  public async deleteBase64AudioFile(id: string): Promise<void> {
-    await this.request(`${urls.audioFiles}/base64/${id}`, 'DELETE');
+  public async getTranscribedAudioFiles(...args: Parameters<AudioModule['getTranscribedAudioFiles']>) {
+    return this.audio.getTranscribedAudioFiles(...args);
   }
 
-  public async addBase64Chunk(sessionId: string, base64Chunks: string[]): Promise<AddBase64ChunkResponse> {
-    return this.request<AddBase64ChunkResponse>(`${urls.audioFiles}/base64/add-chunk/${sessionId}`, 'POST', { base64Chunks });
+  public async getProcessingAudioFiles(...args: Parameters<AudioModule['getProcessingAudioFiles']>) {
+    return this.audio.getProcessingAudioFiles(...args);
   }
 
-  public async queueSessionBase64AudioForTranscription(sessionId: string): Promise<{ success: boolean }> {
-    return this.request<{ success: boolean }>(`${urls.audioFiles}/session/${sessionId}/transcribe`, 'POST');
+  public async getFailedAudioFiles(...args: Parameters<AudioModule['getFailedAudioFiles']>) {
+    return this.audio.getFailedAudioFiles(...args);
   }
 
-  // ======================
-  // WORKFLOW METHODS
-  // ======================
+  public async createBase64AudioFile(...args: Parameters<AudioModule['createBase64AudioFile']>) {
+    return this.audio.createBase64AudioFile(...args);
+  }
+
+  public async getAllBase64AudioFiles(...args: Parameters<AudioModule['getAllBase64AudioFiles']>) {
+    return this.audio.getAllBase64AudioFiles(...args);
+  }
+
+  public async getBase64AudioFilesBySession(...args: Parameters<AudioModule['getBase64AudioFilesBySession']>) {
+    return this.audio.getBase64AudioFilesBySession(...args);
+  }
 
-  public async createWorkflow(name: string, organizationId?: string): Promise<Workflow> {
-    const dto: CreateWorkflowDto = {
-      name,
-      organizationId: organizationId || this.user!.organizationId,
-    };
-    return this.request<Workflow>(urls.workflows, 'POST', dto);
+  public async getBase64AudioFile(...args: Parameters<AudioModule['getBase64AudioFile']>) {
+    return this.audio.getBase64AudioFile(...args);
   }
 
-  public async getWorkflows(organizationId?: string): Promise<Workflow[]> {
-    const params = organizationId ? `?organizationId=${organizationId}` : '';
-    return this.request<Workflow[]>(`${urls.workflows}${params}`, 'GET');
+  public async updateBase64AudioFile(...args: Parameters<AudioModule['updateBase64AudioFile']>) {
+    return this.audio.updateBase64AudioFile(...args);
   }
 
-  public async getWorkflow(id: string): Promise<Workflow> {
-    return this.request<Workflow>(`${urls.workflows}/${id}`, 'GET');
+  public async deleteBase64AudioFile(...args: Parameters<AudioModule['deleteBase64AudioFile']>) {
+    return this.audio.deleteBase64AudioFile(...args);
   }
 
-  public async getWorkflowsByOrganization(organizationId?: string): Promise<Workflow[]> {
-    const orgId = organizationId || this.user!.organizationId;
-    return this.request<Workflow[]>(`${urls.workflows}?organizationId=${orgId}`, 'GET');
+  public async addBase64Chunk(...args: Parameters<AudioModule['addBase64Chunk']>) {
+    return this.audio.addBase64Chunk(...args);
   }
 
-  public async updateWorkflow(id: string, name: string, organizationId?: string): Promise<Workflow> {
-    const dto: UpdateWorkflowDto = {
-      name,
-      organizationId: organizationId || this.user!.organizationId,
-    };
-    return this.request<Workflow>(`${urls.workflows}/${id}`, 'PATCH', dto);
+  public async queueSessionBase64AudioForTranscription(...args: Parameters<AudioModule['queueSessionBase64AudioForTranscription']>) {
+    return this.audio.queueSessionBase64AudioForTranscription(...args);
   }
 
-  public async deleteWorkflow(id: string): Promise<void> {
-    await this.request(`${urls.workflows}/${id}`, 'DELETE');
+  // Workflow methods
+  public async createWorkflow(...args: Parameters<WorkflowModule['createWorkflow']>) {
+    return this.workflows.createWorkflow(...args);
   }
 
-  // ===== LOGS METHODS =====
+  public async getWorkflows(...args: Parameters<WorkflowModule['getWorkflows']>) {
+    return this.workflows.getWorkflows(...args);
+  }
 
-  /**
-   * Get logs with advanced filtering options
-   */
-  public async getLogs(filters?: FilterLogsDto): Promise<LogsResponse> {
-    const params = new URLSearchParams();
+  public async getWorkflow(...args: Parameters<WorkflowModule['getWorkflow']>) {
+    return this.workflows.getWorkflow(...args);
+  }
 
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          params.append(key, value.toString());
-        }
-      });
-    }
+  public async getWorkflowsByOrganization(...args: Parameters<WorkflowModule['getWorkflowsByOrganization']>) {
+    return this.workflows.getWorkflowsByOrganization(...args);
+  }
 
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}?${queryString}` : urls.logs;
+  public async updateWorkflow(...args: Parameters<WorkflowModule['updateWorkflow']>) {
+    return this.workflows.updateWorkflow(...args);
+  }
 
-    return this.request<LogsResponse>(url, 'GET');
+  public async deleteWorkflow(...args: Parameters<WorkflowModule['deleteWorkflow']>) {
+    return this.workflows.deleteWorkflow(...args);
   }
 
-  /**
-   * Get logs for a specific user
-   */
-  public async getLogsByUser(userId: string, limit?: number, offset?: number): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
+  // Log methods
+  public async getLogs(...args: Parameters<LogModule['getLogs']>) {
+    return this.logs.getLogs(...args);
+  }
 
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}/user/${userId}?${queryString}` : `${urls.logs}/user/${userId}`;
+  public async getLogsByUser(...args: Parameters<LogModule['getLogsByUser']>) {
+    return this.logs.getLogsByUser(...args);
+  }
 
-    return this.request<LogsResponse>(url, 'GET');
+  public async getLogsByController(...args: Parameters<LogModule['getLogsByController']>) {
+    return this.logs.getLogsByController(...args);
   }
 
-  /**
-   * Get logs for a specific controller
-   */
-  public async getLogsByController(controller: string, limit?: number, offset?: number): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
+  public async getMyLogs(...args: Parameters<LogModule['getMyLogs']>) {
+    return this.logs.getMyLogs(...args);
+  }
 
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}/controller/${controller}?${queryString}` : `${urls.logs}/controller/${controller}`;
+  public async getLogsByDateRange(...args: Parameters<LogModule['getLogsByDateRange']>) {
+    return this.logs.getLogsByDateRange(...args);
+  }
 
-    return this.request<LogsResponse>(url, 'GET');
+  public async getLogStats(...args: Parameters<LogModule['getLogStats']>) {
+    return this.logs.getLogStats(...args);
   }
 
-  /**
-   * Get logs for the current authenticated user
-   */
-  public async getMyLogs(limit?: number, offset?: number): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
+  public async createLog(...args: Parameters<LogModule['createLog']>) {
+    return this.logs.createLog(...args);
+  }
 
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}/my-logs?${queryString}` : `${urls.logs}/my-logs`;
+  public async logInfo(...args: Parameters<LogModule['logInfo']>) {
+    return this.logs.logInfo(...args);
+  }
 
-    return this.request<LogsResponse>(url, 'GET');
+  public async logError(...args: Parameters<LogModule['logError']>) {
+    return this.logs.logError(...args);
   }
 
-  /**
-   * Get logs within a date range
-   */
-  public async getLogsByDateRange(
-    startDate: string,
-    endDate: string,
-    limit?: number,
-    offset?: number
-  ): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    params.append('startDate', startDate);
-    params.append('endDate', endDate);
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
+  public async logWarn(...args: Parameters<LogModule['logWarn']>) {
+    return this.logs.logWarn(...args);
+  }
 
-    return this.request<LogsResponse>(`${urls.logs}/date-range?${params.toString()}`, 'GET');
+  public async logDebug(...args: Parameters<LogModule['logDebug']>) {
+    return this.logs.logDebug(...args);
   }
 
-  /**
-   * Get logging statistics
-   */
-  public async getLogStats(): Promise<LogStats> {
-    return this.request<LogStats>(`${urls.logs}/stats`, 'GET');
+  public async getLogsByRole(...args: Parameters<LogModule['getLogsByRole']>) {
+    return this.logs.getLogsByRole(...args);
   }
-
-  /**
-   * Create a manual log entry (app logs)
-   */
-  public async createLog(logData: CreateLogDto): Promise<Log> {
-    return this.request<Log>(urls.logs, 'POST', logData);
+
+  public async getLogsByOrganizationRole(...args: Parameters<LogModule['getLogsByOrganizationRole']>) {
+    return this.logs.getLogsByOrganizationRole(...args);
   }
 
-  /**
-   * Convenience methods for different log levels
-   */
-  public async logInfo(message: string, context?: string, action?: string, data?: any): Promise<Log> {
-    return this.createLog({
-      level: 'info',
-      message,
-      context,
-      action,
-      data,
-    });
-  }
-
-  public async logError(message: string, context?: string, action?: string, data?: any): Promise<Log> {
-    return this.createLog({
-      level: 'error',
-      message,
-      context,
-      action,
-      data,
-    });
-  }
-
-  public async logWarn(message: string, context?: string, action?: string, data?: any): Promise<Log> {
-    return this.createLog({
-      level: 'warn',
-      message,
-      context,
-      action,
-      data,
-    });
-  }
-
-  public async logDebug(message: string, context?: string, action?: string, data?: any): Promise<Log> {
-    return this.createLog({
-      level: 'debug',
-      message,
-      context,
-      action,
-      data,
-    });
-  }
-
-  /**
-   * Get logs by role
-   */
-  public async getLogsByRole(role: string, limit?: number, offset?: number): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
-
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}/role/${role}?${queryString}` : `${urls.logs}/role/${role}`;
-
-    return this.request<LogsResponse>(url, 'GET');
-  }
-
-  /**
-   * Get logs by organization role
-   */
-  public async getLogsByOrganizationRole(organizationRole: string, limit?: number, offset?: number): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
-
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}/organization-role/${organizationRole}?${queryString}` : `${urls.logs}/organization-role/${organizationRole}`;
-
-    return this.request<LogsResponse>(url, 'GET');
-  }
-
-  /**
-   * Get logs by team role
-   */
-  public async getLogsByTeamRole(teamRole: string, limit?: number, offset?: number): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
-
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}/team-role/${teamRole}?${queryString}` : `${urls.logs}/team-role/${teamRole}`;
-
-    return this.request<LogsResponse>(url, 'GET');
-  }
-
-  /**
-   * Get available roles for filtering
-   */
-  public async getAvailableRoles(): Promise<{
-    roles: string[];
-    organizationRoles: string[];
-    teamRoles: string[];
-  }> {
-    return this.request<{
-      roles: string[];
-      organizationRoles: string[];
-      teamRoles: string[];
-    }>(`${urls.logs}/available-roles`, 'GET');
-  }
-
-  /**
-   * Get logs for a specific session ID
-   * Searches both log messages and meta data for the session ID
-   */
-  public async getSessionLogs(sessionId: string, limit?: number, offset?: number): Promise<LogsResponse> {
-    const params = new URLSearchParams();
-    if (limit !== undefined) params.append('limit', limit.toString());
-    if (offset !== undefined) params.append('offset', offset.toString());
-
-    const queryString = params.toString();
-    const url = queryString ? `${urls.logs}/session/${sessionId}?${queryString}` : `${urls.logs}/session/${sessionId}`;
-
-    return this.request<LogsResponse>(url, 'GET');
-  }
-
-  // ===== DEBUG METHODS =====
-
-  /**
-   * Get sessions that do not have medical transcriptions and primary transcription summaries
-   * for the current user's organization
-   */
-  public async getSessionsWithoutMedicalTranscriptions(): Promise<DebugSessionSummary[]> {
-    return this.request<DebugSessionSummary[]>(`${urls.debug}/sessions/missing-medical-transcriptions`, 'GET');
-  }
-
-  /**
-   * Download a session as a ZIP file containing all related data (decrypted)
-   * Returns a Blob that can be used to create a download link
-   */
-  public async downloadSessionAsZip(sessionId: string): Promise<Blob> {
-    const url = `${this.baseUrl}${urls.debug}/sessions/${sessionId}/download`;
-    
-    // Get token first
-    await this.getToken();
-    
-    const defaultHeaders: Record<string, string> = {
-      'ngrok-skip-browser-warning': 'true'
-    };
-
-    if (this.accessToken) {
-      defaultHeaders['Authorization'] = `Bearer ${this.accessToken}`;
-    }
-
-    const response = await fetch(url, {
-      method: 'GET',
-      headers: defaultHeaders,
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(
-        errorData.message || `Download failed with status ${response.status}`
-      );
-    }
-
-    return response.blob();
-  }
-
-  /**
-   * Download a session as a ZIP file and create a download URL
-   * Returns a URL that can be used for direct download
-   */
-  public async downloadSessionAsZipUrl(sessionId: string): Promise<string> {
-    const blob = await this.downloadSessionAsZip(sessionId);
-    return URL.createObjectURL(blob);
-  }
-
-  /**
-   * Download a session as a ZIP file and trigger browser download
-   * Optionally provide a custom filename
-   */
-  public async downloadSessionAndTriggerDownload(sessionId: string, filename?: string): Promise<void> {
-    const blob = await this.downloadSessionAsZip(sessionId);
-    const url = URL.createObjectURL(blob);
-    
-    // Create temporary download link and click it
-    const link = document.createElement('a');
-    link.href = url;
-    link.download = filename || `session_${sessionId}_${new Date().toISOString().split('T')[0]}.zip`;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    
-    // Clean up the URL object
-    URL.revokeObjectURL(url);
-  }
-
-}
+  public async getLogsByTeamRole(...args: Parameters<LogModule['getLogsByTeamRole']>) {
+    return this.logs.getLogsByTeamRole(...args);
+  }
+
+  public async getAvailableRoles(...args: Parameters<LogModule['getAvailableRoles']>) {
+    return this.logs.getAvailableRoles(...args);
+  }
+
+  public async getSessionLogs(...args: Parameters<LogModule['getSessionLogs']>) {
+    return this.logs.getSessionLogs(...args);
+  }
+
+  // Debug methods
+  public async getSessionsWithoutMedicalTranscriptions(...args: Parameters<DebugModule['getSessionsWithoutMedicalTranscriptions']>) {
+    return this.debug.getSessionsWithoutMedicalTranscriptions(...args);
+  }
+
+  public async downloadSessionAsZip(...args: Parameters<DebugModule['downloadSessionAsZip']>) {
+    return this.debug.downloadSessionAsZip(...args);
+  }
+
+  public async downloadSessionAsZipUrl(...args: Parameters<DebugModule['downloadSessionAsZipUrl']>) {
+    return this.debug.downloadSessionAsZipUrl(...args);
+  }
+
+  public async downloadSessionAndTriggerDownload(...args: Parameters<DebugModule['downloadSessionAndTriggerDownload']>) {
+    return this.debug.downloadSessionAndTriggerDownload(...args);
+  }
+
+  // External Integration methods
+  public async createExternalIntegration(...args: Parameters<ExternalIntegrationModule['createExternalIntegration']>) {
+    return this.externalIntegrations.createExternalIntegration(...args);
+  }
+
+  public async getExternalIntegrations(...args: Parameters<ExternalIntegrationModule['getExternalIntegrations']>) {
+    return this.externalIntegrations.getExternalIntegrations(...args);
+  }
+
+  public async getExternalIntegration(...args: Parameters<ExternalIntegrationModule['getExternalIntegration']>) {
+    return this.externalIntegrations.getExternalIntegration(...args);
+  }
+
+  public async updateExternalIntegration(...args: Parameters<ExternalIntegrationModule['updateExternalIntegration']>) {
+    return this.externalIntegrations.updateExternalIntegration(...args);
+  }
+
+  public async deleteExternalIntegration(...args: Parameters<ExternalIntegrationModule['deleteExternalIntegration']>) {
+    return this.externalIntegrations.deleteExternalIntegration(...args);
+  }
+}