tuix-timesheets-api 0.6.1 → 0.6.2

package/apis/TuixTimesheetsClientApi.ts

@@ -15,121 +15,140 @@
 
 import * as runtime from '../runtime';
 import type {
-  ClientsGet200ResponseInner,
-  ClientsIdPatchRequest,
-  CompaniesGet200ResponseInner,
-  CompaniesIdPatchRequest,
-  CompaniesPostRequest,
-  EmailsSendPostRequest,
-  TemplatesPostRequest,
-  TestUsersGet200ResponseInner,
+  ClientDTO,
+  CompanyDTO,
+  CreateSubscriptionDTO,
+  EmailTemplates,
+  ErrorDTO,
+  SDKTestRequestDTO,
+  SDKTestResponseDTO,
+  SendNewsletterDto,
+  Subscription,
+  SubscriptionsSentResponseDto,
+  UserDTO,
+  UserDTOSc,
 } from '../models/index';
 import {
-    ClientsGet200ResponseInnerFromJSON,
-    ClientsGet200ResponseInnerToJSON,
-    ClientsIdPatchRequestFromJSON,
-    ClientsIdPatchRequestToJSON,
-    CompaniesGet200ResponseInnerFromJSON,
-    CompaniesGet200ResponseInnerToJSON,
-    CompaniesIdPatchRequestFromJSON,
-    CompaniesIdPatchRequestToJSON,
-    CompaniesPostRequestFromJSON,
-    CompaniesPostRequestToJSON,
-    EmailsSendPostRequestFromJSON,
-    EmailsSendPostRequestToJSON,
-    TemplatesPostRequestFromJSON,
-    TemplatesPostRequestToJSON,
-    TestUsersGet200ResponseInnerFromJSON,
-    TestUsersGet200ResponseInnerToJSON,
+    ClientDTOFromJSON,
+    ClientDTOToJSON,
+    CompanyDTOFromJSON,
+    CompanyDTOToJSON,
+    CreateSubscriptionDTOFromJSON,
+    CreateSubscriptionDTOToJSON,
+    EmailTemplatesFromJSON,
+    EmailTemplatesToJSON,
+    ErrorDTOFromJSON,
+    ErrorDTOToJSON,
+    SDKTestRequestDTOFromJSON,
+    SDKTestRequestDTOToJSON,
+    SDKTestResponseDTOFromJSON,
+    SDKTestResponseDTOToJSON,
+    SendNewsletterDtoFromJSON,
+    SendNewsletterDtoToJSON,
+    SubscriptionFromJSON,
+    SubscriptionToJSON,
+    SubscriptionsSentResponseDtoFromJSON,
+    SubscriptionsSentResponseDtoToJSON,
+    UserDTOFromJSON,
+    UserDTOToJSON,
+    UserDTOScFromJSON,
+    UserDTOScToJSON,
 } from '../models/index';
 
-export interface ClientsIdDeleteRequest {
+export interface AddUserToCompanyRequest {
     id: string;
+    userDTO: UserDTO;
 }
 
-export interface ClientsIdGetRequest {
-    id: string;
+export interface CreateClientRequest {
+    clientDTO: ClientDTO;
 }
 
-export interface ClientsIdPatchOperationRequest {
-    id: string;
-    clientsIdPatchRequest: ClientsIdPatchRequest;
+export interface CreateCompanyRequest {
+    companyDTO: CompanyDTO;
 }
 
-export interface ClientsPostRequest {
-    clientsGet200ResponseInner: ClientsGet200ResponseInner;
+export interface CreateSubscriptionRequest {
+    createSubscriptionDTO: CreateSubscriptionDTO;
 }
 
-export interface CompaniesIdDeleteRequest {
-    id: string;
+export interface CreateTestUserRequest {
+    userDTOSc: UserDTOSc;
 }
 
-export interface CompaniesIdGetRequest {
+export interface DeleteClientRequest {
     id: string;
 }
 
-export interface CompaniesIdPatchOperationRequest {
+export interface DeleteCompanyRequest {
     id: string;
-    companiesIdPatchRequest: CompaniesIdPatchRequest;
 }
 
-export interface CompaniesIdUserIdDeleteRequest {
+export interface DeleteSubscriptionRequest {
     id: string;
-    userId: string;
 }
 
-export interface CompaniesIdUsersGetRequest {
+export interface DeleteTestUserRequest {
     id: string;
 }
 
-export interface CompaniesIdUsersPostRequest {
+export interface GetClientByIdRequest {
     id: string;
-    body: object;
 }
 
-export interface CompaniesPostOperationRequest {
-    companiesPostRequest: CompaniesPostRequest;
+export interface GetCompanyByIdRequest {
+    id: string;
 }
 
-export interface EmailsSendPostOperationRequest {
-    emailsSendPostRequest: EmailsSendPostRequest;
+export interface GetTemplateByIdRequest {
+    id: string;
 }
 
-export interface SubscriptionsIdDeleteRequest {
+export interface GetTestUserByIdRequest {
     id: string;
 }
 
-export interface SubscriptionsNewsletterPostRequest {
-    body: object;
+export interface RemoveUserFromCompanyRequest {
+    id: string;
+    userId: string;
 }
 
-export interface SubscriptionsPostRequest {
-    body: object;
+export interface SdkTestRequest {
+    sDKTestRequestDTO: SDKTestRequestDTO;
 }
 
-export interface TemplatesIdGetRequest {
-    id: string;
+export interface SendEmailRequest {
+    from: string;
+    to: string;
+    subject: string;
+    templateUUID: string;
+    body?: string;
+    data?: string;
+    file?: Blob;
 }
 
-export interface TemplatesPostOperationRequest {
-    templatesPostRequest: TemplatesPostRequest;
+export interface SendNewsletterToSubscribersRequest {
+    sendNewsletterDto: SendNewsletterDto;
 }
 
-export interface TestUsersIdDeleteRequest {
+export interface UpdateClientRequest {
     id: string;
+    clientDTO: ClientDTO;
 }
 
-export interface TestUsersIdGetRequest {
+export interface UpdateCompanyRequest {
     id: string;
+    companyDTO: CompanyDTO;
 }
 
-export interface TestUsersIdPatchRequest {
+export interface UpdateTestUserRequest {
     id: string;
-    testUsersGet200ResponseInner: TestUsersGet200ResponseInner;
+    userDTOSc: UserDTOSc;
 }
 
-export interface TestUsersPostRequest {
-    testUsersGet200ResponseInner: TestUsersGet200ResponseInner;
+export interface UploadTemplateRequest {
+    name: string;
+    file: Blob;
 }
 
 /**
@@ -138,112 +157,129 @@ export interface TestUsersPostRequest {
 export class TuixTimesheetsClientApi extends runtime.BaseAPI {
 
     /**
-     * Get all clients
+     * Add a user to a company
+     * Add a user to a company
      */
-    async clientsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientsGet200ResponseInner>>> {
+    async addUserToCompanyRaw(requestParameters: AddUserToCompanyRequest, 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 addUserToCompany.');
+        }
+
+        if (requestParameters.userDTO === null || requestParameters.userDTO === undefined) {
+            throw new runtime.RequiredError('userDTO','Required parameter requestParameters.userDTO was null or undefined when calling addUserToCompany.');
+        }
+
         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: 'GET',
+            path: `/companies/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: UserDTOToJSON(requestParameters.userDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientsGet200ResponseInnerFromJSON));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get all clients
+     * Add a user to a company
+     * Add a user to a company
      */
-    async clientsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientsGet200ResponseInner>> {
-        const response = await this.clientsGetRaw(initOverrides);
-        return await response.value();
+    async addUserToCompany(requestParameters: AddUserToCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.addUserToCompanyRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Delete a client by ID
+     * Create client
      */
-    async clientsIdDeleteRaw(requestParameters: ClientsIdDeleteRequest, 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 clientsIdDelete.');
+    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/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/clients`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: ClientDTOToJSON(requestParameters.clientDTO),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * Delete a client by ID
+     * Create client
      */
-    async clientsIdDelete(requestParameters: ClientsIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.clientsIdDeleteRaw(requestParameters, initOverrides);
+    async createClient(requestParameters: CreateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.createClientRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Get a client by ID
+     * Create a company
+     * Creates a new company
      */
-    async clientsIdGetRaw(requestParameters: ClientsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientsGet200ResponseInner>> {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling clientsIdGet.');
+    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: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/companies`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: CompanyDTOToJSON(requestParameters.companyDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
     }
 
     /**
-     * Get a client by ID
+     * Create a company
+     * Creates a new company
      */
-    async clientsIdGet(requestParameters: ClientsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
-        const response = await this.clientsIdGetRaw(requestParameters, initOverrides);
+    async createCompany(requestParameters: CreateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
+        const response = await this.createCompanyRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update a client by ID
+     * 
      */
-    async clientsIdPatchRaw(requestParameters: ClientsIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientsGet200ResponseInner>> {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling clientsIdPatch.');
-        }
-
-        if (requestParameters.clientsIdPatchRequest === null || requestParameters.clientsIdPatchRequest === undefined) {
-            throw new runtime.RequiredError('clientsIdPatchRequest','Required parameter requestParameters.clientsIdPatchRequest was null or undefined when calling clientsIdPatch.');
+    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 = {};
@@ -252,35 +288,31 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
 
         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/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'PATCH',
+            path: `/subscriptions`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientsIdPatchRequestToJSON(requestParameters.clientsIdPatchRequest),
+            body: CreateSubscriptionDTOToJSON(requestParameters.createSubscriptionDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionFromJSON(jsonValue));
     }
 
     /**
-     * Update a client by ID
+     * 
      */
-    async clientsIdPatch(requestParameters: ClientsIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
-        const response = await this.clientsIdPatchRaw(requestParameters, initOverrides);
+    async createSubscription(requestParameters: CreateSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Subscription> {
+        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a new client
+     * Create user
      */
-    async clientsPostRaw(requestParameters: ClientsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientsGet200ResponseInner>> {
-        if (requestParameters.clientsGet200ResponseInner === null || requestParameters.clientsGet200ResponseInner === undefined) {
-            throw new runtime.RequiredError('clientsGet200ResponseInner','Required parameter requestParameters.clientsGet200ResponseInner was null or undefined when calling clientsPost.');
+    async createTestUserRaw(requestParameters: CreateTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserDTOSc>> {
+        if (requestParameters.userDTOSc === null || requestParameters.userDTOSc === undefined) {
+            throw new runtime.RequiredError('userDTOSc','Required parameter requestParameters.userDTOSc was null or undefined when calling createTestUser.');
         }
 
         const queryParameters: any = {};
@@ -289,33 +321,33 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
 
         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`,
+            path: `/test-users`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientsGet200ResponseInnerToJSON(requestParameters.clientsGet200ResponseInner),
+            body: UserDTOScToJSON(requestParameters.userDTOSc),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
     }
 
     /**
-     * Create a new client
+     * Create user
      */
-    async clientsPost(requestParameters: ClientsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
-        const response = await this.clientsPostRaw(requestParameters, initOverrides);
+    async createTestUser(requestParameters: CreateTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
+        const response = await this.createTestUserRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get all companies
+     * Delete client
      */
-    async companiesGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CompaniesGet200ResponseInner>>> {
+    async deleteClientRaw(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteClient.');
+        }
+
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -325,29 +357,30 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/companies`,
-            method: 'GET',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CompaniesGet200ResponseInnerFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * Get all companies
+     * Delete client
      */
-    async companiesGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CompaniesGet200ResponseInner>> {
-        const response = await this.companiesGetRaw(initOverrides);
+    async deleteClient(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.deleteClientRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Delete a company by ID
+     * Delete a company
+     * delete a company
      */
-    async companiesIdDeleteRaw(requestParameters: CompaniesIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async deleteCompanyRaw(requestParameters: DeleteCompanyRequest, 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 companiesIdDelete.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteCompany.');
         }
 
         const queryParameters: any = {};
@@ -369,97 +402,77 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
     }
 
     /**
-     * Delete a company by ID
+     * Delete a company
+     * delete a company
      */
-    async companiesIdDelete(requestParameters: CompaniesIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.companiesIdDeleteRaw(requestParameters, initOverrides);
+    async deleteCompany(requestParameters: DeleteCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteCompanyRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get a company by ID
+     * 
      */
-    async companiesIdGetRaw(requestParameters: CompaniesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompaniesGet200ResponseInner>> {
+    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 companiesIdGet.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSubscription.');
         }
 
         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/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get a company by ID
+     * 
      */
-    async companiesIdGet(requestParameters: CompaniesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
-        const response = await this.companiesIdGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async deleteSubscription(requestParameters: DeleteSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteSubscriptionRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Update a company by ID
+     * Delete user
      */
-    async companiesIdPatchRaw(requestParameters: CompaniesIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompaniesGet200ResponseInner>> {
+    async deleteTestUserRaw(requestParameters: DeleteTestUserRequest, 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 companiesIdPatch.');
-        }
-
-        if (requestParameters.companiesIdPatchRequest === null || requestParameters.companiesIdPatchRequest === undefined) {
-            throw new runtime.RequiredError('companiesIdPatchRequest','Required parameter requestParameters.companiesIdPatchRequest was null or undefined when calling companiesIdPatch.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteTestUser.');
         }
 
         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/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'PATCH',
+            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-            body: CompaniesIdPatchRequestToJSON(requestParameters.companiesIdPatchRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Update a company by ID
+     * Delete user
      */
-    async companiesIdPatch(requestParameters: CompaniesIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
-        const response = await this.companiesIdPatchRaw(requestParameters, initOverrides);
-        return await response.value();
+    async deleteTestUser(requestParameters: DeleteTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteTestUserRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Remove a user from a company
+     * Get client by id
      */
-    async companiesIdUserIdDeleteRaw(requestParameters: CompaniesIdUserIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async getClientByIdRaw(requestParameters: GetClientByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling companiesIdUserIdDelete.');
-        }
-
-        if (requestParameters.userId === null || requestParameters.userId === undefined) {
-            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling companiesIdUserIdDelete.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getClientById.');
         }
 
         const queryParameters: any = {};
@@ -471,30 +484,27 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/companies/{id}/{userId}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
-            method: 'DELETE',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * Remove a user from a company
+     * Get client by id
      */
-    async companiesIdUserIdDelete(requestParameters: CompaniesIdUserIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.companiesIdUserIdDeleteRaw(requestParameters, initOverrides);
+    async getClientById(requestParameters: GetClientByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.getClientByIdRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Get all users from a company
+     * Get all clients
      */
-    async companiesIdUsersGetRaw(requestParameters: CompaniesIdUsersGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<object>>> {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling companiesIdUsersGet.');
-        }
-
+    async getClientsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientDTO>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -504,250 +514,257 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/companies/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/clients`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse<any>(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientDTOFromJSON));
     }
 
     /**
-     * Get all users from a company
+     * Get all clients
      */
-    async companiesIdUsersGet(requestParameters: CompaniesIdUsersGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<object>> {
-        const response = await this.companiesIdUsersGetRaw(requestParameters, initOverrides);
+    async getClients(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientDTO>> {
+        const response = await this.getClientsRaw(initOverrides);
         return await response.value();
     }
 
     /**
-     * Add a user to a company
+     * Get all companies a user belongs to
+     * Get all companies a user belongs to
      */
-    async companiesIdUsersPostRaw(requestParameters: CompaniesIdUsersPostRequest, 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 companiesIdUsersPost.');
-        }
-
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling companiesIdUsersPost.');
-        }
-
+    async getCompaniesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CompanyDTO>>> {
         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/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'POST',
+            path: `/companies`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CompanyDTOFromJSON));
     }
 
     /**
-     * Add a user to a company
+     * Get all companies a user belongs to
+     * Get all companies a user belongs to
      */
-    async companiesIdUsersPost(requestParameters: CompaniesIdUsersPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.companiesIdUsersPostRaw(requestParameters, initOverrides);
+    async getCompanies(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CompanyDTO>> {
+        const response = await this.getCompaniesRaw(initOverrides);
+        return await response.value();
     }
 
     /**
-     * Creates a new company
+     * Get a company
+     * Get a company by ID
      */
-    async companiesPostRaw(requestParameters: CompaniesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompaniesGet200ResponseInner>> {
-        if (requestParameters.companiesPostRequest === null || requestParameters.companiesPostRequest === undefined) {
-            throw new runtime.RequiredError('companiesPostRequest','Required parameter requestParameters.companiesPostRequest was null or undefined when calling companiesPost.');
+    async getCompanyByIdRaw(requestParameters: GetCompanyByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getCompanyById.');
         }
 
         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',
+            path: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: CompaniesPostRequestToJSON(requestParameters.companiesPostRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
     }
 
     /**
-     * Creates a new company
+     * Get a company
+     * Get a company by ID
      */
-    async companiesPost(requestParameters: CompaniesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
-        const response = await this.companiesPostRaw(requestParameters, initOverrides);
+    async getCompanyById(requestParameters: GetCompanyByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
+        const response = await this.getCompanyByIdRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
+     * 
      */
-    async emailsSendPostRaw(requestParameters: EmailsSendPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.emailsSendPostRequest === null || requestParameters.emailsSendPostRequest === undefined) {
-            throw new runtime.RequiredError('emailsSendPostRequest','Required parameter requestParameters.emailsSendPostRequest was null or undefined when calling emailsSendPost.');
-        }
-
+    async getSubscriptionsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Subscription>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         const response = await this.request({
-            path: `/emails/send`,
-            method: 'POST',
+            path: `/subscriptions`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: EmailsSendPostRequestToJSON(requestParameters.emailsSendPostRequest),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubscriptionFromJSON));
     }
 
     /**
+     * 
      */
-    async emailsSendPost(requestParameters: EmailsSendPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.emailsSendPostRaw(requestParameters, initOverrides);
+    async getSubscriptions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Subscription>> {
+        const response = await this.getSubscriptionsRaw(initOverrides);
+        return await response.value();
     }
 
     /**
+     * 
      */
-    async subscriptionsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    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 = {};
 
         const response = await this.request({
-            path: `/subscriptions`,
+            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
+     * 
      */
-    async subscriptionsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.subscriptionsGetRaw(initOverrides);
+    async getTemplateById(requestParameters: GetTemplateByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.getTemplateByIdRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
+     * 
      */
-    async subscriptionsIdDeleteRaw(requestParameters: SubscriptionsIdDeleteRequest, 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 subscriptionsIdDelete.');
-        }
-
+    async getTemplatesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<EmailTemplates>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/templates`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(EmailTemplatesFromJSON));
     }
 
     /**
+     * 
      */
-    async subscriptionsIdDelete(requestParameters: SubscriptionsIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.subscriptionsIdDeleteRaw(requestParameters, initOverrides);
+    async getTemplates(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<EmailTemplates>> {
+        const response = await this.getTemplatesRaw(initOverrides);
+        return await response.value();
     }
 
     /**
+     * Get user by id
      */
-    async subscriptionsNewsletterPostRaw(requestParameters: SubscriptionsNewsletterPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling subscriptionsNewsletterPost.');
+    async getTestUserByIdRaw(requestParameters: GetTestUserByIdRequest, 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 getTestUserById.');
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         const response = await this.request({
-            path: `/subscriptions/newsletter`,
-            method: 'POST',
+            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
     }
 
     /**
+     * Get user by id
      */
-    async subscriptionsNewsletterPost(requestParameters: SubscriptionsNewsletterPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.subscriptionsNewsletterPostRaw(requestParameters, initOverrides);
+    async getTestUserById(requestParameters: GetTestUserByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
+        const response = await this.getTestUserByIdRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
+     * Get all users
      */
-    async subscriptionsPostRaw(requestParameters: SubscriptionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling subscriptionsPost.');
-        }
-
+    async getTestUsersRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UserDTOSc>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         const response = await this.request({
-            path: `/subscriptions`,
-            method: 'POST',
+            path: `/test-users`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UserDTOScFromJSON));
     }
 
     /**
+     * Get all users
      */
-    async subscriptionsPost(requestParameters: SubscriptionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.subscriptionsPostRaw(requestParameters, initOverrides);
+    async getTestUsers(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UserDTOSc>> {
+        const response = await this.getTestUsersRaw(initOverrides);
+        return await response.value();
     }
 
     /**
+     * Remove a user from a company
+     * Remove a user from a company
      */
-    async templatesGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async removeUserFromCompanyRaw(requestParameters: RemoveUserFromCompanyRequest, 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 removeUserFromCompany.');
+        }
+
+        if (requestParameters.userId === null || requestParameters.userId === undefined) {
+            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling removeUserFromCompany.');
+        }
+
         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',
+            path: `/companies/{id}/{userId}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
@@ -756,163 +773,259 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
     }
 
     /**
+     * Remove a user from a company
+     * Remove a user from a company
      */
-    async templatesGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.templatesGetRaw(initOverrides);
+    async removeUserFromCompany(requestParameters: RemoveUserFromCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.removeUserFromCompanyRaw(requestParameters, initOverrides);
     }
 
     /**
+     * 
      */
-    async templatesIdGetRaw(requestParameters: TemplatesIdGetRequest, 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 templatesIdGet.');
+    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: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/sdkTest`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: SDKTestRequestDTOToJSON(requestParameters.sDKTestRequestDTO),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SDKTestResponseDTOFromJSON(jsonValue));
     }
 
     /**
+     * 
      */
-    async templatesIdGet(requestParameters: TemplatesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.templatesIdGetRaw(requestParameters, initOverrides);
+    async sdkTest(requestParameters: SdkTestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SDKTestResponseDTO> {
+        const response = await this.sdkTestRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
+     * 
      */
-    async templatesPostRaw(requestParameters: TemplatesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.templatesPostRequest === null || requestParameters.templatesPostRequest === undefined) {
-            throw new runtime.RequiredError('templatesPostRequest','Required parameter requestParameters.templatesPostRequest was null or undefined when calling templatesPost.');
+    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 = {};
 
-        headerParameters['Content-Type'] = 'application/json';
+        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: `/templates`,
+            path: `/emails/send`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: TemplatesPostRequestToJSON(requestParameters.templatesPostRequest),
+            body: formParams,
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
     }
 
     /**
+     * 
      */
-    async templatesPost(requestParameters: TemplatesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.templatesPostRaw(requestParameters, initOverrides);
+    async sendEmail(requestParameters: SendEmailRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.sendEmailRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get all users
+     * 
      */
-    async testUsersGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<TestUsersGet200ResponseInner>>> {
+    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: `/test-users`,
-            method: 'GET',
+            path: `/subscriptions/newsletter`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: SendNewsletterDtoToJSON(requestParameters.sendNewsletterDto),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TestUsersGet200ResponseInnerFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionsSentResponseDtoFromJSON(jsonValue));
     }
 
     /**
-     * Get all users
+     * 
      */
-    async testUsersGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<TestUsersGet200ResponseInner>> {
-        const response = await this.testUsersGetRaw(initOverrides);
+    async sendNewsletterToSubscribers(requestParameters: SendNewsletterToSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionsSentResponseDto> {
+        const response = await this.sendNewsletterToSubscribersRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Delete user
+     * Update client
      */
-    async testUsersIdDeleteRaw(requestParameters: TestUsersIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async updateClientRaw(requestParameters: UpdateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientDTO>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling testUsersIdDelete.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id 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: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: ClientDTOToJSON(requestParameters.clientDTO),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * Delete user
+     * Update client
      */
-    async testUsersIdDelete(requestParameters: TestUsersIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.testUsersIdDeleteRaw(requestParameters, initOverrides);
+    async updateClient(requestParameters: UpdateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.updateClientRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Get user by id
+     * Update a company
+     * Update a company by ID
      */
-    async testUsersIdGetRaw(requestParameters: TestUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TestUsersGet200ResponseInner>> {
+    async updateCompanyRaw(requestParameters: UpdateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling testUsersIdGet.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id 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: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: CompanyDTOToJSON(requestParameters.companyDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TestUsersGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
     }
 
     /**
-     * Get user by id
+     * Update a company
+     * Update a company by ID
      */
-    async testUsersIdGet(requestParameters: TestUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TestUsersGet200ResponseInner> {
-        const response = await this.testUsersIdGetRaw(requestParameters, initOverrides);
+    async updateCompany(requestParameters: UpdateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
+        const response = await this.updateCompanyRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Update user
      */
-    async testUsersIdPatchRaw(requestParameters: TestUsersIdPatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TestUsersGet200ResponseInner>> {
+    async updateTestUserRaw(requestParameters: UpdateTestUserRequest, 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 testUsersIdPatch.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateTestUser.');
         }
 
-        if (requestParameters.testUsersGet200ResponseInner === null || requestParameters.testUsersGet200ResponseInner === undefined) {
-            throw new runtime.RequiredError('testUsersGet200ResponseInner','Required parameter requestParameters.testUsersGet200ResponseInner was null or undefined when calling testUsersIdPatch.');
+        if (requestParameters.userDTOSc === null || requestParameters.userDTOSc === undefined) {
+            throw new runtime.RequiredError('userDTOSc','Required parameter requestParameters.userDTOSc was null or undefined when calling updateTestUser.');
         }
 
         const queryParameters: any = {};
@@ -926,50 +1039,76 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: TestUsersGet200ResponseInnerToJSON(requestParameters.testUsersGet200ResponseInner),
+            body: UserDTOScToJSON(requestParameters.userDTOSc),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TestUsersGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
     }
 
     /**
      * Update user
      */
-    async testUsersIdPatch(requestParameters: TestUsersIdPatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TestUsersGet200ResponseInner> {
-        const response = await this.testUsersIdPatchRaw(requestParameters, initOverrides);
+    async updateTestUser(requestParameters: UpdateTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
+        const response = await this.updateTestUserRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create user
+     * 
      */
-    async testUsersPostRaw(requestParameters: TestUsersPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TestUsersGet200ResponseInner>> {
-        if (requestParameters.testUsersGet200ResponseInner === null || requestParameters.testUsersGet200ResponseInner === undefined) {
-            throw new runtime.RequiredError('testUsersGet200ResponseInner','Required parameter requestParameters.testUsersGet200ResponseInner was null or undefined when calling testUsersPost.');
+    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 = {};
 
-        headerParameters['Content-Type'] = 'application/json';
+        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: `/test-users`,
+            path: `/templates`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: TestUsersGet200ResponseInnerToJSON(requestParameters.testUsersGet200ResponseInner),
+            body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TestUsersGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => EmailTemplatesFromJSON(jsonValue));
     }
 
     /**
-     * Create user
+     * 
      */
-    async testUsersPost(requestParameters: TestUsersPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TestUsersGet200ResponseInner> {
-        const response = await this.testUsersPostRaw(requestParameters, initOverrides);
+    async uploadTemplate(requestParameters: UploadTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmailTemplates> {
+        const response = await this.uploadTemplateRaw(requestParameters, initOverrides);
         return await response.value();
     }