tuix-projects-service-client 0.0.1

package/apis/ClientApi.ts

@@ -0,0 +1,4331 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tuix Project Service
+ * Service to manage Tuix projects
+ *
+ * The version of the OpenAPI document: 0.0.1
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import * as runtime from '../runtime';
+import {
+    type AccountInfoDTO,
+    AccountInfoDTOFromJSON,
+    AccountInfoDTOToJSON,
+} from '../models/AccountInfoDTO';
+import {
+    type AdjustedTimesheetDTO,
+    AdjustedTimesheetDTOFromJSON,
+    AdjustedTimesheetDTOToJSON,
+} from '../models/AdjustedTimesheetDTO';
+import {
+    type AdjustedTimesheetEntryDTO,
+    AdjustedTimesheetEntryDTOFromJSON,
+    AdjustedTimesheetEntryDTOToJSON,
+} from '../models/AdjustedTimesheetEntryDTO';
+import {
+    type AdjustedTimesheetUpdateEntryDTO,
+    AdjustedTimesheetUpdateEntryDTOFromJSON,
+    AdjustedTimesheetUpdateEntryDTOToJSON,
+} from '../models/AdjustedTimesheetUpdateEntryDTO';
+import {
+    type ClientDTO,
+    ClientDTOFromJSON,
+    ClientDTOToJSON,
+} from '../models/ClientDTO';
+import {
+    type ClientGithubAccountDTO,
+    ClientGithubAccountDTOFromJSON,
+    ClientGithubAccountDTOToJSON,
+} from '../models/ClientGithubAccountDTO';
+import {
+    type ClientGithubCommitCountDTO,
+    ClientGithubCommitCountDTOFromJSON,
+    ClientGithubCommitCountDTOToJSON,
+} from '../models/ClientGithubCommitCountDTO';
+import {
+    type ClientGithubUserDTO,
+    ClientGithubUserDTOFromJSON,
+    ClientGithubUserDTOToJSON,
+} from '../models/ClientGithubUserDTO';
+import {
+    type ClientJiraAccountDTO,
+    ClientJiraAccountDTOFromJSON,
+    ClientJiraAccountDTOToJSON,
+} from '../models/ClientJiraAccountDTO';
+import {
+    type ClientJiraUserDTO,
+    ClientJiraUserDTOFromJSON,
+    ClientJiraUserDTOToJSON,
+} from '../models/ClientJiraUserDTO';
+import {
+    type CompanyDTO,
+    CompanyDTOFromJSON,
+    CompanyDTOToJSON,
+} from '../models/CompanyDTO';
+import {
+    type CreateEmployeeInvoiceInputDTO,
+    CreateEmployeeInvoiceInputDTOFromJSON,
+    CreateEmployeeInvoiceInputDTOToJSON,
+} from '../models/CreateEmployeeInvoiceInputDTO';
+import {
+    type CreateGithubUserRequestDTO,
+    CreateGithubUserRequestDTOFromJSON,
+    CreateGithubUserRequestDTOToJSON,
+} from '../models/CreateGithubUserRequestDTO';
+import {
+    type CreateJiraAccountDTO,
+    CreateJiraAccountDTOFromJSON,
+    CreateJiraAccountDTOToJSON,
+} from '../models/CreateJiraAccountDTO';
+import {
+    type CreateJiraUserRequestDTO,
+    CreateJiraUserRequestDTOFromJSON,
+    CreateJiraUserRequestDTOToJSON,
+} from '../models/CreateJiraUserRequestDTO';
+import {
+    type EmployeeDTO,
+    EmployeeDTOFromJSON,
+    EmployeeDTOToJSON,
+} from '../models/EmployeeDTO';
+import {
+    type EmployeeInvoiceDTO,
+    EmployeeInvoiceDTOFromJSON,
+    EmployeeInvoiceDTOToJSON,
+} from '../models/EmployeeInvoiceDTO';
+import {
+    type EmployeeUpdateDTO,
+    EmployeeUpdateDTOFromJSON,
+    EmployeeUpdateDTOToJSON,
+} from '../models/EmployeeUpdateDTO';
+import {
+    type ErrorDTO,
+    ErrorDTOFromJSON,
+    ErrorDTOToJSON,
+} from '../models/ErrorDTO';
+import {
+    type GlobalTimesheetDTO,
+    GlobalTimesheetDTOFromJSON,
+    GlobalTimesheetDTOToJSON,
+} from '../models/GlobalTimesheetDTO';
+import {
+    type GlobalTimesheetEntryDTO,
+    GlobalTimesheetEntryDTOFromJSON,
+    GlobalTimesheetEntryDTOToJSON,
+} from '../models/GlobalTimesheetEntryDTO';
+import {
+    type GlobalTimesheetEntryUpdateDTO,
+    GlobalTimesheetEntryUpdateDTOFromJSON,
+    GlobalTimesheetEntryUpdateDTOToJSON,
+} from '../models/GlobalTimesheetEntryUpdateDTO';
+import {
+    type HolidayCreateDTO,
+    HolidayCreateDTOFromJSON,
+    HolidayCreateDTOToJSON,
+} from '../models/HolidayCreateDTO';
+import {
+    type HolidayDTO,
+    HolidayDTOFromJSON,
+    HolidayDTOToJSON,
+} from '../models/HolidayDTO';
+import {
+    type MarkEmployeeInvoicePaidDTO,
+    MarkEmployeeInvoicePaidDTOFromJSON,
+    MarkEmployeeInvoicePaidDTOToJSON,
+} from '../models/MarkEmployeeInvoicePaidDTO';
+import {
+    type MarkInvoicePaidDTO,
+    MarkInvoicePaidDTOFromJSON,
+    MarkInvoicePaidDTOToJSON,
+} from '../models/MarkInvoicePaidDTO';
+import {
+    type PaginatedAdjustedTimesheets,
+    PaginatedAdjustedTimesheetsFromJSON,
+    PaginatedAdjustedTimesheetsToJSON,
+} from '../models/PaginatedAdjustedTimesheets';
+import {
+    type PaginatedClientInvoices,
+    PaginatedClientInvoicesFromJSON,
+    PaginatedClientInvoicesToJSON,
+} from '../models/PaginatedClientInvoices';
+import {
+    type PaginatedClients,
+    PaginatedClientsFromJSON,
+    PaginatedClientsToJSON,
+} from '../models/PaginatedClients';
+import {
+    type PaginatedEmployeeInvoices,
+    PaginatedEmployeeInvoicesFromJSON,
+    PaginatedEmployeeInvoicesToJSON,
+} from '../models/PaginatedEmployeeInvoices';
+import {
+    type PaginatedEmployeeProjects,
+    PaginatedEmployeeProjectsFromJSON,
+    PaginatedEmployeeProjectsToJSON,
+} from '../models/PaginatedEmployeeProjects';
+import {
+    type PaginatedEmployees,
+    PaginatedEmployeesFromJSON,
+    PaginatedEmployeesToJSON,
+} from '../models/PaginatedEmployees';
+import {
+    type PaginatedGlobalTimesheets,
+    PaginatedGlobalTimesheetsFromJSON,
+    PaginatedGlobalTimesheetsToJSON,
+} from '../models/PaginatedGlobalTimesheets';
+import {
+    type PaginatedHolidaysDTO,
+    PaginatedHolidaysDTOFromJSON,
+    PaginatedHolidaysDTOToJSON,
+} from '../models/PaginatedHolidaysDTO';
+import {
+    type PaginatedProjects,
+    PaginatedProjectsFromJSON,
+    PaginatedProjectsToJSON,
+} from '../models/PaginatedProjects';
+import {
+    type PaginatedTimesheets,
+    PaginatedTimesheetsFromJSON,
+    PaginatedTimesheetsToJSON,
+} from '../models/PaginatedTimesheets';
+import {
+    type PaginatedUsers,
+    PaginatedUsersFromJSON,
+    PaginatedUsersToJSON,
+} from '../models/PaginatedUsers';
+import {
+    type ProjectDTO,
+    ProjectDTOFromJSON,
+    ProjectDTOToJSON,
+} from '../models/ProjectDTO';
+import {
+    type ProjectInputDTO,
+    ProjectInputDTOFromJSON,
+    ProjectInputDTOToJSON,
+} from '../models/ProjectInputDTO';
+import {
+    type ProjectUpdateDTO,
+    ProjectUpdateDTOFromJSON,
+    ProjectUpdateDTOToJSON,
+} from '../models/ProjectUpdateDTO';
+import {
+    type TeamUpdateDTO,
+    TeamUpdateDTOFromJSON,
+    TeamUpdateDTOToJSON,
+} from '../models/TeamUpdateDTO';
+import {
+    type TimesheetDTO,
+    TimesheetDTOFromJSON,
+    TimesheetDTOToJSON,
+} from '../models/TimesheetDTO';
+import {
+    type TimesheetEntryUpdateDTO,
+    TimesheetEntryUpdateDTOFromJSON,
+    TimesheetEntryUpdateDTOToJSON,
+} from '../models/TimesheetEntryUpdateDTO';
+import {
+    type UserProjectReport,
+    UserProjectReportFromJSON,
+    UserProjectReportToJSON,
+} from '../models/UserProjectReport';
+
+export interface AddJiraAccountRequest {
+    createJiraAccountDTO: CreateJiraAccountDTO;
+}
+
+export interface ApproveAdjustedTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface ApproveGlobalTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface ApproveTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface CreateClientRequest {
+    clientDTO: ClientDTO;
+}
+
+export interface CreateCompanyRequest {
+    companyDTO: CompanyDTO;
+}
+
+export interface CreateEmployeeInvoiceRequest {
+    userId: string;
+    createEmployeeInvoiceInputDTO: CreateEmployeeInvoiceInputDTO;
+}
+
+export interface CreateGithubUserRequest {
+    createGithubUserRequestDTO: CreateGithubUserRequestDTO;
+}
+
+export interface CreateHolidayRequest {
+    holidayCreateDTO: HolidayCreateDTO;
+}
+
+export interface CreateJiraUserRequest {
+    createJiraUserRequestDTO: CreateJiraUserRequestDTO;
+}
+
+export interface CreateProjectRequest {
+    projectInputDTO: ProjectInputDTO;
+}
+
+export interface DeleteClientRequest {
+    clientId: string;
+}
+
+export interface DeleteCompanyRequest {
+    companyId: string;
+}
+
+export interface DeleteEmployeeRequest {
+    userId: string;
+}
+
+export interface DeleteEmployeeInvoiceRequest {
+    userId: string;
+    employeeInvoiceId: string;
+}
+
+export interface DeleteHolidayRequest {
+    holidayId: string;
+}
+
+export interface DeleteProjectRequest {
+    projectId: string;
+}
+
+export interface DownloadAdjustedTimesheetPdfRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface DownloadClientInvoicePdfRequest {
+    invoiceId: string;
+    clientId: string;
+}
+
+export interface DownloadEmployeeInvoicePdfRequest {
+    userId: string;
+    employeeInvoiceId: string;
+}
+
+export interface DownloadGlobalTimesheetPdfRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface DownloadTimesheetPdfRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface GetAdjustedTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface GetAdjustedTimesheetsRequest {
+    projectId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetClientByIdRequest {
+    clientId: string;
+}
+
+export interface GetClientInvoicesRequest {
+    clientId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetClientsRequest {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetCommitsByUserIDRequest {
+    userId: string;
+    from: Date;
+    to: Date;
+    groupBy?: GetCommitsByUserIDGroupByEnum;
+}
+
+export interface GetCompaniesRequest {
+    search?: string;
+}
+
+export interface GetCompanyRequest {
+    companyId: string;
+}
+
+export interface GetEmployeeRequest {
+    userId: string;
+}
+
+export interface GetEmployeeInvoicesRequest {
+    userId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetEmployeeTimesheetsRequest {
+    projectId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetEmployeesRequest {
+    page?: number;
+    pageSize?: number;
+    activated?: boolean;
+    search?: string;
+}
+
+export interface GetGlobalTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface GetGlobalTimesheetsRequest {
+    projectId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetHolidaysRequest {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetHolidaysByEmployeeRequest {
+    userId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetMyCommitsRequest {
+    from: Date;
+    to: Date;
+    groupBy?: GetMyCommitsGroupByEnum;
+}
+
+export interface GetProjectByIdRequest {
+    projectId: string;
+}
+
+export interface GetProjectReportByUserRequest {
+    userId: string;
+    startDate: Date;
+    endDate: Date;
+}
+
+export interface GetProjectsRequest {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetProjectsAsEmployeeRequest {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetTeamRequest {
+    projectId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface GetTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface GetTimesheetsRequest {
+    projectId: string;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}
+
+export interface InviteEmployeeRequest {
+    employeeDTO: EmployeeDTO;
+}
+
+export interface MarkEmployeeInvoiceAsPaidRequest {
+    userId: string;
+    employeeInvoiceId: string;
+    markEmployeeInvoicePaidDTO: MarkEmployeeInvoicePaidDTO;
+}
+
+export interface MarkInvoiceAsPaidRequest {
+    clientId: string;
+    invoiceId: string;
+    markInvoicePaidDTO: MarkInvoicePaidDTO;
+}
+
+export interface OpenSentTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface RemoveJiraAccountRequest {
+    jiraAccountId: string;
+}
+
+export interface SendTimesheetRequest {
+    projectId: string;
+    timesheetId: string;
+}
+
+export interface UpdateAdjustedEntryRequest {
+    projectId: string;
+    timesheetId: string;
+    entryId: string;
+    adjustedTimesheetUpdateEntryDTO: AdjustedTimesheetUpdateEntryDTO;
+}
+
+export interface UpdateClientRequest {
+    clientId: string;
+    clientDTO: ClientDTO;
+}
+
+export interface UpdateCompanyRequest {
+    companyId: string;
+    companyDTO: CompanyDTO;
+}
+
+export interface UpdateEmployeeDataRequest {
+    userId: string;
+    employeeUpdateDTO: EmployeeUpdateDTO;
+}
+
+export interface UpdateGlobalTimesheetEntryRequest {
+    projectId: string;
+    timesheetId: string;
+    entryId: string;
+    globalTimesheetEntryUpdateDTO: GlobalTimesheetEntryUpdateDTO;
+}
+
+export interface UpdateProjectRequest {
+    projectId: string;
+    projectUpdateDTO: ProjectUpdateDTO;
+}
+
+export interface UpdateTeamRequest {
+    projectId: string;
+    teamUpdateDTO: TeamUpdateDTO;
+}
+
+export interface UpdateTimesheetEntryRequest {
+    projectId: string;
+    timesheetId: string;
+    entryId: string;
+    timesheetEntryUpdateDTO: TimesheetEntryUpdateDTO;
+}
+
+/**
+ * 
+ */
+export class ClientApi extends runtime.BaseAPI {
+
+    /**
+     * Creates request options for addJiraAccount without sending the request
+     */
+    async addJiraAccountRequestOpts(requestParameters: AddJiraAccountRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['createJiraAccountDTO'] == null) {
+            throw new runtime.RequiredError(
+                'createJiraAccountDTO',
+                'Required parameter "createJiraAccountDTO" was null or undefined when calling addJiraAccount().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/jira-users/jira-accounts`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateJiraAccountDTOToJSON(requestParameters['createJiraAccountDTO']),
+        };
+    }
+
+    /**
+     * Add a new Jira account for the authenticated user
+     * Add Jira account
+     */
+    async addJiraAccountRaw(requestParameters: AddJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<object>> {
+        const requestOptions = await this.addJiraAccountRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Add a new Jira account for the authenticated user
+     * Add Jira account
+     */
+    async addJiraAccount(requestParameters: AddJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<object> {
+        const response = await this.addJiraAccountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for approveAdjustedTimesheet without sending the request
+     */
+    async approveAdjustedTimesheetRequestOpts(requestParameters: ApproveAdjustedTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling approveAdjustedTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling approveAdjustedTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/adjusted-timesheets/{timesheetId}/approve`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Approve an adjustedTimesheet in a project
+     * Approve an adjustedTimesheet in a project
+     */
+    async approveAdjustedTimesheetRaw(requestParameters: ApproveAdjustedTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.approveAdjustedTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Approve an adjustedTimesheet in a project
+     * Approve an adjustedTimesheet in a project
+     */
+    async approveAdjustedTimesheet(requestParameters: ApproveAdjustedTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.approveAdjustedTimesheetRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for approveGlobalTimesheet without sending the request
+     */
+    async approveGlobalTimesheetRequestOpts(requestParameters: ApproveGlobalTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling approveGlobalTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling approveGlobalTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/global-timesheets/{timesheetId}/approve`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Approve a global timesheet
+     * Approve a global timesheet
+     */
+    async approveGlobalTimesheetRaw(requestParameters: ApproveGlobalTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.approveGlobalTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Approve a global timesheet
+     * Approve a global timesheet
+     */
+    async approveGlobalTimesheet(requestParameters: ApproveGlobalTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.approveGlobalTimesheetRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for approveTimesheet without sending the request
+     */
+    async approveTimesheetRequestOpts(requestParameters: ApproveTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling approveTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling approveTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/timesheets/{timesheetId}/approve`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Approve a timesheet
+     * Approve a timesheet
+     */
+    async approveTimesheetRaw(requestParameters: ApproveTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.approveTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Approve a timesheet
+     * Approve a timesheet
+     */
+    async approveTimesheet(requestParameters: ApproveTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.approveTimesheetRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for createClient without sending the request
+     */
+    async createClientRequestOpts(requestParameters: CreateClientRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['clientDTO'] == null) {
+            throw new runtime.RequiredError(
+                'clientDTO',
+                'Required parameter "clientDTO" was null or undefined when calling createClient().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientDTOToJSON(requestParameters['clientDTO']),
+        };
+    }
+
+    /**
+     * Create client
+     */
+    async createClientRaw(requestParameters: CreateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
+        const requestOptions = await this.createClientRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Create client
+     */
+    async createClient(requestParameters: CreateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.createClientRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for createCompany without sending the request
+     */
+    async createCompanyRequestOpts(requestParameters: CreateCompanyRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['companyDTO'] == null) {
+            throw new runtime.RequiredError(
+                'companyDTO',
+                'Required parameter "companyDTO" was null or undefined when calling createCompany().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/companies`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CompanyDTOToJSON(requestParameters['companyDTO']),
+        };
+    }
+
+    /**
+     * Create a company
+     * Creates a new company
+     */
+    async createCompanyRaw(requestParameters: CreateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
+        const requestOptions = await this.createCompanyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a company
+     * Creates a new company
+     */
+    async createCompany(requestParameters: CreateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
+        const response = await this.createCompanyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for createEmployeeInvoice without sending the request
+     */
+    async createEmployeeInvoiceRequestOpts(requestParameters: CreateEmployeeInvoiceRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling createEmployeeInvoice().'
+            );
+        }
+
+        if (requestParameters['createEmployeeInvoiceInputDTO'] == null) {
+            throw new runtime.RequiredError(
+                'createEmployeeInvoiceInputDTO',
+                'Required parameter "createEmployeeInvoiceInputDTO" was null or undefined when calling createEmployeeInvoice().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}/invoices`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateEmployeeInvoiceInputDTOToJSON(requestParameters['createEmployeeInvoiceInputDTO']),
+        };
+    }
+
+    /**
+     * Create an employee invoice
+     * Create an employee invoice
+     */
+    async createEmployeeInvoiceRaw(requestParameters: CreateEmployeeInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeInvoiceDTO>> {
+        const requestOptions = await this.createEmployeeInvoiceRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EmployeeInvoiceDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Create an employee invoice
+     * Create an employee invoice
+     */
+    async createEmployeeInvoice(requestParameters: CreateEmployeeInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmployeeInvoiceDTO> {
+        const response = await this.createEmployeeInvoiceRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for createGithubUser without sending the request
+     */
+    async createGithubUserRequestOpts(requestParameters: CreateGithubUserRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['createGithubUserRequestDTO'] == null) {
+            throw new runtime.RequiredError(
+                'createGithubUserRequestDTO',
+                'Required parameter "createGithubUserRequestDTO" was null or undefined when calling createGithubUser().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/github-users`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateGithubUserRequestDTOToJSON(requestParameters['createGithubUserRequestDTO']),
+        };
+    }
+
+    /**
+     * Create a new GitHub user account
+     * Create GitHub user
+     */
+    async createGithubUserRaw(requestParameters: CreateGithubUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientGithubUserDTO>> {
+        const requestOptions = await this.createGithubUserRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientGithubUserDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a new GitHub user account
+     * Create GitHub user
+     */
+    async createGithubUser(requestParameters: CreateGithubUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientGithubUserDTO> {
+        const response = await this.createGithubUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for createHoliday without sending the request
+     */
+    async createHolidayRequestOpts(requestParameters: CreateHolidayRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['holidayCreateDTO'] == null) {
+            throw new runtime.RequiredError(
+                'holidayCreateDTO',
+                'Required parameter "holidayCreateDTO" was null or undefined when calling createHoliday().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/holidays`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: HolidayCreateDTOToJSON(requestParameters['holidayCreateDTO']),
+        };
+    }
+
+    /**
+     * Allows a user to add a holiday
+     */
+    async createHolidayRaw(requestParameters: CreateHolidayRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<HolidayDTO>> {
+        const requestOptions = await this.createHolidayRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => HolidayDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Allows a user to add a holiday
+     */
+    async createHoliday(requestParameters: CreateHolidayRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<HolidayDTO> {
+        const response = await this.createHolidayRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for createJiraUser without sending the request
+     */
+    async createJiraUserRequestOpts(requestParameters: CreateJiraUserRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['createJiraUserRequestDTO'] == null) {
+            throw new runtime.RequiredError(
+                'createJiraUserRequestDTO',
+                'Required parameter "createJiraUserRequestDTO" was null or undefined when calling createJiraUser().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/jira-users`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateJiraUserRequestDTOToJSON(requestParameters['createJiraUserRequestDTO']),
+        };
+    }
+
+    /**
+     * Create a new Jira user
+     * Create Jira user
+     */
+    async createJiraUserRaw(requestParameters: CreateJiraUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientJiraUserDTO>> {
+        const requestOptions = await this.createJiraUserRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientJiraUserDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a new Jira user
+     * Create Jira user
+     */
+    async createJiraUser(requestParameters: CreateJiraUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientJiraUserDTO> {
+        const response = await this.createJiraUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for createProject without sending the request
+     */
+    async createProjectRequestOpts(requestParameters: CreateProjectRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectInputDTO'] == null) {
+            throw new runtime.RequiredError(
+                'projectInputDTO',
+                'Required parameter "projectInputDTO" was null or undefined when calling createProject().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ProjectInputDTOToJSON(requestParameters['projectInputDTO']),
+        };
+    }
+
+    /**
+     * Create a project
+     * Creates a new project
+     */
+    async createProjectRaw(requestParameters: CreateProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectDTO>> {
+        const requestOptions = await this.createProjectRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a project
+     * Creates a new project
+     */
+    async createProject(requestParameters: CreateProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectDTO> {
+        const response = await this.createProjectRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for deleteClient without sending the request
+     */
+    async deleteClientRequestOpts(requestParameters: DeleteClientRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['clientId'] == null) {
+            throw new runtime.RequiredError(
+                'clientId',
+                'Required parameter "clientId" was null or undefined when calling deleteClient().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients/{clientId}`;
+        urlPath = urlPath.replace('{clientId}', encodeURIComponent(String(requestParameters['clientId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete client
+     * Delete client
+     */
+    async deleteClientRaw(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteClientRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete client
+     * Delete client
+     */
+    async deleteClient(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteClientRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for deleteCompany without sending the request
+     */
+    async deleteCompanyRequestOpts(requestParameters: DeleteCompanyRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['companyId'] == null) {
+            throw new runtime.RequiredError(
+                'companyId',
+                'Required parameter "companyId" was null or undefined when calling deleteCompany().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/companies/{companyId}`;
+        urlPath = urlPath.replace('{companyId}', encodeURIComponent(String(requestParameters['companyId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete a company
+     * Delete a company
+     */
+    async deleteCompanyRaw(requestParameters: DeleteCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteCompanyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete a company
+     * Delete a company
+     */
+    async deleteCompany(requestParameters: DeleteCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteCompanyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for deleteEmployee without sending the request
+     */
+    async deleteEmployeeRequestOpts(requestParameters: DeleteEmployeeRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling deleteEmployee().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete an employee
+     * Delete an employee
+     */
+    async deleteEmployeeRaw(requestParameters: DeleteEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteEmployeeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete an employee
+     * Delete an employee
+     */
+    async deleteEmployee(requestParameters: DeleteEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteEmployeeRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for deleteEmployeeInvoice without sending the request
+     */
+    async deleteEmployeeInvoiceRequestOpts(requestParameters: DeleteEmployeeInvoiceRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling deleteEmployeeInvoice().'
+            );
+        }
+
+        if (requestParameters['employeeInvoiceId'] == null) {
+            throw new runtime.RequiredError(
+                'employeeInvoiceId',
+                'Required parameter "employeeInvoiceId" was null or undefined when calling deleteEmployeeInvoice().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}/invoices/{employeeInvoiceId}`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+        urlPath = urlPath.replace('{employeeInvoiceId}', encodeURIComponent(String(requestParameters['employeeInvoiceId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete an employee invoice
+     * Delete an employee invoice
+     */
+    async deleteEmployeeInvoiceRaw(requestParameters: DeleteEmployeeInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteEmployeeInvoiceRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete an employee invoice
+     * Delete an employee invoice
+     */
+    async deleteEmployeeInvoice(requestParameters: DeleteEmployeeInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteEmployeeInvoiceRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for deleteGithubUser without sending the request
+     */
+    async deleteGithubUserRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/github-users`;
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete the authenticated user\'s GitHub account
+     * Delete GitHub user
+     */
+    async deleteGithubUserRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteGithubUserRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete the authenticated user\'s GitHub account
+     * Delete GitHub user
+     */
+    async deleteGithubUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteGithubUserRaw(initOverrides);
+    }
+
+    /**
+     * Creates request options for deleteHoliday without sending the request
+     */
+    async deleteHolidayRequestOpts(requestParameters: DeleteHolidayRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['holidayId'] == null) {
+            throw new runtime.RequiredError(
+                'holidayId',
+                'Required parameter "holidayId" was null or undefined when calling deleteHoliday().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/holidays/{holidayId}`;
+        urlPath = urlPath.replace('{holidayId}', encodeURIComponent(String(requestParameters['holidayId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete a holiday
+     * Delete a holiday
+     */
+    async deleteHolidayRaw(requestParameters: DeleteHolidayRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteHolidayRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete a holiday
+     * Delete a holiday
+     */
+    async deleteHoliday(requestParameters: DeleteHolidayRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteHolidayRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for deleteProject without sending the request
+     */
+    async deleteProjectRequestOpts(requestParameters: DeleteProjectRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling deleteProject().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Delete a project
+     * Delete a project
+     */
+    async deleteProjectRaw(requestParameters: DeleteProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteProjectRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Delete a project
+     * Delete a project
+     */
+    async deleteProject(requestParameters: DeleteProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteProjectRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for downloadAdjustedTimesheetPdf without sending the request
+     */
+    async downloadAdjustedTimesheetPdfRequestOpts(requestParameters: DownloadAdjustedTimesheetPdfRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling downloadAdjustedTimesheetPdf().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling downloadAdjustedTimesheetPdf().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/adjusted-timesheets/{timesheetId}/download`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Download an AdjustedTimesheet report in PDF format
+     * Download an AdjustedTimesheet report in PDF format
+     */
+    async downloadAdjustedTimesheetPdfRaw(requestParameters: DownloadAdjustedTimesheetPdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        const requestOptions = await this.downloadAdjustedTimesheetPdfRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
+    }
+
+    /**
+     * Download an AdjustedTimesheet report in PDF format
+     * Download an AdjustedTimesheet report in PDF format
+     */
+    async downloadAdjustedTimesheetPdf(requestParameters: DownloadAdjustedTimesheetPdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.downloadAdjustedTimesheetPdfRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for downloadClientInvoicePdf without sending the request
+     */
+    async downloadClientInvoicePdfRequestOpts(requestParameters: DownloadClientInvoicePdfRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['invoiceId'] == null) {
+            throw new runtime.RequiredError(
+                'invoiceId',
+                'Required parameter "invoiceId" was null or undefined when calling downloadClientInvoicePdf().'
+            );
+        }
+
+        if (requestParameters['clientId'] == null) {
+            throw new runtime.RequiredError(
+                'clientId',
+                'Required parameter "clientId" was null or undefined when calling downloadClientInvoicePdf().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients/{clientId}/invoices/{invoiceId}/download`;
+        urlPath = urlPath.replace('{invoiceId}', encodeURIComponent(String(requestParameters['invoiceId'])));
+        urlPath = urlPath.replace('{clientId}', encodeURIComponent(String(requestParameters['clientId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Download client invoice pdf
+     * Download client invoice pdf
+     */
+    async downloadClientInvoicePdfRaw(requestParameters: DownloadClientInvoicePdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        const requestOptions = await this.downloadClientInvoicePdfRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
+    }
+
+    /**
+     * Download client invoice pdf
+     * Download client invoice pdf
+     */
+    async downloadClientInvoicePdf(requestParameters: DownloadClientInvoicePdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.downloadClientInvoicePdfRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for downloadEmployeeInvoicePdf without sending the request
+     */
+    async downloadEmployeeInvoicePdfRequestOpts(requestParameters: DownloadEmployeeInvoicePdfRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling downloadEmployeeInvoicePdf().'
+            );
+        }
+
+        if (requestParameters['employeeInvoiceId'] == null) {
+            throw new runtime.RequiredError(
+                'employeeInvoiceId',
+                'Required parameter "employeeInvoiceId" was null or undefined when calling downloadEmployeeInvoicePdf().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}/invoices/{employeeInvoiceId}/download`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+        urlPath = urlPath.replace('{employeeInvoiceId}', encodeURIComponent(String(requestParameters['employeeInvoiceId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Download the employee invoice report in PDF format
+     * Download the employee invoice report in PDF format
+     */
+    async downloadEmployeeInvoicePdfRaw(requestParameters: DownloadEmployeeInvoicePdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        const requestOptions = await this.downloadEmployeeInvoicePdfRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
+    }
+
+    /**
+     * Download the employee invoice report in PDF format
+     * Download the employee invoice report in PDF format
+     */
+    async downloadEmployeeInvoicePdf(requestParameters: DownloadEmployeeInvoicePdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.downloadEmployeeInvoicePdfRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for downloadGlobalTimesheetPdf without sending the request
+     */
+    async downloadGlobalTimesheetPdfRequestOpts(requestParameters: DownloadGlobalTimesheetPdfRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling downloadGlobalTimesheetPdf().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling downloadGlobalTimesheetPdf().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/global-timesheets/{timesheetId}/download`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Download a global timesheet report in PDF format
+     * Download a global timesheet report in PDF format
+     */
+    async downloadGlobalTimesheetPdfRaw(requestParameters: DownloadGlobalTimesheetPdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        const requestOptions = await this.downloadGlobalTimesheetPdfRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
+    }
+
+    /**
+     * Download a global timesheet report in PDF format
+     * Download a global timesheet report in PDF format
+     */
+    async downloadGlobalTimesheetPdf(requestParameters: DownloadGlobalTimesheetPdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.downloadGlobalTimesheetPdfRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for downloadTimesheetPdf without sending the request
+     */
+    async downloadTimesheetPdfRequestOpts(requestParameters: DownloadTimesheetPdfRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling downloadTimesheetPdf().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling downloadTimesheetPdf().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/timesheets/{timesheetId}/download`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Download a timesheet report in PDF format
+     * Download a timesheet report in PDF format
+     */
+    async downloadTimesheetPdfRaw(requestParameters: DownloadTimesheetPdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        const requestOptions = await this.downloadTimesheetPdfRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
+    }
+
+    /**
+     * Download a timesheet report in PDF format
+     * Download a timesheet report in PDF format
+     */
+    async downloadTimesheetPdf(requestParameters: DownloadTimesheetPdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.downloadTimesheetPdfRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getAdjustedTimesheet without sending the request
+     */
+    async getAdjustedTimesheetRequestOpts(requestParameters: GetAdjustedTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getAdjustedTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling getAdjustedTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/adjusted-timesheets/{timesheetId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get an adjustedTimesheet
+     * Get an adjustedTimesheet
+     */
+    async getAdjustedTimesheetRaw(requestParameters: GetAdjustedTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AdjustedTimesheetDTO>> {
+        const requestOptions = await this.getAdjustedTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => AdjustedTimesheetDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get an adjustedTimesheet
+     * Get an adjustedTimesheet
+     */
+    async getAdjustedTimesheet(requestParameters: GetAdjustedTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AdjustedTimesheetDTO> {
+        const response = await this.getAdjustedTimesheetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getAdjustedTimesheets without sending the request
+     */
+    async getAdjustedTimesheetsRequestOpts(requestParameters: GetAdjustedTimesheetsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getAdjustedTimesheets().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/adjusted-timesheets`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all adjustedTimesheets in a project
+     * Get all adjustedTimesheets in a project
+     */
+    async getAdjustedTimesheetsRaw(requestParameters: GetAdjustedTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedAdjustedTimesheets>> {
+        const requestOptions = await this.getAdjustedTimesheetsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedAdjustedTimesheetsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all adjustedTimesheets in a project
+     * Get all adjustedTimesheets in a project
+     */
+    async getAdjustedTimesheets(requestParameters: GetAdjustedTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedAdjustedTimesheets> {
+        const response = await this.getAdjustedTimesheetsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getClientById without sending the request
+     */
+    async getClientByIdRequestOpts(requestParameters: GetClientByIdRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['clientId'] == null) {
+            throw new runtime.RequiredError(
+                'clientId',
+                'Required parameter "clientId" was null or undefined when calling getClientById().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients/{clientId}`;
+        urlPath = urlPath.replace('{clientId}', encodeURIComponent(String(requestParameters['clientId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get client by id
+     */
+    async getClientByIdRaw(requestParameters: GetClientByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
+        const requestOptions = await this.getClientByIdRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get client by id
+     */
+    async getClientById(requestParameters: GetClientByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.getClientByIdRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getClientInvoices without sending the request
+     */
+    async getClientInvoicesRequestOpts(requestParameters: GetClientInvoicesRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['clientId'] == null) {
+            throw new runtime.RequiredError(
+                'clientId',
+                'Required parameter "clientId" was null or undefined when calling getClientInvoices().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients/{clientId}/invoices`;
+        urlPath = urlPath.replace('{clientId}', encodeURIComponent(String(requestParameters['clientId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all invoices from client
+     * Get all invoices from client
+     */
+    async getClientInvoicesRaw(requestParameters: GetClientInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedClientInvoices>> {
+        const requestOptions = await this.getClientInvoicesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedClientInvoicesFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all invoices from client
+     * Get all invoices from client
+     */
+    async getClientInvoices(requestParameters: GetClientInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedClientInvoices> {
+        const response = await this.getClientInvoicesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getClients without sending the request
+     */
+    async getClientsRequestOpts(requestParameters: GetClientsRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all clients from company
+     * Get all clients from company
+     */
+    async getClientsRaw(requestParameters: GetClientsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedClients>> {
+        const requestOptions = await this.getClientsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedClientsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all clients from company
+     * Get all clients from company
+     */
+    async getClients(requestParameters: GetClientsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedClients> {
+        const response = await this.getClientsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getCommitsByUserID without sending the request
+     */
+    async getCommitsByUserIDRequestOpts(requestParameters: GetCommitsByUserIDRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling getCommitsByUserID().'
+            );
+        }
+
+        if (requestParameters['from'] == null) {
+            throw new runtime.RequiredError(
+                'from',
+                'Required parameter "from" was null or undefined when calling getCommitsByUserID().'
+            );
+        }
+
+        if (requestParameters['to'] == null) {
+            throw new runtime.RequiredError(
+                'to',
+                'Required parameter "to" was null or undefined when calling getCommitsByUserID().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['from'] != null) {
+            queryParameters['from'] = (requestParameters['from'] as any).toISOString().substring(0,10);
+        }
+
+        if (requestParameters['to'] != null) {
+            queryParameters['to'] = (requestParameters['to'] as any).toISOString().substring(0,10);
+        }
+
+        if (requestParameters['groupBy'] != null) {
+            queryParameters['groupBy'] = requestParameters['groupBy'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}/commits`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get commit statistics for a specific user
+     * Get commits by user ID
+     */
+    async getCommitsByUserIDRaw(requestParameters: GetCommitsByUserIDRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientGithubCommitCountDTO>>> {
+        const requestOptions = await this.getCommitsByUserIDRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientGithubCommitCountDTOFromJSON));
+    }
+
+    /**
+     * Get commit statistics for a specific user
+     * Get commits by user ID
+     */
+    async getCommitsByUserID(requestParameters: GetCommitsByUserIDRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientGithubCommitCountDTO>> {
+        const response = await this.getCommitsByUserIDRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getCompanies without sending the request
+     */
+    async getCompaniesRequestOpts(requestParameters: GetCompaniesRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/companies`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all companies a user belongs to
+     * Get all companies a user belongs to
+     */
+    async getCompaniesRaw(requestParameters: GetCompaniesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CompanyDTO>>> {
+        const requestOptions = await this.getCompaniesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CompanyDTOFromJSON));
+    }
+
+    /**
+     * Get all companies a user belongs to
+     * Get all companies a user belongs to
+     */
+    async getCompanies(requestParameters: GetCompaniesRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CompanyDTO>> {
+        const response = await this.getCompaniesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getCompany without sending the request
+     */
+    async getCompanyRequestOpts(requestParameters: GetCompanyRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['companyId'] == null) {
+            throw new runtime.RequiredError(
+                'companyId',
+                'Required parameter "companyId" was null or undefined when calling getCompany().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/companies/{companyId}`;
+        urlPath = urlPath.replace('{companyId}', encodeURIComponent(String(requestParameters['companyId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get a company
+     * Get a company by ID
+     */
+    async getCompanyRaw(requestParameters: GetCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
+        const requestOptions = await this.getCompanyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get a company
+     * Get a company by ID
+     */
+    async getCompany(requestParameters: GetCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
+        const response = await this.getCompanyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getEmployee without sending the request
+     */
+    async getEmployeeRequestOpts(requestParameters: GetEmployeeRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling getEmployee().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get employee info
+     * Get employee info
+     */
+    async getEmployeeRaw(requestParameters: GetEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeDTO>> {
+        const requestOptions = await this.getEmployeeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EmployeeDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get employee info
+     * Get employee info
+     */
+    async getEmployee(requestParameters: GetEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmployeeDTO> {
+        const response = await this.getEmployeeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getEmployeeInvoices without sending the request
+     */
+    async getEmployeeInvoicesRequestOpts(requestParameters: GetEmployeeInvoicesRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling getEmployeeInvoices().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}/invoices`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all employee invoices
+     * Get all employee invoices
+     */
+    async getEmployeeInvoicesRaw(requestParameters: GetEmployeeInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEmployeeInvoices>> {
+        const requestOptions = await this.getEmployeeInvoicesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedEmployeeInvoicesFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all employee invoices
+     * Get all employee invoices
+     */
+    async getEmployeeInvoices(requestParameters: GetEmployeeInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedEmployeeInvoices> {
+        const response = await this.getEmployeeInvoicesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getEmployeeTimesheets without sending the request
+     */
+    async getEmployeeTimesheetsRequestOpts(requestParameters: GetEmployeeTimesheetsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getEmployeeTimesheets().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/employee-timesheets`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all timesheets of an employee in a project
+     * Get all timesheets of an employee in a project
+     */
+    async getEmployeeTimesheetsRaw(requestParameters: GetEmployeeTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedTimesheets>> {
+        const requestOptions = await this.getEmployeeTimesheetsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedTimesheetsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all timesheets of an employee in a project
+     * Get all timesheets of an employee in a project
+     */
+    async getEmployeeTimesheets(requestParameters: GetEmployeeTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedTimesheets> {
+        const response = await this.getEmployeeTimesheetsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getEmployees without sending the request
+     */
+    async getEmployeesRequestOpts(requestParameters: GetEmployeesRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['activated'] != null) {
+            queryParameters['activated'] = requestParameters['activated'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * List employees
+     * List employees
+     */
+    async getEmployeesRaw(requestParameters: GetEmployeesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEmployees>> {
+        const requestOptions = await this.getEmployeesRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedEmployeesFromJSON(jsonValue));
+    }
+
+    /**
+     * List employees
+     * List employees
+     */
+    async getEmployees(requestParameters: GetEmployeesRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedEmployees> {
+        const response = await this.getEmployeesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getGithubAccount without sending the request
+     */
+    async getGithubAccountRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/github-accounts`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get GitHub account for the authenticated user
+     * Get GitHub account
+     */
+    async getGithubAccountRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientGithubAccountDTO>> {
+        const requestOptions = await this.getGithubAccountRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientGithubAccountDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get GitHub account for the authenticated user
+     * Get GitHub account
+     */
+    async getGithubAccount(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientGithubAccountDTO> {
+        const response = await this.getGithubAccountRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getGlobalTimesheet without sending the request
+     */
+    async getGlobalTimesheetRequestOpts(requestParameters: GetGlobalTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getGlobalTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling getGlobalTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/global-timesheets/{timesheetId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get a global timesheet
+     * Get a global timesheet
+     */
+    async getGlobalTimesheetRaw(requestParameters: GetGlobalTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GlobalTimesheetDTO>> {
+        const requestOptions = await this.getGlobalTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GlobalTimesheetDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get a global timesheet
+     * Get a global timesheet
+     */
+    async getGlobalTimesheet(requestParameters: GetGlobalTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GlobalTimesheetDTO> {
+        const response = await this.getGlobalTimesheetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getGlobalTimesheets without sending the request
+     */
+    async getGlobalTimesheetsRequestOpts(requestParameters: GetGlobalTimesheetsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getGlobalTimesheets().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/global-timesheets`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all global timesheets in a project
+     * Get all global timesheets in a project
+     */
+    async getGlobalTimesheetsRaw(requestParameters: GetGlobalTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedGlobalTimesheets>> {
+        const requestOptions = await this.getGlobalTimesheetsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedGlobalTimesheetsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all global timesheets in a project
+     * Get all global timesheets in a project
+     */
+    async getGlobalTimesheets(requestParameters: GetGlobalTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedGlobalTimesheets> {
+        const response = await this.getGlobalTimesheetsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getHolidays without sending the request
+     */
+    async getHolidaysRequestOpts(requestParameters: GetHolidaysRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/holidays`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Returns a paginated list of a user\'s holidays
+     */
+    async getHolidaysRaw(requestParameters: GetHolidaysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedHolidaysDTO>> {
+        const requestOptions = await this.getHolidaysRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedHolidaysDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Returns a paginated list of a user\'s holidays
+     */
+    async getHolidays(requestParameters: GetHolidaysRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedHolidaysDTO> {
+        const response = await this.getHolidaysRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getHolidaysByEmployee without sending the request
+     */
+    async getHolidaysByEmployeeRequestOpts(requestParameters: GetHolidaysByEmployeeRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling getHolidaysByEmployee().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}/holidays`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * returns a paginated list of a user\'s holidays
+     */
+    async getHolidaysByEmployeeRaw(requestParameters: GetHolidaysByEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedHolidaysDTO>> {
+        const requestOptions = await this.getHolidaysByEmployeeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedHolidaysDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * returns a paginated list of a user\'s holidays
+     */
+    async getHolidaysByEmployee(requestParameters: GetHolidaysByEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedHolidaysDTO> {
+        const response = await this.getHolidaysByEmployeeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getJiraAccount without sending the request
+     */
+    async getJiraAccountRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/jira-users/jira-accounts`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get Jira account for the authenticated user
+     * Get Jira account
+     */
+    async getJiraAccountRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientJiraAccountDTO>>> {
+        const requestOptions = await this.getJiraAccountRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientJiraAccountDTOFromJSON));
+    }
+
+    /**
+     * Get Jira account for the authenticated user
+     * Get Jira account
+     */
+    async getJiraAccount(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientJiraAccountDTO>> {
+        const response = await this.getJiraAccountRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getJiraUser without sending the request
+     */
+    async getJiraUserRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/jira-users`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get Jira user information for the authenticated user
+     * Get Jira user
+     */
+    async getJiraUserRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientJiraUserDTO>> {
+        const requestOptions = await this.getJiraUserRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientJiraUserDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get Jira user information for the authenticated user
+     * Get Jira user
+     */
+    async getJiraUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientJiraUserDTO> {
+        const response = await this.getJiraUserRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getMyAccount without sending the request
+     */
+    async getMyAccountRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/me`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get my account info
+     * Get my account info
+     */
+    async getMyAccountRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountInfoDTO>> {
+        const requestOptions = await this.getMyAccountRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => AccountInfoDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get my account info
+     * Get my account info
+     */
+    async getMyAccount(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountInfoDTO> {
+        const response = await this.getMyAccountRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getMyCommits without sending the request
+     */
+    async getMyCommitsRequestOpts(requestParameters: GetMyCommitsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['from'] == null) {
+            throw new runtime.RequiredError(
+                'from',
+                'Required parameter "from" was null or undefined when calling getMyCommits().'
+            );
+        }
+
+        if (requestParameters['to'] == null) {
+            throw new runtime.RequiredError(
+                'to',
+                'Required parameter "to" was null or undefined when calling getMyCommits().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['from'] != null) {
+            queryParameters['from'] = (requestParameters['from'] as any).toISOString().substring(0,10);
+        }
+
+        if (requestParameters['to'] != null) {
+            queryParameters['to'] = (requestParameters['to'] as any).toISOString().substring(0,10);
+        }
+
+        if (requestParameters['groupBy'] != null) {
+            queryParameters['groupBy'] = requestParameters['groupBy'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/commits`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get commit statistics for the authenticated user
+     * Get my commits
+     */
+    async getMyCommitsRaw(requestParameters: GetMyCommitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientGithubCommitCountDTO>>> {
+        const requestOptions = await this.getMyCommitsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientGithubCommitCountDTOFromJSON));
+    }
+
+    /**
+     * Get commit statistics for the authenticated user
+     * Get my commits
+     */
+    async getMyCommits(requestParameters: GetMyCommitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientGithubCommitCountDTO>> {
+        const response = await this.getMyCommitsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getProjectById without sending the request
+     */
+    async getProjectByIdRequestOpts(requestParameters: GetProjectByIdRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getProjectById().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get a project
+     * Get a project by ID
+     */
+    async getProjectByIdRaw(requestParameters: GetProjectByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectDTO>> {
+        const requestOptions = await this.getProjectByIdRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get a project
+     * Get a project by ID
+     */
+    async getProjectById(requestParameters: GetProjectByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectDTO> {
+        const response = await this.getProjectByIdRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getProjectReportByUser without sending the request
+     */
+    async getProjectReportByUserRequestOpts(requestParameters: GetProjectReportByUserRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling getProjectReportByUser().'
+            );
+        }
+
+        if (requestParameters['startDate'] == null) {
+            throw new runtime.RequiredError(
+                'startDate',
+                'Required parameter "startDate" was null or undefined when calling getProjectReportByUser().'
+            );
+        }
+
+        if (requestParameters['endDate'] == null) {
+            throw new runtime.RequiredError(
+                'endDate',
+                'Required parameter "endDate" was null or undefined when calling getProjectReportByUser().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+
+        if (requestParameters['startDate'] != null) {
+            queryParameters['startDate'] = (requestParameters['startDate'] as any).toISOString();
+        }
+
+        if (requestParameters['endDate'] != null) {
+            queryParameters['endDate'] = (requestParameters['endDate'] as any).toISOString();
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+
+
+        let urlPath = `/api/projects/report-by-user`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all projects an employee has access to
+     * Get all projects an employee has access to
+     */
+    async getProjectReportByUserRaw(requestParameters: GetProjectReportByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserProjectReport>> {
+        const requestOptions = await this.getProjectReportByUserRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserProjectReportFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all projects an employee has access to
+     * Get all projects an employee has access to
+     */
+    async getProjectReportByUser(requestParameters: GetProjectReportByUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserProjectReport> {
+        const response = await this.getProjectReportByUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getProjects without sending the request
+     */
+    async getProjectsRequestOpts(requestParameters: GetProjectsRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all projects a user or employee has access to
+     * Get all projects a user or employee has access to
+     */
+    async getProjectsRaw(requestParameters: GetProjectsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedProjects>> {
+        const requestOptions = await this.getProjectsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedProjectsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all projects a user or employee has access to
+     * Get all projects a user or employee has access to
+     */
+    async getProjects(requestParameters: GetProjectsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedProjects> {
+        const response = await this.getProjectsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getProjectsAsEmployee without sending the request
+     */
+    async getProjectsAsEmployeeRequestOpts(requestParameters: GetProjectsAsEmployeeRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employee-projects`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all projects an employee has access to
+     * Get all projects an employee has access to
+     */
+    async getProjectsAsEmployeeRaw(requestParameters: GetProjectsAsEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEmployeeProjects>> {
+        const requestOptions = await this.getProjectsAsEmployeeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedEmployeeProjectsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all projects an employee has access to
+     * Get all projects an employee has access to
+     */
+    async getProjectsAsEmployee(requestParameters: GetProjectsAsEmployeeRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedEmployeeProjects> {
+        const response = await this.getProjectsAsEmployeeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getTeam without sending the request
+     */
+    async getTeamRequestOpts(requestParameters: GetTeamRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getTeam().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/team`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all users in a project
+     * Get all users in a project
+     */
+    async getTeamRaw(requestParameters: GetTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUsers>> {
+        const requestOptions = await this.getTeamRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedUsersFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all users in a project
+     * Get all users in a project
+     */
+    async getTeam(requestParameters: GetTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedUsers> {
+        const response = await this.getTeamRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getTimesheet without sending the request
+     */
+    async getTimesheetRequestOpts(requestParameters: GetTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling getTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/timesheets/{timesheetId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get a timesheet
+     * Get a timesheet
+     */
+    async getTimesheetRaw(requestParameters: GetTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TimesheetDTO>> {
+        const requestOptions = await this.getTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => TimesheetDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Get a timesheet
+     * Get a timesheet
+     */
+    async getTimesheet(requestParameters: GetTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TimesheetDTO> {
+        const response = await this.getTimesheetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getTimesheets without sending the request
+     */
+    async getTimesheetsRequestOpts(requestParameters: GetTimesheetsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling getTimesheets().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['pageSize'] = requestParameters['pageSize'];
+        }
+
+        if (requestParameters['search'] != null) {
+            queryParameters['search'] = requestParameters['search'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/timesheets`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get all timesheets in a project without timesheet entries.
+     * Get all timesheets in a project without timesheet entries.
+     */
+    async getTimesheetsRaw(requestParameters: GetTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedTimesheets>> {
+        const requestOptions = await this.getTimesheetsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedTimesheetsFromJSON(jsonValue));
+    }
+
+    /**
+     * Get all timesheets in a project without timesheet entries.
+     * Get all timesheets in a project without timesheet entries.
+     */
+    async getTimesheets(requestParameters: GetTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedTimesheets> {
+        const response = await this.getTimesheetsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for inviteEmployee without sending the request
+     */
+    async inviteEmployeeRequestOpts(requestParameters: InviteEmployeeRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['employeeDTO'] == null) {
+            throw new runtime.RequiredError(
+                'employeeDTO',
+                'Required parameter "employeeDTO" was null or undefined when calling inviteEmployee().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/invite`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: EmployeeDTOToJSON(requestParameters['employeeDTO']),
+        };
+    }
+
+    /**
+     * Invite an employee to a company
+     * Invite an employee to a company
+     */
+    async inviteEmployeeRaw(requestParameters: InviteEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeDTO>> {
+        const requestOptions = await this.inviteEmployeeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EmployeeDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Invite an employee to a company
+     * Invite an employee to a company
+     */
+    async inviteEmployee(requestParameters: InviteEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmployeeDTO> {
+        const response = await this.inviteEmployeeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for markEmployeeInvoiceAsPaid without sending the request
+     */
+    async markEmployeeInvoiceAsPaidRequestOpts(requestParameters: MarkEmployeeInvoiceAsPaidRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling markEmployeeInvoiceAsPaid().'
+            );
+        }
+
+        if (requestParameters['employeeInvoiceId'] == null) {
+            throw new runtime.RequiredError(
+                'employeeInvoiceId',
+                'Required parameter "employeeInvoiceId" was null or undefined when calling markEmployeeInvoiceAsPaid().'
+            );
+        }
+
+        if (requestParameters['markEmployeeInvoicePaidDTO'] == null) {
+            throw new runtime.RequiredError(
+                'markEmployeeInvoicePaidDTO',
+                'Required parameter "markEmployeeInvoicePaidDTO" was null or undefined when calling markEmployeeInvoiceAsPaid().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}/invoices/{employeeInvoiceId}/mark-paid`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+        urlPath = urlPath.replace('{employeeInvoiceId}', encodeURIComponent(String(requestParameters['employeeInvoiceId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: MarkEmployeeInvoicePaidDTOToJSON(requestParameters['markEmployeeInvoicePaidDTO']),
+        };
+    }
+
+    /**
+     * Mark an employee invoice as paid
+     * Mark an employee invoice as paid
+     */
+    async markEmployeeInvoiceAsPaidRaw(requestParameters: MarkEmployeeInvoiceAsPaidRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.markEmployeeInvoiceAsPaidRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Mark an employee invoice as paid
+     * Mark an employee invoice as paid
+     */
+    async markEmployeeInvoiceAsPaid(requestParameters: MarkEmployeeInvoiceAsPaidRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.markEmployeeInvoiceAsPaidRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for markInvoiceAsPaid without sending the request
+     */
+    async markInvoiceAsPaidRequestOpts(requestParameters: MarkInvoiceAsPaidRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['clientId'] == null) {
+            throw new runtime.RequiredError(
+                'clientId',
+                'Required parameter "clientId" was null or undefined when calling markInvoiceAsPaid().'
+            );
+        }
+
+        if (requestParameters['invoiceId'] == null) {
+            throw new runtime.RequiredError(
+                'invoiceId',
+                'Required parameter "invoiceId" was null or undefined when calling markInvoiceAsPaid().'
+            );
+        }
+
+        if (requestParameters['markInvoicePaidDTO'] == null) {
+            throw new runtime.RequiredError(
+                'markInvoicePaidDTO',
+                'Required parameter "markInvoicePaidDTO" was null or undefined when calling markInvoiceAsPaid().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients/{clientId}/invoices/{invoiceId}/mark-paid`;
+        urlPath = urlPath.replace('{clientId}', encodeURIComponent(String(requestParameters['clientId'])));
+        urlPath = urlPath.replace('{invoiceId}', encodeURIComponent(String(requestParameters['invoiceId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: MarkInvoicePaidDTOToJSON(requestParameters['markInvoicePaidDTO']),
+        };
+    }
+
+    /**
+     * Mark a client invoice as paid
+     * Mark a client invoice as paid with the specified date and time
+     */
+    async markInvoiceAsPaidRaw(requestParameters: MarkInvoiceAsPaidRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.markInvoiceAsPaidRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Mark a client invoice as paid
+     * Mark a client invoice as paid with the specified date and time
+     */
+    async markInvoiceAsPaid(requestParameters: MarkInvoiceAsPaidRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.markInvoiceAsPaidRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for openSentTimesheet without sending the request
+     */
+    async openSentTimesheetRequestOpts(requestParameters: OpenSentTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling openSentTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling openSentTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/timesheets/{timesheetId}/open`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Open a sent timesheet
+     * Open a sent timesheet
+     */
+    async openSentTimesheetRaw(requestParameters: OpenSentTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.openSentTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Open a sent timesheet
+     * Open a sent timesheet
+     */
+    async openSentTimesheet(requestParameters: OpenSentTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.openSentTimesheetRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for removeJiraAccount without sending the request
+     */
+    async removeJiraAccountRequestOpts(requestParameters: RemoveJiraAccountRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['jiraAccountId'] == null) {
+            throw new runtime.RequiredError(
+                'jiraAccountId',
+                'Required parameter "jiraAccountId" was null or undefined when calling removeJiraAccount().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/jira-users/jira-accounts/{jiraAccountId}`;
+        urlPath = urlPath.replace('{jiraAccountId}', encodeURIComponent(String(requestParameters['jiraAccountId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Remove specific jira account for the current user
+     * Remove jira account
+     */
+    async removeJiraAccountRaw(requestParameters: RemoveJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.removeJiraAccountRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Remove specific jira account for the current user
+     * Remove jira account
+     */
+    async removeJiraAccount(requestParameters: RemoveJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.removeJiraAccountRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for sendTimesheet without sending the request
+     */
+    async sendTimesheetRequestOpts(requestParameters: SendTimesheetRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling sendTimesheet().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling sendTimesheet().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/timesheets/{timesheetId}/send`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Send a timesheet
+     * Send a timesheet
+     */
+    async sendTimesheetRaw(requestParameters: SendTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.sendTimesheetRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Send a timesheet
+     * Send a timesheet
+     */
+    async sendTimesheet(requestParameters: SendTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.sendTimesheetRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for updateAdjustedEntry without sending the request
+     */
+    async updateAdjustedEntryRequestOpts(requestParameters: UpdateAdjustedEntryRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling updateAdjustedEntry().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling updateAdjustedEntry().'
+            );
+        }
+
+        if (requestParameters['entryId'] == null) {
+            throw new runtime.RequiredError(
+                'entryId',
+                'Required parameter "entryId" was null or undefined when calling updateAdjustedEntry().'
+            );
+        }
+
+        if (requestParameters['adjustedTimesheetUpdateEntryDTO'] == null) {
+            throw new runtime.RequiredError(
+                'adjustedTimesheetUpdateEntryDTO',
+                'Required parameter "adjustedTimesheetUpdateEntryDTO" was null or undefined when calling updateAdjustedEntry().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/adjusted-timesheets/{timesheetId}/entries/{entryId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+        urlPath = urlPath.replace('{entryId}', encodeURIComponent(String(requestParameters['entryId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: AdjustedTimesheetUpdateEntryDTOToJSON(requestParameters['adjustedTimesheetUpdateEntryDTO']),
+        };
+    }
+
+    /**
+     * Update an adjusted timesheet entry
+     * Update an adjusted timesheet entry
+     */
+    async updateAdjustedEntryRaw(requestParameters: UpdateAdjustedEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AdjustedTimesheetEntryDTO>> {
+        const requestOptions = await this.updateAdjustedEntryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => AdjustedTimesheetEntryDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Update an adjusted timesheet entry
+     * Update an adjusted timesheet entry
+     */
+    async updateAdjustedEntry(requestParameters: UpdateAdjustedEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AdjustedTimesheetEntryDTO> {
+        const response = await this.updateAdjustedEntryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for updateClient without sending the request
+     */
+    async updateClientRequestOpts(requestParameters: UpdateClientRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['clientId'] == null) {
+            throw new runtime.RequiredError(
+                'clientId',
+                'Required parameter "clientId" was null or undefined when calling updateClient().'
+            );
+        }
+
+        if (requestParameters['clientDTO'] == null) {
+            throw new runtime.RequiredError(
+                'clientDTO',
+                'Required parameter "clientDTO" was null or undefined when calling updateClient().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/clients/{clientId}`;
+        urlPath = urlPath.replace('{clientId}', encodeURIComponent(String(requestParameters['clientId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ClientDTOToJSON(requestParameters['clientDTO']),
+        };
+    }
+
+    /**
+     * Update client
+     */
+    async updateClientRaw(requestParameters: UpdateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
+        const requestOptions = await this.updateClientRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Update client
+     */
+    async updateClient(requestParameters: UpdateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.updateClientRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for updateCompany without sending the request
+     */
+    async updateCompanyRequestOpts(requestParameters: UpdateCompanyRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['companyId'] == null) {
+            throw new runtime.RequiredError(
+                'companyId',
+                'Required parameter "companyId" was null or undefined when calling updateCompany().'
+            );
+        }
+
+        if (requestParameters['companyDTO'] == null) {
+            throw new runtime.RequiredError(
+                'companyDTO',
+                'Required parameter "companyDTO" was null or undefined when calling updateCompany().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/companies/{companyId}`;
+        urlPath = urlPath.replace('{companyId}', encodeURIComponent(String(requestParameters['companyId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CompanyDTOToJSON(requestParameters['companyDTO']),
+        };
+    }
+
+    /**
+     * Update a company
+     * Update a company by ID
+     */
+    async updateCompanyRaw(requestParameters: UpdateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
+        const requestOptions = await this.updateCompanyRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Update a company
+     * Update a company by ID
+     */
+    async updateCompany(requestParameters: UpdateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
+        const response = await this.updateCompanyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for updateEmployeeData without sending the request
+     */
+    async updateEmployeeDataRequestOpts(requestParameters: UpdateEmployeeDataRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError(
+                'userId',
+                'Required parameter "userId" was null or undefined when calling updateEmployeeData().'
+            );
+        }
+
+        if (requestParameters['employeeUpdateDTO'] == null) {
+            throw new runtime.RequiredError(
+                'employeeUpdateDTO',
+                'Required parameter "employeeUpdateDTO" was null or undefined when calling updateEmployeeData().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/employees/{userId}`;
+        urlPath = urlPath.replace('{userId}', encodeURIComponent(String(requestParameters['userId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: EmployeeUpdateDTOToJSON(requestParameters['employeeUpdateDTO']),
+        };
+    }
+
+    /**
+     * Update an employee
+     * Update an employee
+     */
+    async updateEmployeeDataRaw(requestParameters: UpdateEmployeeDataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeDTO>> {
+        const requestOptions = await this.updateEmployeeDataRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => EmployeeDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Update an employee
+     * Update an employee
+     */
+    async updateEmployeeData(requestParameters: UpdateEmployeeDataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmployeeDTO> {
+        const response = await this.updateEmployeeDataRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for updateGlobalTimesheetEntry without sending the request
+     */
+    async updateGlobalTimesheetEntryRequestOpts(requestParameters: UpdateGlobalTimesheetEntryRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling updateGlobalTimesheetEntry().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling updateGlobalTimesheetEntry().'
+            );
+        }
+
+        if (requestParameters['entryId'] == null) {
+            throw new runtime.RequiredError(
+                'entryId',
+                'Required parameter "entryId" was null or undefined when calling updateGlobalTimesheetEntry().'
+            );
+        }
+
+        if (requestParameters['globalTimesheetEntryUpdateDTO'] == null) {
+            throw new runtime.RequiredError(
+                'globalTimesheetEntryUpdateDTO',
+                'Required parameter "globalTimesheetEntryUpdateDTO" was null or undefined when calling updateGlobalTimesheetEntry().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/global-timesheets/{timesheetId}/entries/{entryId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+        urlPath = urlPath.replace('{entryId}', encodeURIComponent(String(requestParameters['entryId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: GlobalTimesheetEntryUpdateDTOToJSON(requestParameters['globalTimesheetEntryUpdateDTO']),
+        };
+    }
+
+    /**
+     * Update a global timesheet entry
+     * Update a global timesheet entry
+     */
+    async updateGlobalTimesheetEntryRaw(requestParameters: UpdateGlobalTimesheetEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GlobalTimesheetEntryDTO>> {
+        const requestOptions = await this.updateGlobalTimesheetEntryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GlobalTimesheetEntryDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Update a global timesheet entry
+     * Update a global timesheet entry
+     */
+    async updateGlobalTimesheetEntry(requestParameters: UpdateGlobalTimesheetEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GlobalTimesheetEntryDTO> {
+        const response = await this.updateGlobalTimesheetEntryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for updateProject without sending the request
+     */
+    async updateProjectRequestOpts(requestParameters: UpdateProjectRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling updateProject().'
+            );
+        }
+
+        if (requestParameters['projectUpdateDTO'] == null) {
+            throw new runtime.RequiredError(
+                'projectUpdateDTO',
+                'Required parameter "projectUpdateDTO" was null or undefined when calling updateProject().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ProjectUpdateDTOToJSON(requestParameters['projectUpdateDTO']),
+        };
+    }
+
+    /**
+     * Update a project
+     * Update a project by ID
+     */
+    async updateProjectRaw(requestParameters: UpdateProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectDTO>> {
+        const requestOptions = await this.updateProjectRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ProjectDTOFromJSON(jsonValue));
+    }
+
+    /**
+     * Update a project
+     * Update a project by ID
+     */
+    async updateProject(requestParameters: UpdateProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ProjectDTO> {
+        const response = await this.updateProjectRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for updateTeam without sending the request
+     */
+    async updateTeamRequestOpts(requestParameters: UpdateTeamRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling updateTeam().'
+            );
+        }
+
+        if (requestParameters['teamUpdateDTO'] == null) {
+            throw new runtime.RequiredError(
+                'teamUpdateDTO',
+                'Required parameter "teamUpdateDTO" was null or undefined when calling updateTeam().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/team`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: TeamUpdateDTOToJSON(requestParameters['teamUpdateDTO']),
+        };
+    }
+
+    /**
+     * Update a project team
+     * Update a project team
+     */
+    async updateTeamRaw(requestParameters: UpdateTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.updateTeamRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update a project team
+     * Update a project team
+     */
+    async updateTeam(requestParameters: UpdateTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.updateTeamRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Creates request options for updateTimesheetEntry without sending the request
+     */
+    async updateTimesheetEntryRequestOpts(requestParameters: UpdateTimesheetEntryRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['projectId'] == null) {
+            throw new runtime.RequiredError(
+                'projectId',
+                'Required parameter "projectId" was null or undefined when calling updateTimesheetEntry().'
+            );
+        }
+
+        if (requestParameters['timesheetId'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetId',
+                'Required parameter "timesheetId" was null or undefined when calling updateTimesheetEntry().'
+            );
+        }
+
+        if (requestParameters['entryId'] == null) {
+            throw new runtime.RequiredError(
+                'entryId',
+                'Required parameter "entryId" was null or undefined when calling updateTimesheetEntry().'
+            );
+        }
+
+        if (requestParameters['timesheetEntryUpdateDTO'] == null) {
+            throw new runtime.RequiredError(
+                'timesheetEntryUpdateDTO',
+                'Required parameter "timesheetEntryUpdateDTO" was null or undefined when calling updateTimesheetEntry().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // auth0JWT authentication
+        }
+
+
+        let urlPath = `/projects/{projectId}/timesheets/{timesheetId}/entries/{entryId}`;
+        urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+        urlPath = urlPath.replace('{timesheetId}', encodeURIComponent(String(requestParameters['timesheetId'])));
+        urlPath = urlPath.replace('{entryId}', encodeURIComponent(String(requestParameters['entryId'])));
+
+        return {
+            path: urlPath,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: TimesheetEntryUpdateDTOToJSON(requestParameters['timesheetEntryUpdateDTO']),
+        };
+    }
+
+    /**
+     * Update a timesheet entry
+     * Update a timesheet entry
+     */
+    async updateTimesheetEntryRaw(requestParameters: UpdateTimesheetEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.updateTimesheetEntryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Update a timesheet entry
+     * Update a timesheet entry
+     */
+    async updateTimesheetEntry(requestParameters: UpdateTimesheetEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.updateTimesheetEntryRaw(requestParameters, initOverrides);
+    }
+
+}
+
+/**
+ * @export
+ */
+export const GetCommitsByUserIDGroupByEnum = {
+    HourOfDay: 'hourOfDay',
+    Year: 'year',
+    Month: 'month',
+    Day: 'day'
+} as const;
+export type GetCommitsByUserIDGroupByEnum = typeof GetCommitsByUserIDGroupByEnum[keyof typeof GetCommitsByUserIDGroupByEnum];
+/**
+ * @export
+ */
+export const GetMyCommitsGroupByEnum = {
+    HourOfDay: 'hourOfDay',
+    Year: 'year',
+    Month: 'month',
+    Day: 'day'
+} as const;
+export type GetMyCommitsGroupByEnum = typeof GetMyCommitsGroupByEnum[keyof typeof GetMyCommitsGroupByEnum];