/* tslint:disable */
/* eslint-disable */
/**
 * Tuix Services
 * Tuix Services API
 *
 * The version of the OpenAPI document: 1.0.0
 * 
 *
 * 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,
  AdjustedTimesheetDTO,
  AdjustedTimesheetEntryDTO,
  AdjustedTimesheetUpadateEntryDTO,
  ClientDTO,
  CompanyDTO,
  CreateEmployeeInvoiceInputDTO,
  CreateGithubUserDto,
  CreateJiraAccountDto,
  CreateJiraUserDto,
  CreateSubscriptionDTO,
  CreateUserDto,
  EmailTemplates,
  EmployeeDTO,
  EmployeeInvoiceDTO,
  EmployeeUpdateDTO,
  ErrorDTO,
  GithubAccountDto,
  GithubCommitCountDTO,
  GithubUserDto,
  GlobalTimesheetDTO,
  GlobalTimesheetEntryDTO,
  GlobalTimesheetEntryUpdateDTO,
  HolidayCreateDTO,
  HolidayDTO,
  JiraAccountDto,
  JiraUserDto,
  PaginatedAdjustedTimesheets,
  PaginatedClientInvoices,
  PaginatedClients,
  PaginatedEmployeeInvoices,
  PaginatedEmployeeProjects,
  PaginatedEmployees,
  PaginatedGlobalTimesheets,
  PaginatedHolidaysDTO,
  PaginatedProjects,
  PaginatedTimesheets,
  PaginatedUsers,
  PdfTemplateDTO,
  ProjectDTO,
  ProjectInputDTO,
  ProjectUpdateDTO,
  SDKTestRequestDTO,
  SDKTestResponseDTO,
  SendNewsletterDto,
  SlackAccountReponseDto,
  SlackUserDto,
  Subscription,
  SubscriptionsSentResponseDto,
  TeamUpdateDTO,
  TimesheetDTO,
  TimesheetEntryUpdateDTO,
  UpdateUserDto,
  UserDTOSc,
  UserInputDTOSc,
  UserUpdateDTOSc,
} from '../models/index';
import {
    AccountInfoDTOFromJSON,
    AccountInfoDTOToJSON,
    AdjustedTimesheetDTOFromJSON,
    AdjustedTimesheetDTOToJSON,
    AdjustedTimesheetEntryDTOFromJSON,
    AdjustedTimesheetEntryDTOToJSON,
    AdjustedTimesheetUpadateEntryDTOFromJSON,
    AdjustedTimesheetUpadateEntryDTOToJSON,
    ClientDTOFromJSON,
    ClientDTOToJSON,
    CompanyDTOFromJSON,
    CompanyDTOToJSON,
    CreateEmployeeInvoiceInputDTOFromJSON,
    CreateEmployeeInvoiceInputDTOToJSON,
    CreateGithubUserDtoFromJSON,
    CreateGithubUserDtoToJSON,
    CreateJiraAccountDtoFromJSON,
    CreateJiraAccountDtoToJSON,
    CreateJiraUserDtoFromJSON,
    CreateJiraUserDtoToJSON,
    CreateSubscriptionDTOFromJSON,
    CreateSubscriptionDTOToJSON,
    CreateUserDtoFromJSON,
    CreateUserDtoToJSON,
    EmailTemplatesFromJSON,
    EmailTemplatesToJSON,
    EmployeeDTOFromJSON,
    EmployeeDTOToJSON,
    EmployeeInvoiceDTOFromJSON,
    EmployeeInvoiceDTOToJSON,
    EmployeeUpdateDTOFromJSON,
    EmployeeUpdateDTOToJSON,
    ErrorDTOFromJSON,
    ErrorDTOToJSON,
    GithubAccountDtoFromJSON,
    GithubAccountDtoToJSON,
    GithubCommitCountDTOFromJSON,
    GithubCommitCountDTOToJSON,
    GithubUserDtoFromJSON,
    GithubUserDtoToJSON,
    GlobalTimesheetDTOFromJSON,
    GlobalTimesheetDTOToJSON,
    GlobalTimesheetEntryDTOFromJSON,
    GlobalTimesheetEntryDTOToJSON,
    GlobalTimesheetEntryUpdateDTOFromJSON,
    GlobalTimesheetEntryUpdateDTOToJSON,
    HolidayCreateDTOFromJSON,
    HolidayCreateDTOToJSON,
    HolidayDTOFromJSON,
    HolidayDTOToJSON,
    JiraAccountDtoFromJSON,
    JiraAccountDtoToJSON,
    JiraUserDtoFromJSON,
    JiraUserDtoToJSON,
    PaginatedAdjustedTimesheetsFromJSON,
    PaginatedAdjustedTimesheetsToJSON,
    PaginatedClientInvoicesFromJSON,
    PaginatedClientInvoicesToJSON,
    PaginatedClientsFromJSON,
    PaginatedClientsToJSON,
    PaginatedEmployeeInvoicesFromJSON,
    PaginatedEmployeeInvoicesToJSON,
    PaginatedEmployeeProjectsFromJSON,
    PaginatedEmployeeProjectsToJSON,
    PaginatedEmployeesFromJSON,
    PaginatedEmployeesToJSON,
    PaginatedGlobalTimesheetsFromJSON,
    PaginatedGlobalTimesheetsToJSON,
    PaginatedHolidaysDTOFromJSON,
    PaginatedHolidaysDTOToJSON,
    PaginatedProjectsFromJSON,
    PaginatedProjectsToJSON,
    PaginatedTimesheetsFromJSON,
    PaginatedTimesheetsToJSON,
    PaginatedUsersFromJSON,
    PaginatedUsersToJSON,
    PdfTemplateDTOFromJSON,
    PdfTemplateDTOToJSON,
    ProjectDTOFromJSON,
    ProjectDTOToJSON,
    ProjectInputDTOFromJSON,
    ProjectInputDTOToJSON,
    ProjectUpdateDTOFromJSON,
    ProjectUpdateDTOToJSON,
    SDKTestRequestDTOFromJSON,
    SDKTestRequestDTOToJSON,
    SDKTestResponseDTOFromJSON,
    SDKTestResponseDTOToJSON,
    SendNewsletterDtoFromJSON,
    SendNewsletterDtoToJSON,
    SlackAccountReponseDtoFromJSON,
    SlackAccountReponseDtoToJSON,
    SlackUserDtoFromJSON,
    SlackUserDtoToJSON,
    SubscriptionFromJSON,
    SubscriptionToJSON,
    SubscriptionsSentResponseDtoFromJSON,
    SubscriptionsSentResponseDtoToJSON,
    TeamUpdateDTOFromJSON,
    TeamUpdateDTOToJSON,
    TimesheetDTOFromJSON,
    TimesheetDTOToJSON,
    TimesheetEntryUpdateDTOFromJSON,
    TimesheetEntryUpdateDTOToJSON,
    UpdateUserDtoFromJSON,
    UpdateUserDtoToJSON,
    UserDTOScFromJSON,
    UserDTOScToJSON,
    UserInputDTOScFromJSON,
    UserInputDTOScToJSON,
    UserUpdateDTOScFromJSON,
    UserUpdateDTOScToJSON,
} from '../models/index';

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 {
    employeeId: string;
    createEmployeeInvoiceInputDTO: CreateEmployeeInvoiceInputDTO;
}

export interface CreateGithubUserRequest {
    createGithubUserDto: CreateGithubUserDto;
}

export interface CreateHolidayRequest {
    holidayCreateDTO: HolidayCreateDTO;
}

export interface CreateJiraUserRequest {
    createJiraUserDto: CreateJiraUserDto;
}

export interface CreateProjectRequest {
    projectInputDTO: ProjectInputDTO;
}

export interface CreateSlackUserRequest {
    createUserDto: CreateUserDto;
}

export interface CreateSubscriptionRequest {
    createSubscriptionDTO: CreateSubscriptionDTO;
}

export interface CreateUserRequest {
    userInputDTOSc: UserInputDTOSc;
}

export interface DeleteClientRequest {
    clientId: string;
}

export interface DeleteCompanyRequest {
    companyId: string;
}

export interface DeleteEmployeeRequest {
    employeeId: string;
}

export interface DeleteHolidayRequest {
    holidayId: string;
}

export interface DeleteProjectRequest {
    projectId: string;
}

export interface DeleteSubscriptionRequest {
    id: string;
}

export interface DeleteUserRequest {
    id: string;
}

export interface DownloadAdjustedTimesheetPdfRequest {
    projectId: string;
    timesheetId: string;
}

export interface DownloadClientInvoicePdfRequest {
    invoiceId: string;
    clientId: string;
}

export interface DownloadEmployeeInvoicePdfRequest {
    employeeId: string;
    employeeInvoiceId: string;
}

export interface DownloadGlobalTimesheetPdfRequest {
    projectId: string;
    timesheetId: string;
}

export interface DownloadTimesheetPdfRequest {
    projectId: string;
    timesheetId: string;
}

export interface EmployeesControllerGetCommitsByUserIdRequest {
    from: Date;
    to: Date;
    groupBy: EmployeesControllerGetCommitsByUserIdGroupByEnum;
    employeeId: any;
}

export interface EmployeesControllerGetMyCommitsRequest {
    from: Date;
    to: Date;
    groupBy: EmployeesControllerGetMyCommitsGroupByEnum;
}

export interface EmployeesEmployeeIdGetRequest {
    employeeId: string;
}

export interface GetAdjustedTimesheetRequest {
    projectId: string;
    timesheetId: string;
}

export interface GetAdjustedTimesheetsRequest {
    projectId: string;
    page?: number;
    pageSize?: number;
}

export interface GetClientByIdRequest {
    clientId: string;
}

export interface GetClientInvoicesRequest {
    clientId: string;
    page?: number;
    pageSize?: number;
}

export interface GetClientsRequest {
    page?: number;
    pageSize?: number;
}

export interface GetCompanyRequest {
    companyId: string;
}

export interface GetEmployeeInvoicesRequest {
    employeeId: string;
    page?: number;
    pageSize?: number;
}

export interface GetEmployeeTimesheetsRequest {
    projectId: string;
    page?: number;
    pageSize?: number;
}

export interface GetEmployeesRequest {
    page?: number;
    pageSize?: number;
    activated?: boolean;
}

export interface GetGlobalTimesheetRequest {
    projectId: string;
    timesheetId: string;
}

export interface GetGlobalTimesheetsRequest {
    projectId: string;
    page?: number;
    pageSize?: number;
}

export interface GetHolidaysRequest {
    page?: number;
    pageSize?: number;
}

export interface GetHolidaysByEmployeeRequest {
    employeeId: string;
    page?: number;
    pageSize?: number;
}

export interface GetPdfTemplateRequest {
    id: string;
}

export interface GetProjectByIdRequest {
    projectId: string;
}

export interface GetProjectsRequest {
    page?: number;
    pageSize?: number;
}

export interface GetProjectsAsEmployeeRequest {
    page?: number;
    pageSize?: number;
}

export interface GetTeamRequest {
    projectId: string;
    page?: number;
    pageSize?: number;
}

export interface GetTemplateByIdRequest {
    id: string;
}

export interface GetTimesheetRequest {
    projectId: string;
    timesheetId: string;
}

export interface GetTimesheetsRequest {
    projectId: string;
    page?: number;
    pageSize?: number;
}

export interface GetUserByIdRequest {
    id: string;
}

export interface InviteEmployeeRequest {
    employeeDTO: EmployeeDTO;
}

export interface OpenSentTimesheetRequest {
    projectId: string;
    timesheetId: string;
}

export interface RemoveJiraAccountRequest {
    jiraAccountId: string;
}

export interface SdkTestRequest {
    sDKTestRequestDTO: SDKTestRequestDTO;
}

export interface SendEmailRequest {
    from: string;
    to: string;
    subject: string;
    templateUUID: string;
    body?: string;
    data?: string;
    file?: Blob;
}

export interface SendNewsletterToSubscribersRequest {
    sendNewsletterDto: SendNewsletterDto;
}

export interface SendTimesheetRequest {
    projectId: string;
    timesheetId: string;
}

export interface UpdateAdjustedEntryRequest {
    projectId: string;
    timesheetId: string;
    entryId: string;
    adjustedTimesheetUpadateEntryDTO: AdjustedTimesheetUpadateEntryDTO;
}

export interface UpdateClientRequest {
    clientId: string;
    clientDTO: ClientDTO;
}

export interface UpdateCompanyRequest {
    companyId: string;
    companyDTO: CompanyDTO;
}

export interface UpdateEmployeeDataRequest {
    employeeId: string;
    employeeUpdateDTO: EmployeeUpdateDTO;
}

export interface UpdateGlobalTimesheetEntryRequest {
    projectId: string;
    timesheetId: string;
    entryId: string;
    globalTimesheetEntryUpdateDTO: GlobalTimesheetEntryUpdateDTO;
}

export interface UpdateProjectRequest {
    projectId: string;
    projectUpdateDTO: ProjectUpdateDTO;
}

export interface UpdateSlackbotUserRequest {
    userId: string;
    updateUserDto: UpdateUserDto;
}

export interface UpdateTeamRequest {
    projectId: string;
    teamUpdateDTO: TeamUpdateDTO;
}

export interface UpdateTimesheetEntryRequest {
    projectId: string;
    timesheetId: string;
    entryId: string;
    timesheetEntryUpdateDTO: TimesheetEntryUpdateDTO;
}

export interface UpdateUserRequest {
    id: string;
    userUpdateDTOSc: UserUpdateDTOSc;
}

export interface UploadPdfTemplateRequest {
    file: Blob;
    name: string;
}

export interface UploadTemplateRequest {
    name: string;
    file: Blob;
}

/**
 * 
 */
export class TuixTimesheetsClientApi extends runtime.BaseAPI {

    /**
     * Add a new jira account to the user
     */
    async addJiraAccountRaw(requestParameters: AddJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<JiraAccountDto>> {
        if (requestParameters.createJiraAccountDto === null || requestParameters.createJiraAccountDto === undefined) {
            throw new runtime.RequiredError('createJiraAccountDto','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/jira-users/jira-accounts`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateJiraAccountDtoToJSON(requestParameters.createJiraAccountDto),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => JiraAccountDtoFromJSON(jsonValue));
    }

    /**
     * Add a new jira account to the user
     */
    async addJiraAccount(requestParameters: AddJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<JiraAccountDto> {
        const response = await this.addJiraAccountRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Aprove an adjustedTimesheet in a project
     * Aprove an adjustedTimesheet in a project
     */
    async approveAdjustedTimesheetRaw(requestParameters: ApproveAdjustedTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling approveAdjustedTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling approveAdjustedTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/adjusted-timesheets/{timesheetId}/approve`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Aprove an adjustedTimesheet in a project
     * Aprove an adjustedTimesheet in a project
     */
    async approveAdjustedTimesheet(requestParameters: ApproveAdjustedTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.approveAdjustedTimesheetRaw(requestParameters, initOverrides);
    }

    /**
     * Approve a global timesheet
     * Approve a global timesheet
     */
    async approveGlobalTimesheetRaw(requestParameters: ApproveGlobalTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling approveGlobalTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling approveGlobalTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/global-timesheets/{timesheetId}/approve`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * Approve a timesheet
     * Approve a timesheet
     */
    async approveTimesheetRaw(requestParameters: ApproveTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling approveTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling approveTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/timesheets/{timesheetId}/approve`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * Create client
     */
    async createClientRaw(requestParameters: CreateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
        if (requestParameters.clientDTO === null || requestParameters.clientDTO === undefined) {
            throw new runtime.RequiredError('clientDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/clients`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ClientDTOToJSON(requestParameters.clientDTO),
        }, 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();
    }

    /**
     * Create a company
     * Creates a new company
     */
    async createCompanyRaw(requestParameters: CreateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
        if (requestParameters.companyDTO === null || requestParameters.companyDTO === undefined) {
            throw new runtime.RequiredError('companyDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/companies`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CompanyDTOToJSON(requestParameters.companyDTO),
        }, 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();
    }

    /**
     * Create an employee invoice
     * Create an employee invoice
     */
    async createEmployeeInvoiceRaw(requestParameters: CreateEmployeeInvoiceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeInvoiceDTO>> {
        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling createEmployeeInvoice.');
        }

        if (requestParameters.createEmployeeInvoiceInputDTO === null || requestParameters.createEmployeeInvoiceInputDTO === undefined) {
            throw new runtime.RequiredError('createEmployeeInvoiceInputDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}/invoices`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateEmployeeInvoiceInputDTOToJSON(requestParameters.createEmployeeInvoiceInputDTO),
        }, 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();
    }

    /**
     * 
     */
    async createGithubUserRaw(requestParameters: CreateGithubUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GithubUserDto>> {
        if (requestParameters.createGithubUserDto === null || requestParameters.createGithubUserDto === undefined) {
            throw new runtime.RequiredError('createGithubUserDto','Required parameter requestParameters.createGithubUserDto 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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/github-users`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateGithubUserDtoToJSON(requestParameters.createGithubUserDto),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => GithubUserDtoFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createGithubUser(requestParameters: CreateGithubUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GithubUserDto> {
        const response = await this.createGithubUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Allows a user to add a holiday
     */
    async createHolidayRaw(requestParameters: CreateHolidayRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<HolidayDTO>> {
        if (requestParameters.holidayCreateDTO === null || requestParameters.holidayCreateDTO === undefined) {
            throw new runtime.RequiredError('holidayCreateDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/holidays`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: HolidayCreateDTOToJSON(requestParameters.holidayCreateDTO),
        }, 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();
    }

    /**
     * Create a new user
     */
    async createJiraUserRaw(requestParameters: CreateJiraUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<JiraUserDto>> {
        if (requestParameters.createJiraUserDto === null || requestParameters.createJiraUserDto === undefined) {
            throw new runtime.RequiredError('createJiraUserDto','Required parameter requestParameters.createJiraUserDto 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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/jira-users`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateJiraUserDtoToJSON(requestParameters.createJiraUserDto),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => JiraUserDtoFromJSON(jsonValue));
    }

    /**
     * Create a new user
     */
    async createJiraUser(requestParameters: CreateJiraUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<JiraUserDto> {
        const response = await this.createJiraUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Create a project
     * Creates a new project
     */
    async createProjectRaw(requestParameters: CreateProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectDTO>> {
        if (requestParameters.projectInputDTO === null || requestParameters.projectInputDTO === undefined) {
            throw new runtime.RequiredError('projectInputDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ProjectInputDTOToJSON(requestParameters.projectInputDTO),
        }, 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();
    }

    /**
     * 
     */
    async createSlackUserRaw(requestParameters: CreateSlackUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SlackAccountReponseDto>> {
        if (requestParameters.createUserDto === null || requestParameters.createUserDto === undefined) {
            throw new runtime.RequiredError('createUserDto','Required parameter requestParameters.createUserDto was null or undefined when calling createSlackUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/slackbot-users`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateUserDtoToJSON(requestParameters.createUserDto),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SlackAccountReponseDtoFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createSlackUser(requestParameters: CreateSlackUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SlackAccountReponseDto> {
        const response = await this.createSlackUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createSubscriptionRaw(requestParameters: CreateSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Subscription>> {
        if (requestParameters.createSubscriptionDTO === null || requestParameters.createSubscriptionDTO === undefined) {
            throw new runtime.RequiredError('createSubscriptionDTO','Required parameter requestParameters.createSubscriptionDTO was null or undefined when calling createSubscription.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/subscriptions`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CreateSubscriptionDTOToJSON(requestParameters.createSubscriptionDTO),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createSubscription(requestParameters: CreateSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Subscription> {
        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Create user
     * Create a user
     */
    async createUserRaw(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserDTOSc>> {
        if (requestParameters.userInputDTOSc === null || requestParameters.userInputDTOSc === undefined) {
            throw new runtime.RequiredError('userInputDTOSc','Required parameter requestParameters.userInputDTOSc was null or undefined when calling createUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/test-users`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UserInputDTOScToJSON(requestParameters.userInputDTOSc),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
    }

    /**
     * Create user
     * Create a user
     */
    async createUser(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
        const response = await this.createUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Delete client
     */
    async deleteClientRaw(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.clientId === null || requestParameters.clientId === undefined) {
            throw new runtime.RequiredError('clientId','Required parameter requestParameters.clientId was null or undefined when calling deleteClient.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/clients/{clientId}`.replace(`{${"clientId"}}`, encodeURIComponent(String(requestParameters.clientId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete client
     */
    async deleteClient(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.deleteClientRaw(requestParameters, initOverrides);
    }

    /**
     * Delete a company
     * delete a company
     */
    async deleteCompanyRaw(requestParameters: DeleteCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.companyId === null || requestParameters.companyId === undefined) {
            throw new runtime.RequiredError('companyId','Required parameter requestParameters.companyId was null or undefined when calling deleteCompany.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/companies/{companyId}`.replace(`{${"companyId"}}`, encodeURIComponent(String(requestParameters.companyId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * Delete an employee
     * Delete an employee
     */
    async deleteEmployeeRaw(requestParameters: DeleteEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling deleteEmployee.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * 
     */
    async deleteGithubUserRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/github-users`,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async deleteGithubUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.deleteGithubUserRaw(initOverrides);
    }

    /**
     * Delete a holiday
     * delete a holiday
     */
    async deleteHolidayRaw(requestParameters: DeleteHolidayRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.holidayId === null || requestParameters.holidayId === undefined) {
            throw new runtime.RequiredError('holidayId','Required parameter requestParameters.holidayId was null or undefined when calling deleteHoliday.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/holidays/{holidayId}`.replace(`{${"holidayId"}}`, encodeURIComponent(String(requestParameters.holidayId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * Delete a project
     * delete a project
     */
    async deleteProjectRaw(requestParameters: DeleteProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling deleteProject.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * 
     */
    async deleteSlackUserRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/slackbot-users`,
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async deleteSlackUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.deleteSlackUserRaw(initOverrides);
    }

    /**
     * 
     */
    async deleteSubscriptionRaw(requestParameters: DeleteSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSubscription.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async deleteSubscription(requestParameters: DeleteSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.deleteSubscriptionRaw(requestParameters, initOverrides);
    }

    /**
     * Delete user
     * Delete a user by ID
     */
    async deleteUserRaw(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Delete user
     * Delete a user by ID
     */
    async deleteUser(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.deleteUserRaw(requestParameters, initOverrides);
    }

    /**
     * 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>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling downloadAdjustedTimesheetPdf.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling downloadAdjustedTimesheetPdf.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/adjusted-timesheets/{timesheetId}/download`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Download client invoice pdf
     * Download client invoice pdf
     */
    async downloadClientInvoicePdfRaw(requestParameters: DownloadClientInvoicePdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
        if (requestParameters.invoiceId === null || requestParameters.invoiceId === undefined) {
            throw new runtime.RequiredError('invoiceId','Required parameter requestParameters.invoiceId was null or undefined when calling downloadClientInvoicePdf.');
        }

        if (requestParameters.clientId === null || requestParameters.clientId === undefined) {
            throw new runtime.RequiredError('clientId','Required parameter requestParameters.clientId was null or undefined when calling downloadClientInvoicePdf.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/clients/{clientId}/invoices/{invoiceId}/download`.replace(`{${"invoiceId"}}`, encodeURIComponent(String(requestParameters.invoiceId))).replace(`{${"clientId"}}`, encodeURIComponent(String(requestParameters.clientId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 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>> {
        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling downloadEmployeeInvoicePdf.');
        }

        if (requestParameters.employeeInvoiceId === null || requestParameters.employeeInvoiceId === undefined) {
            throw new runtime.RequiredError('employeeInvoiceId','Required parameter requestParameters.employeeInvoiceId was null or undefined when calling downloadEmployeeInvoicePdf.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}/invoices/{employeeInvoiceId}/download`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))).replace(`{${"employeeInvoiceId"}}`, encodeURIComponent(String(requestParameters.employeeInvoiceId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 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>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling downloadGlobalTimesheetPdf.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling downloadGlobalTimesheetPdf.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/global-timesheets/{timesheetId}/download`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 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>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling downloadTimesheetPdf.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling downloadTimesheetPdf.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/timesheets/{timesheetId}/download`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     */
    async employeesControllerGetCommitsByUserIdRaw(requestParameters: EmployeesControllerGetCommitsByUserIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<GithubCommitCountDTO>>> {
        if (requestParameters.from === null || requestParameters.from === undefined) {
            throw new runtime.RequiredError('from','Required parameter requestParameters.from was null or undefined when calling employeesControllerGetCommitsByUserId.');
        }

        if (requestParameters.to === null || requestParameters.to === undefined) {
            throw new runtime.RequiredError('to','Required parameter requestParameters.to was null or undefined when calling employeesControllerGetCommitsByUserId.');
        }

        if (requestParameters.groupBy === null || requestParameters.groupBy === undefined) {
            throw new runtime.RequiredError('groupBy','Required parameter requestParameters.groupBy was null or undefined when calling employeesControllerGetCommitsByUserId.');
        }

        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling employeesControllerGetCommitsByUserId.');
        }

        const queryParameters: any = {};

        if (requestParameters.from !== undefined) {
            queryParameters['from'] = (requestParameters.from as any).toISOString().substring(0,10);
        }

        if (requestParameters.to !== undefined) {
            queryParameters['to'] = (requestParameters.to as any).toISOString().substring(0,10);
        }

        if (requestParameters.groupBy !== undefined) {
            queryParameters['groupBy'] = requestParameters.groupBy;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}/commits`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(GithubCommitCountDTOFromJSON));
    }

    /**
     */
    async employeesControllerGetCommitsByUserId(requestParameters: EmployeesControllerGetCommitsByUserIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<GithubCommitCountDTO>> {
        const response = await this.employeesControllerGetCommitsByUserIdRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     */
    async employeesControllerGetMyCommitsRaw(requestParameters: EmployeesControllerGetMyCommitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<GithubCommitCountDTO>>> {
        if (requestParameters.from === null || requestParameters.from === undefined) {
            throw new runtime.RequiredError('from','Required parameter requestParameters.from was null or undefined when calling employeesControllerGetMyCommits.');
        }

        if (requestParameters.to === null || requestParameters.to === undefined) {
            throw new runtime.RequiredError('to','Required parameter requestParameters.to was null or undefined when calling employeesControllerGetMyCommits.');
        }

        if (requestParameters.groupBy === null || requestParameters.groupBy === undefined) {
            throw new runtime.RequiredError('groupBy','Required parameter requestParameters.groupBy was null or undefined when calling employeesControllerGetMyCommits.');
        }

        const queryParameters: any = {};

        if (requestParameters.from !== undefined) {
            queryParameters['from'] = (requestParameters.from as any).toISOString().substring(0,10);
        }

        if (requestParameters.to !== undefined) {
            queryParameters['to'] = (requestParameters.to as any).toISOString().substring(0,10);
        }

        if (requestParameters.groupBy !== undefined) {
            queryParameters['groupBy'] = requestParameters.groupBy;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/commits`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(GithubCommitCountDTOFromJSON));
    }

    /**
     */
    async employeesControllerGetMyCommits(requestParameters: EmployeesControllerGetMyCommitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<GithubCommitCountDTO>> {
        const response = await this.employeesControllerGetMyCommitsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get employee info
     * Get employee info
     */
    async employeesEmployeeIdGetRaw(requestParameters: EmployeesEmployeeIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeDTO>> {
        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling employeesEmployeeIdGet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EmployeeDTOFromJSON(jsonValue));
    }

    /**
     * Get employee info
     * Get employee info
     */
    async employeesEmployeeIdGet(requestParameters: EmployeesEmployeeIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmployeeDTO> {
        const response = await this.employeesEmployeeIdGetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get an adjustedTimesheet
     * Get an adjustedTimesheet
     */
    async getAdjustedTimesheetRaw(requestParameters: GetAdjustedTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AdjustedTimesheetDTO>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getAdjustedTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling getAdjustedTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/adjusted-timesheets/{timesheetId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get all adjustedTimesheets in a project
     * Get all adjustedTimesheets in a project
     */
    async getAdjustedTimesheetsRaw(requestParameters: GetAdjustedTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedAdjustedTimesheets>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getAdjustedTimesheets.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/adjusted-timesheets`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get client by id
     */
    async getClientByIdRaw(requestParameters: GetClientByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
        if (requestParameters.clientId === null || requestParameters.clientId === undefined) {
            throw new runtime.RequiredError('clientId','Required parameter requestParameters.clientId was null or undefined when calling getClientById.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/clients/{clientId}`.replace(`{${"clientId"}}`, encodeURIComponent(String(requestParameters.clientId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get all invoices from client
     * Get all invoices from client
     */
    async getClientInvoicesRaw(requestParameters: GetClientInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedClientInvoices>> {
        if (requestParameters.clientId === null || requestParameters.clientId === undefined) {
            throw new runtime.RequiredError('clientId','Required parameter requestParameters.clientId was null or undefined when calling getClientInvoices.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/clients/{clientId}/invoices`.replace(`{${"clientId"}}`, encodeURIComponent(String(requestParameters.clientId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get all clients from company
     */
    async getClientsRaw(requestParameters: GetClientsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedClients>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/clients`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedClientsFromJSON(jsonValue));
    }

    /**
     * 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();
    }

    /**
     * Get all companies a user belongs to
     * Get all companies a user belongs to
     */
    async getCompaniesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CompanyDTO>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/companies`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CompanyDTO>> {
        const response = await this.getCompaniesRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get a company
     * Get a company by ID
     */
    async getCompanyRaw(requestParameters: GetCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
        if (requestParameters.companyId === null || requestParameters.companyId === undefined) {
            throw new runtime.RequiredError('companyId','Required parameter requestParameters.companyId was null or undefined when calling getCompany.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/companies/{companyId}`.replace(`{${"companyId"}}`, encodeURIComponent(String(requestParameters.companyId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get all employee invoices
     * Get all employee invoices
     */
    async getEmployeeInvoicesRaw(requestParameters: GetEmployeeInvoicesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEmployeeInvoices>> {
        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling getEmployeeInvoices.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}/invoices`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 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>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getEmployeeTimesheets.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/employee-timesheets`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * List employees
     * List employees
     */
    async getEmployeesRaw(requestParameters: GetEmployeesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEmployees>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        if (requestParameters.activated !== undefined) {
            queryParameters['activated'] = requestParameters.activated;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 
     */
    async getGithubAccountRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GithubAccountDto>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/github-accounts`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => GithubAccountDtoFromJSON(jsonValue));
    }

    /**
     * 
     */
    async getGithubAccount(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GithubAccountDto> {
        const response = await this.getGithubAccountRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get a global timesheet
     * Get a global timesheet
     */
    async getGlobalTimesheetRaw(requestParameters: GetGlobalTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GlobalTimesheetDTO>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getGlobalTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling getGlobalTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/global-timesheets/{timesheetId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 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>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getGlobalTimesheets.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/global-timesheets`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Returns a paginated list of a user\'s holidays
     */
    async getHolidaysRaw(requestParameters: GetHolidaysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedHolidaysDTO>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/holidays`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Returns a paginated list of a user\'s holidays
     */
    async getHolidaysByEmployeeRaw(requestParameters: GetHolidaysByEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedHolidaysDTO>> {
        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling getHolidaysByEmployee.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}/holidays`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get jira accounts
     */
    async getJiraAccountsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<JiraAccountDto>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/jira-users/jira-accounts`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(JiraAccountDtoFromJSON));
    }

    /**
     * Get jira accounts
     */
    async getJiraAccounts(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<JiraAccountDto>> {
        const response = await this.getJiraAccountsRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get user
     */
    async getJiraUserRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<JiraUserDto>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/jira-users`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => JiraUserDtoFromJSON(jsonValue));
    }

    /**
     * Get user
     */
    async getJiraUser(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<JiraUserDto> {
        const response = await this.getJiraUserRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get my account info
     * Get my account info
     */
    async getMyAccountRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountInfoDTO>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/me`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get template by id
     * Get template by id
     */
    async getPdfTemplateRaw(requestParameters: GetPdfTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getPdfTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/pdf-templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<string>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * Get template by id
     * Get template by id
     */
    async getPdfTemplate(requestParameters: GetPdfTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
        const response = await this.getPdfTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get all templates
     * Get all templates
     */
    async getPdfTemplatesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<PdfTemplateDTO>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/pdf-templates`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(PdfTemplateDTOFromJSON));
    }

    /**
     * Get all templates
     * Get all templates
     */
    async getPdfTemplates(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<PdfTemplateDTO>> {
        const response = await this.getPdfTemplatesRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get a project
     * Get a project by ID
     */
    async getProjectByIdRaw(requestParameters: GetProjectByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectDTO>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getProjectById.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 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 queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get all projects a employee has access to
     * Get all projects a employee has access to
     */
    async getProjectsAsEmployeeRaw(requestParameters: GetProjectsAsEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedEmployeeProjects>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employee-projects`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedEmployeeProjectsFromJSON(jsonValue));
    }

    /**
     * Get all projects a employee has access to
     * Get all projects a 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();
    }

    /**
     * 
     */
    async getSlackAccountRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SlackAccountReponseDto>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/slack-accounts`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SlackAccountReponseDtoFromJSON(jsonValue));
    }

    /**
     * 
     */
    async getSlackAccount(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SlackAccountReponseDto> {
        const response = await this.getSlackAccountRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async getSubscriptionsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Subscription>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/subscriptions`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubscriptionFromJSON));
    }

    /**
     * 
     */
    async getSubscriptions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Subscription>> {
        const response = await this.getSubscriptionsRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get all users in a project
     * Get all users in a project
     */
    async getTeamRaw(requestParameters: GetTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedUsers>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getTeam.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/team`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * 
     */
    async getTemplateByIdRaw(requestParameters: GetTemplateByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTemplateById.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<string>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * 
     */
    async getTemplateById(requestParameters: GetTemplateByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
        const response = await this.getTemplateByIdRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async getTemplatesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<EmailTemplates>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/templates`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(EmailTemplatesFromJSON));
    }

    /**
     * 
     */
    async getTemplates(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<EmailTemplates>> {
        const response = await this.getTemplatesRaw(initOverrides);
        return await response.value();
    }

    /**
     * Get a timesheet
     * Get a timesheet
     */
    async getTimesheetRaw(requestParameters: GetTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TimesheetDTO>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling getTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/timesheets/{timesheetId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, 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();
    }

    /**
     * Get all timesheets in a project
     * Get all timesheets in a project
     */
    async getTimesheetsRaw(requestParameters: GetTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedTimesheets>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling getTimesheets.');
        }

        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['pageSize'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/timesheets`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedTimesheetsFromJSON(jsonValue));
    }

    /**
     * Get all timesheets in a project
     * Get all timesheets in a project
     */
    async getTimesheets(requestParameters: GetTimesheetsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedTimesheets> {
        const response = await this.getTimesheetsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get user by id
     * Get a user by ID
     */
    async getUserByIdRaw(requestParameters: GetUserByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserDTOSc>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getUserById.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
    }

    /**
     * Get user by id
     * Get a user by ID
     */
    async getUserById(requestParameters: GetUserByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
        const response = await this.getUserByIdRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Get all users
     * Get all users
     */
    async getUsersRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UserDTOSc>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/test-users`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UserDTOScFromJSON));
    }

    /**
     * Get all users
     * Get all users
     */
    async getUsers(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UserDTOSc>> {
        const response = await this.getUsersRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async handleActionRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/slack-actions`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async handleAction(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.handleActionRaw(initOverrides);
    }

    /**
     * Invite an employee to a company
     * Invite an employee to a company
     */
    async inviteEmployeeRaw(requestParameters: InviteEmployeeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeDTO>> {
        if (requestParameters.employeeDTO === null || requestParameters.employeeDTO === undefined) {
            throw new runtime.RequiredError('employeeDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/invite`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: EmployeeDTOToJSON(requestParameters.employeeDTO),
        }, 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();
    }

    /**
     * Open a sent timesheet
     * Open a sent timesheet
     */
    async openSentTimesheetRaw(requestParameters: OpenSentTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling openSentTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling openSentTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/timesheets/{timesheetId}/open`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * Remove jira account
     */
    async removeJiraAccountRaw(requestParameters: RemoveJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.jiraAccountId === null || requestParameters.jiraAccountId === undefined) {
            throw new runtime.RequiredError('jiraAccountId','Required parameter requestParameters.jiraAccountId was null or undefined when calling removeJiraAccount.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/jira-users/jira-accounts/{jiraAccountId}`.replace(`{${"jiraAccountId"}}`, encodeURIComponent(String(requestParameters.jiraAccountId))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * Remove jira account
     */
    async removeJiraAccount(requestParameters: RemoveJiraAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.removeJiraAccountRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async sdkTestRaw(requestParameters: SdkTestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SDKTestResponseDTO>> {
        if (requestParameters.sDKTestRequestDTO === null || requestParameters.sDKTestRequestDTO === undefined) {
            throw new runtime.RequiredError('sDKTestRequestDTO','Required parameter requestParameters.sDKTestRequestDTO was null or undefined when calling sdkTest.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/sdkTest`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SDKTestRequestDTOToJSON(requestParameters.sDKTestRequestDTO),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SDKTestResponseDTOFromJSON(jsonValue));
    }

    /**
     * 
     */
    async sdkTest(requestParameters: SdkTestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SDKTestResponseDTO> {
        const response = await this.sdkTestRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async sendEmailRaw(requestParameters: SendEmailRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.from === null || requestParameters.from === undefined) {
            throw new runtime.RequiredError('from','Required parameter requestParameters.from was null or undefined when calling sendEmail.');
        }

        if (requestParameters.to === null || requestParameters.to === undefined) {
            throw new runtime.RequiredError('to','Required parameter requestParameters.to was null or undefined when calling sendEmail.');
        }

        if (requestParameters.subject === null || requestParameters.subject === undefined) {
            throw new runtime.RequiredError('subject','Required parameter requestParameters.subject was null or undefined when calling sendEmail.');
        }

        if (requestParameters.templateUUID === null || requestParameters.templateUUID === undefined) {
            throw new runtime.RequiredError('templateUUID','Required parameter requestParameters.templateUUID was null or undefined when calling sendEmail.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters.from !== undefined) {
            formParams.append('from', requestParameters.from as any);
        }

        if (requestParameters.to !== undefined) {
            formParams.append('to', requestParameters.to as any);
        }

        if (requestParameters.subject !== undefined) {
            formParams.append('subject', requestParameters.subject as any);
        }

        if (requestParameters.body !== undefined) {
            formParams.append('body', requestParameters.body as any);
        }

        if (requestParameters.data !== undefined) {
            formParams.append('data', requestParameters.data as any);
        }

        if (requestParameters.templateUUID !== undefined) {
            formParams.append('templateUUID', requestParameters.templateUUID as any);
        }

        if (requestParameters.file !== undefined) {
            formParams.append('file', requestParameters.file as any);
        }

        const response = await this.request({
            path: `/emails/send`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async sendEmail(requestParameters: SendEmailRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.sendEmailRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async sendNewsletterToSubscribersRaw(requestParameters: SendNewsletterToSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscriptionsSentResponseDto>> {
        if (requestParameters.sendNewsletterDto === null || requestParameters.sendNewsletterDto === undefined) {
            throw new runtime.RequiredError('sendNewsletterDto','Required parameter requestParameters.sendNewsletterDto was null or undefined when calling sendNewsletterToSubscribers.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/subscriptions/newsletter`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SendNewsletterDtoToJSON(requestParameters.sendNewsletterDto),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionsSentResponseDtoFromJSON(jsonValue));
    }

    /**
     * 
     */
    async sendNewsletterToSubscribers(requestParameters: SendNewsletterToSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionsSentResponseDto> {
        const response = await this.sendNewsletterToSubscribersRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Send a timesheet
     * Send a timesheet
     */
    async sendTimesheetRaw(requestParameters: SendTimesheetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling sendTimesheet.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling sendTimesheet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/timesheets/{timesheetId}/send`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
        }, 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);
    }

    /**
     * Update an adjusted timesheet entry
     * Update an adjusted timesheet entry
     */
    async updateAdjustedEntryRaw(requestParameters: UpdateAdjustedEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AdjustedTimesheetEntryDTO>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling updateAdjustedEntry.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling updateAdjustedEntry.');
        }

        if (requestParameters.entryId === null || requestParameters.entryId === undefined) {
            throw new runtime.RequiredError('entryId','Required parameter requestParameters.entryId was null or undefined when calling updateAdjustedEntry.');
        }

        if (requestParameters.adjustedTimesheetUpadateEntryDTO === null || requestParameters.adjustedTimesheetUpadateEntryDTO === undefined) {
            throw new runtime.RequiredError('adjustedTimesheetUpadateEntryDTO','Required parameter requestParameters.adjustedTimesheetUpadateEntryDTO 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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/adjusted-timesheets/{timesheetId}/entries/{entryId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))).replace(`{${"entryId"}}`, encodeURIComponent(String(requestParameters.entryId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: AdjustedTimesheetUpadateEntryDTOToJSON(requestParameters.adjustedTimesheetUpadateEntryDTO),
        }, 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();
    }

    /**
     * Update client
     */
    async updateClientRaw(requestParameters: UpdateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
        if (requestParameters.clientId === null || requestParameters.clientId === undefined) {
            throw new runtime.RequiredError('clientId','Required parameter requestParameters.clientId was null or undefined when calling updateClient.');
        }

        if (requestParameters.clientDTO === null || requestParameters.clientDTO === undefined) {
            throw new runtime.RequiredError('clientDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/clients/{clientId}`.replace(`{${"clientId"}}`, encodeURIComponent(String(requestParameters.clientId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ClientDTOToJSON(requestParameters.clientDTO),
        }, 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();
    }

    /**
     * Update a company
     * Update a company by ID
     */
    async updateCompanyRaw(requestParameters: UpdateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
        if (requestParameters.companyId === null || requestParameters.companyId === undefined) {
            throw new runtime.RequiredError('companyId','Required parameter requestParameters.companyId was null or undefined when calling updateCompany.');
        }

        if (requestParameters.companyDTO === null || requestParameters.companyDTO === undefined) {
            throw new runtime.RequiredError('companyDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/companies/{companyId}`.replace(`{${"companyId"}}`, encodeURIComponent(String(requestParameters.companyId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: CompanyDTOToJSON(requestParameters.companyDTO),
        }, 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();
    }

    /**
     * Update an employee
     * Update an employee
     */
    async updateEmployeeDataRaw(requestParameters: UpdateEmployeeDataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmployeeDTO>> {
        if (requestParameters.employeeId === null || requestParameters.employeeId === undefined) {
            throw new runtime.RequiredError('employeeId','Required parameter requestParameters.employeeId was null or undefined when calling updateEmployeeData.');
        }

        if (requestParameters.employeeUpdateDTO === null || requestParameters.employeeUpdateDTO === undefined) {
            throw new runtime.RequiredError('employeeUpdateDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/employees/{employeeId}`.replace(`{${"employeeId"}}`, encodeURIComponent(String(requestParameters.employeeId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: EmployeeUpdateDTOToJSON(requestParameters.employeeUpdateDTO),
        }, 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();
    }

    /**
     * Update a global timesheet entry
     * Update a global timesheet entry
     */
    async updateGlobalTimesheetEntryRaw(requestParameters: UpdateGlobalTimesheetEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GlobalTimesheetEntryDTO>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling updateGlobalTimesheetEntry.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling updateGlobalTimesheetEntry.');
        }

        if (requestParameters.entryId === null || requestParameters.entryId === undefined) {
            throw new runtime.RequiredError('entryId','Required parameter requestParameters.entryId was null or undefined when calling updateGlobalTimesheetEntry.');
        }

        if (requestParameters.globalTimesheetEntryUpdateDTO === null || requestParameters.globalTimesheetEntryUpdateDTO === undefined) {
            throw new runtime.RequiredError('globalTimesheetEntryUpdateDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/global-timesheets/{timesheetId}/entries/{entryId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))).replace(`{${"entryId"}}`, encodeURIComponent(String(requestParameters.entryId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: GlobalTimesheetEntryUpdateDTOToJSON(requestParameters.globalTimesheetEntryUpdateDTO),
        }, 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();
    }

    /**
     * Update a project
     * Update a project by ID
     */
    async updateProjectRaw(requestParameters: UpdateProjectRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ProjectDTO>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling updateProject.');
        }

        if (requestParameters.projectUpdateDTO === null || requestParameters.projectUpdateDTO === undefined) {
            throw new runtime.RequiredError('projectUpdateDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ProjectUpdateDTOToJSON(requestParameters.projectUpdateDTO),
        }, 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();
    }

    /**
     * 
     */
    async updateSlackbotUserRaw(requestParameters: UpdateSlackbotUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SlackUserDto>> {
        if (requestParameters.userId === null || requestParameters.userId === undefined) {
            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling updateSlackbotUser.');
        }

        if (requestParameters.updateUserDto === null || requestParameters.updateUserDto === undefined) {
            throw new runtime.RequiredError('updateUserDto','Required parameter requestParameters.updateUserDto was null or undefined when calling updateSlackbotUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/slackbot-users/{userId}`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UpdateUserDtoToJSON(requestParameters.updateUserDto),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SlackUserDtoFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateSlackbotUser(requestParameters: UpdateSlackbotUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SlackUserDto> {
        const response = await this.updateSlackbotUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Update a project team
     * Update a project team
     */
    async updateTeamRaw(requestParameters: UpdateTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling updateTeam.');
        }

        if (requestParameters.teamUpdateDTO === null || requestParameters.teamUpdateDTO === undefined) {
            throw new runtime.RequiredError('teamUpdateDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/team`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: TeamUpdateDTOToJSON(requestParameters.teamUpdateDTO),
        }, 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);
    }

    /**
     * Update a timesheet entry
     * Update a timesheet entry
     */
    async updateTimesheetEntryRaw(requestParameters: UpdateTimesheetEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.projectId === null || requestParameters.projectId === undefined) {
            throw new runtime.RequiredError('projectId','Required parameter requestParameters.projectId was null or undefined when calling updateTimesheetEntry.');
        }

        if (requestParameters.timesheetId === null || requestParameters.timesheetId === undefined) {
            throw new runtime.RequiredError('timesheetId','Required parameter requestParameters.timesheetId was null or undefined when calling updateTimesheetEntry.');
        }

        if (requestParameters.entryId === null || requestParameters.entryId === undefined) {
            throw new runtime.RequiredError('entryId','Required parameter requestParameters.entryId was null or undefined when calling updateTimesheetEntry.');
        }

        if (requestParameters.timesheetEntryUpdateDTO === null || requestParameters.timesheetEntryUpdateDTO === undefined) {
            throw new runtime.RequiredError('timesheetEntryUpdateDTO','Required parameter requestParameters.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"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/projects/{projectId}/timesheets/{timesheetId}/entries/{entryId}`.replace(`{${"projectId"}}`, encodeURIComponent(String(requestParameters.projectId))).replace(`{${"timesheetId"}}`, encodeURIComponent(String(requestParameters.timesheetId))).replace(`{${"entryId"}}`, encodeURIComponent(String(requestParameters.entryId))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: TimesheetEntryUpdateDTOToJSON(requestParameters.timesheetEntryUpdateDTO),
        }, 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);
    }

    /**
     * Update user
     * Update a user by ID
     */
    async updateUserRaw(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserDTOSc>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateUser.');
        }

        if (requestParameters.userUpdateDTOSc === null || requestParameters.userUpdateDTOSc === undefined) {
            throw new runtime.RequiredError('userUpdateDTOSc','Required parameter requestParameters.userUpdateDTOSc was null or undefined when calling updateUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const response = await this.request({
            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UserUpdateDTOScToJSON(requestParameters.userUpdateDTOSc),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
    }

    /**
     * Update user
     * Update a user by ID
     */
    async updateUser(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
        const response = await this.updateUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * Upload template
     * Upload template
     */
    async uploadPdfTemplateRaw(requestParameters: UploadPdfTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PdfTemplateDTO>> {
        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling uploadPdfTemplate.');
        }

        if (requestParameters.name === null || requestParameters.name === undefined) {
            throw new runtime.RequiredError('name','Required parameter requestParameters.name was null or undefined when calling uploadPdfTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters.file !== undefined) {
            formParams.append('file', requestParameters.file as any);
        }

        if (requestParameters.name !== undefined) {
            formParams.append('name', requestParameters.name as any);
        }

        const response = await this.request({
            path: `/pdf-templates`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PdfTemplateDTOFromJSON(jsonValue));
    }

    /**
     * Upload template
     * Upload template
     */
    async uploadPdfTemplate(requestParameters: UploadPdfTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PdfTemplateDTO> {
        const response = await this.uploadPdfTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async uploadTemplateRaw(requestParameters: UploadTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EmailTemplates>> {
        if (requestParameters.name === null || requestParameters.name === undefined) {
            throw new runtime.RequiredError('name','Required parameter requestParameters.name was null or undefined when calling uploadTemplate.');
        }

        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling uploadTemplate.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        if (this.configuration && this.configuration.apiKey) {
            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
        }

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters.name !== undefined) {
            formParams.append('name', requestParameters.name as any);
        }

        if (requestParameters.file !== undefined) {
            formParams.append('file', requestParameters.file as any);
        }

        const response = await this.request({
            path: `/templates`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => EmailTemplatesFromJSON(jsonValue));
    }

    /**
     * 
     */
    async uploadTemplate(requestParameters: UploadTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmailTemplates> {
        const response = await this.uploadTemplateRaw(requestParameters, initOverrides);
        return await response.value();
    }

}

/**
 * @export
 */
export const EmployeesControllerGetCommitsByUserIdGroupByEnum = {
    HourOfDay: 'hourOfDay',
    Year: 'year',
    Month: 'month',
    Day: 'day'
} as const;
export type EmployeesControllerGetCommitsByUserIdGroupByEnum = typeof EmployeesControllerGetCommitsByUserIdGroupByEnum[keyof typeof EmployeesControllerGetCommitsByUserIdGroupByEnum];
/**
 * @export
 */
export const EmployeesControllerGetMyCommitsGroupByEnum = {
    HourOfDay: 'hourOfDay',
    Year: 'year',
    Month: 'month',
    Day: 'day'
} as const;
export type EmployeesControllerGetMyCommitsGroupByEnum = typeof EmployeesControllerGetMyCommitsGroupByEnum[keyof typeof EmployeesControllerGetMyCommitsGroupByEnum];