whio-api-sdk 1.0.192-bet-staging → 1.0.194-beta-staging

package/src/sdk/modules/log.module.ts

@@ -0,0 +1,213 @@
+import { BaseClient } from './base-client';
+import { Log, LogsResponse, LogStats, FilterLogsDto, CreateLogDto } from '../types';
+import urls from '../urls';
+
+export class LogModule extends BaseClient {
+  /**
+   * Get logs with advanced filtering options
+   */
+  public async getLogs(filters?: FilterLogsDto): Promise<LogsResponse> {
+    const params = new URLSearchParams();
+
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          params.append(key, value.toString());
+        }
+      });
+    }
+
+    const queryString = params.toString();
+    const url = queryString ? `${urls.logs}?${queryString}` : urls.logs;
+
+    return this.request<LogsResponse>(url, 'GET');
+  }
+
+  /**
+   * 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());
+
+    const queryString = params.toString();
+    const url = queryString ? `${urls.logs}/user/${userId}?${queryString}` : `${urls.logs}/user/${userId}`;
+
+    return this.request<LogsResponse>(url, 'GET');
+  }
+
+  /**
+   * 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());
+
+    const queryString = params.toString();
+    const url = queryString ? `${urls.logs}/controller/${controller}?${queryString}` : `${urls.logs}/controller/${controller}`;
+
+    return this.request<LogsResponse>(url, 'GET');
+  }
+
+  /**
+   * 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());
+
+    const queryString = params.toString();
+    const url = queryString ? `${urls.logs}/my-logs?${queryString}` : `${urls.logs}/my-logs`;
+
+    return this.request<LogsResponse>(url, 'GET');
+  }
+
+  /**
+   * 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());
+
+    return this.request<LogsResponse>(`${urls.logs}/date-range?${params.toString()}`, 'GET');
+  }
+
+  /**
+   * Get logging statistics
+   */
+  public async getLogStats(): Promise<LogStats> {
+    return this.request<LogStats>(`${urls.logs}/stats`, 'GET');
+  }
+
+  /**
+   * Create a manual log entry (app logs)
+   */
+  public async createLog(logData: CreateLogDto): Promise<Log> {
+    return this.request<Log>(urls.logs, 'POST', logData);
+  }
+
+  /**
+   * 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
+   */
+  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');
+  }
+}

package/src/sdk/modules/organization.module.ts

@@ -0,0 +1,35 @@
+import { BaseClient } from './base-client';
+import { Organization, CreateOrganizationDto, UpdateOrganizationDto } from '../types';
+import urls from '../urls';
+
+export class OrganizationModule extends BaseClient {
+  public async createOrganization(name: string, description?: string): Promise<Organization> {
+    const dto: CreateOrganizationDto = { name, description };
+    return this.request<Organization>(urls.organizations, 'POST', dto);
+  }
+
+  public async getOrganizations(): Promise<Organization[]> {
+    return this.request<Organization[]>(urls.organizations, 'GET');
+  }
+
+  public async getOrganization(id: string): Promise<Organization> {
+    return this.request<Organization>(`${urls.organizations}/${id}`, 'GET');
+  }
+
+  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 deleteOrganization(id: string): Promise<void> {
+    await this.request(`${urls.organizations}/${id}`, 'DELETE');
+  }
+
+  public async addUserToOrganization(organizationId: string, userId: string): Promise<void> {
+    await this.request(`${urls.organizations}/${organizationId}/users/${userId}`, 'POST');
+  }
+
+  public async removeUserFromOrganization(organizationId: string, userId: string): Promise<void> {
+    await this.request(`${urls.organizations}/${organizationId}/users/${userId}`, 'DELETE');
+  }
+}

package/src/sdk/modules/session.module.ts

@@ -0,0 +1,41 @@
+import { BaseClient } from './base-client';
+import { Session, CreateSessionDto, UpdateSessionDto } from '../types';
+import urls from '../urls';
+
+export class SessionModule extends BaseClient {
+  public async createSession(sessionData: CreateSessionDto): Promise<Session> {
+    return this.request<Session>(urls.sessions, 'POST', sessionData);
+  }
+
+  public async getSessions(): Promise<Session[]> {
+    return this.request<Session[]>(`${urls.sessions}/my-sessions`, 'GET');
+  }
+
+  public async getSession(id: string): Promise<Session> {
+    return this.request<Session>(`${urls.sessions}/${id}`, 'GET');
+  }
+
+  public async getSessionsByUser(userId: string): Promise<Session[]> {
+    return this.request<Session[]>(`${urls.sessions}/user/${userId}`, 'GET');
+  }
+
+  public async getSessionsByOrganization(): Promise<Session[]> {
+    return this.request<Session[]>(`${urls.sessions}/organization`, 'GET');
+  }
+
+  public async updateSession(id: string, sessionData: UpdateSessionDto): Promise<Session> {
+    return this.request<Session>(`${urls.sessions}/${id}`, 'PATCH', sessionData);
+  }
+
+  public async deleteSession(id: string): Promise<void> {
+    await this.request(`${urls.sessions}/${id}`, 'DELETE');
+  }
+
+  public async setPrimaryTranscriptionSummary(sessionId: string, summaryId: string): Promise<Session> {
+    return this.request<Session>(`${urls.sessions}/${sessionId}/primary-summary/${summaryId}`, 'PATCH');
+  }
+
+  public async rerunTranscription(sessionId: string): Promise<{ message: string; sessionId: string }> {
+    return this.request<{ message: string; sessionId: string }>(`${urls.sessions}/${sessionId}/rerun-transcription`, 'POST');
+  }
+}

package/src/sdk/modules/team.module.ts

@@ -0,0 +1,55 @@
+import { BaseClient } from './base-client';
+import { Team, CreateTeamDto, UpdateTeamDto, AssignTeamRoleDto } from '../types';
+import urls from '../urls';
+
+export class TeamModule extends BaseClient {
+  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 getTeams(): Promise<Team[]> {
+    return this.request<Team[]>(urls.teams, 'GET');
+  }
+
+  public async getTeam(id: string): Promise<Team> {
+    return this.request<Team>(`${urls.teams}/${id}`, 'GET');
+  }
+
+  public async getTeamsByOrganization(organizationId: string): Promise<Team[]> {
+    return this.request<Team[]>(`${urls.teams}/organization/${organizationId}`, 'GET');
+  }
+
+  public async deleteTeam(id: string): Promise<void> {
+    await this.request(`${urls.teams}/${id}`, 'DELETE');
+  }
+
+  public async removeUserFromTeamFixed(teamId: string, userId: string): Promise<void> {
+    await this.request(`${urls.teamRoles}/user/${userId}/team/${teamId}`, 'DELETE');
+  }
+}

package/src/sdk/modules/template.module.ts

@@ -0,0 +1,242 @@
+import { BaseClient } from './base-client';
+import {
+  Template,
+  TemplateCategory,
+  UserTemplate,
+  TranscriptionSummary,
+  CreateTemplateDto,
+  UpdateTemplateDto,
+  CreateUserTemplateDto,
+  UpdateUserTemplateDto,
+  CreateTemplateCategoryDto,
+  UpdateTemplateCategoryDto,
+  AssignTeamTemplateDto,
+  GenerateTranscriptionSummaryDto,
+  UpdateTranscriptionSummaryDto,
+  TranscriptionAudioUploadResponse,
+} from '../types';
+import urls from '../urls';
+
+export class TemplateModule extends BaseClient {
+  // ======================
+  // TEMPLATE METHODS
+  // ======================
+
+  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 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 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 getTemplate(id: string): Promise<Template> {
+    return this.request<Template>(`${urls.templates}/${id}`, 'GET');
+  }
+
+  public async deleteTemplate(id: string): Promise<void> {
+    await this.request(`${urls.templates}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // USER TEMPLATE METHODS
+  // ======================
+
+  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 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 getUserTemplates(): Promise<UserTemplate[]> {
+    const url = `${urls.userTemplates}/user/${this.user!.id}`;
+    return this.request<UserTemplate[]>(url, 'GET');
+  }
+
+  public async getUserTemplate(id: string): Promise<UserTemplate> {
+    return this.request<UserTemplate>(`${urls.userTemplates}/${id}`, 'GET');
+  }
+
+  public async deleteUserTemplate(id: string): Promise<void> {
+    await this.request(`${urls.userTemplates}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // TEMPLATE CATEGORY METHODS
+  // ======================
+
+  public async getTemplateCategories(): Promise<TemplateCategory[]> {
+    return this.request<TemplateCategory[]>(urls.templateCategories, 'GET');
+  }
+
+  public async getTemplateCategory(id: string): Promise<TemplateCategory> {
+    return this.request<TemplateCategory>(`${urls.templateCategories}/${id}`, 'GET');
+  }
+
+  public async createTemplateCategory(name: string): Promise<TemplateCategory> {
+    const dto: CreateTemplateCategoryDto = { name };
+    return this.request<TemplateCategory>(urls.templateCategories, 'POST', dto);
+  }
+
+  public async updateTemplateCategory(id: string, name: string): Promise<TemplateCategory> {
+    const dto: UpdateTemplateCategoryDto = { name };
+    return this.request<TemplateCategory>(`${urls.templateCategories}/${id}`, 'PATCH', dto);
+  }
+
+  public async deleteTemplateCategory(id: string): Promise<void> {
+    await this.request(`${urls.templateCategories}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // TEAM TEMPLATE METHODS
+  // ======================
+
+  public async assignTemplateToTeam(teamId: string, templateId: string): Promise<void> {
+    const dto: AssignTeamTemplateDto = { teamId, templateId };
+    await this.request(urls.teamTemplates, 'POST', dto);
+  }
+
+  public async removeTemplateFromTeam(teamId: string, templateId: string): Promise<void> {
+    await this.request(`${urls.teamTemplates}/team/${teamId}/template/${templateId}`, 'DELETE');
+  }
+
+  // ======================
+  // 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 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 getTranscriptionSummaries(): Promise<TranscriptionSummary[]> {
+    return this.request<TranscriptionSummary[]>(urls.transcriptionSummaries, 'GET');
+  }
+
+  public async getTranscriptionSummary(id: string): Promise<TranscriptionSummary> {
+    return this.request<TranscriptionSummary>(`${urls.transcriptionSummaries}/${id}`, 'GET');
+  }
+
+  public async getTranscriptionSummariesByUser(userId: string): Promise<TranscriptionSummary[]> {
+    return this.request<TranscriptionSummary[]>(`${urls.transcriptionSummaries}/user/${userId}`, 'GET');
+  }
+
+  public async getByOrganizationTranscriptionSummaries(organizationId: string): Promise<TranscriptionSummary[]> {
+    return this.request<TranscriptionSummary[]>(`${urls.transcriptionSummaries}/organization/${organizationId}`, 'GET');
+  }
+
+  public async deleteTranscriptionSummary(id: string): Promise<void> {
+    await this.request(`${urls.transcriptionSummaries}/${id}`, 'DELETE');
+  }
+
+  // ======================
+  // AUDIO UPLOAD METHODS (for transcription)
+  // ======================
+
+  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;
+  }
+}

package/src/sdk/modules/user.module.ts

@@ -0,0 +1,89 @@
+import { BaseClient } from './base-client';
+import { User, CreateUserDto, UpdateUserDto, Organization, AssignOrganizationRoleDto, OrganizationRoleType } from '../types';
+import urls from '../urls';
+
+export class UserModule extends BaseClient {
+  public async createUser(
+    firstName: string,
+    lastName: string,
+    email: string,
+    password: string
+  ): Promise<User> {
+    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 getUsers(): Promise<User[]> {
+    return this.request<User[]>(urls.users, 'GET');
+  }
+
+  public async getUser(id: string): Promise<User> {
+    return this.request<User>(`${urls.users}/${id}`, 'GET');
+  }
+
+  public async getUsersByOrganization(organizationId: string): Promise<User[]> {
+    return this.request<User[]>(`${urls.users}/organization/${organizationId}`, 'GET');
+  }
+
+  public async updateUser(id: string, data: UpdateUserDto): Promise<User> {
+    return this.request<User>(`${urls.users}/${id}`, 'PATCH', data);
+  }
+
+  public async deleteUser(id: string): Promise<void> {
+    await this.request(`${urls.users}/${id}`, 'DELETE');
+  }
+}