tuix-timesheets-api 0.5.23 → 0.6.0

package/apis/TuixTimesheetsClientApi.ts

@@ -15,140 +15,86 @@
 
 import * as runtime from '../runtime';
 import type {
-  ClientDTO,
-  CompanyDTO,
-  CreateSubscriptionDTO,
-  EmailTemplates,
-  ErrorDTO,
-  SDKTestRequestDTO,
-  SDKTestResponseDTO,
-  SendNewsletterDto,
-  Subscription,
-  SubscriptionsSentResponseDto,
-  UserDTO,
-  UserDTOSc,
+  ClientsGet200ResponseInner,
+  ClientsPost400Response,
+  CompaniesGet200ResponseInner,
+  CompaniesIdPatchRequest,
+  CompaniesPostRequest,
+  EmailsSendPostRequest,
+  TemplatesPostRequest,
 } from '../models/index';
 import {
-    ClientDTOFromJSON,
-    ClientDTOToJSON,
-    CompanyDTOFromJSON,
-    CompanyDTOToJSON,
-    CreateSubscriptionDTOFromJSON,
-    CreateSubscriptionDTOToJSON,
-    EmailTemplatesFromJSON,
-    EmailTemplatesToJSON,
-    ErrorDTOFromJSON,
-    ErrorDTOToJSON,
-    SDKTestRequestDTOFromJSON,
-    SDKTestRequestDTOToJSON,
-    SDKTestResponseDTOFromJSON,
-    SDKTestResponseDTOToJSON,
-    SendNewsletterDtoFromJSON,
-    SendNewsletterDtoToJSON,
-    SubscriptionFromJSON,
-    SubscriptionToJSON,
-    SubscriptionsSentResponseDtoFromJSON,
-    SubscriptionsSentResponseDtoToJSON,
-    UserDTOFromJSON,
-    UserDTOToJSON,
-    UserDTOScFromJSON,
-    UserDTOScToJSON,
+    ClientsGet200ResponseInnerFromJSON,
+    ClientsGet200ResponseInnerToJSON,
+    ClientsPost400ResponseFromJSON,
+    ClientsPost400ResponseToJSON,
+    CompaniesGet200ResponseInnerFromJSON,
+    CompaniesGet200ResponseInnerToJSON,
+    CompaniesIdPatchRequestFromJSON,
+    CompaniesIdPatchRequestToJSON,
+    CompaniesPostRequestFromJSON,
+    CompaniesPostRequestToJSON,
+    EmailsSendPostRequestFromJSON,
+    EmailsSendPostRequestToJSON,
+    TemplatesPostRequestFromJSON,
+    TemplatesPostRequestToJSON,
 } from '../models/index';
 
-export interface AddUserToCompanyRequest {
+export interface ClientsIdDeleteRequest {
     id: string;
-    userDTO: UserDTO;
 }
 
-export interface CreateClientRequest {
-    clientDTO: ClientDTO;
-}
-
-export interface CreateCompanyRequest {
-    companyDTO: CompanyDTO;
-}
-
-export interface CreateSubscriptionRequest {
-    createSubscriptionDTO: CreateSubscriptionDTO;
-}
-
-export interface CreateTestUserRequest {
-    userDTOSc: UserDTOSc;
-}
-
-export interface DeleteClientRequest {
+export interface ClientsIdGetRequest {
     id: string;
 }
 
-export interface DeleteCompanyRequest {
+export interface ClientsIdPatchRequest {
     id: string;
+    clientsGet200ResponseInner: ClientsGet200ResponseInner;
 }
 
-export interface DeleteSubscriptionRequest {
-    id: string;
+export interface ClientsPostRequest {
+    clientsGet200ResponseInner: ClientsGet200ResponseInner;
 }
 
-export interface DeleteTestUserRequest {
-    id: string;
+export interface CompaniesIdPatchOperationRequest {
+    companiesIdPatchRequest: CompaniesIdPatchRequest;
 }
 
-export interface GetClientByIdRequest {
-    id: string;
+export interface CompaniesIdUserIdDeleteRequest {
+    userId: string;
 }
 
-export interface GetCompanyByIdRequest {
-    id: string;
+export interface CompaniesIdUsersPostRequest {
+    body: object;
 }
 
-export interface GetTemplateByIdRequest {
-    id: string;
+export interface CompaniesPostOperationRequest {
+    companiesPostRequest: CompaniesPostRequest;
 }
 
-export interface GetTestUserByIdRequest {
-    id: string;
+export interface EmailsSendPostOperationRequest {
+    emailsSendPostRequest: EmailsSendPostRequest;
 }
 
-export interface RemoveUserFromCompanyRequest {
+export interface SubscriptionsIdDeleteRequest {
     id: string;
-    userId: 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 UpdateClientRequest {
-    id: string;
-    clientDTO: ClientDTO;
+export interface SubscriptionsNewsletterPostRequest {
+    body: object;
 }
 
-export interface UpdateCompanyRequest {
-    id: string;
-    companyDTO: CompanyDTO;
+export interface SubscriptionsPostRequest {
+    body: object;
 }
 
-export interface UpdateTestUserRequest {
+export interface TemplatesIdGetRequest {
     id: string;
-    userDTOSc: UserDTOSc;
 }
 
-export interface UploadTemplateRequest {
-    name: string;
-    file: Blob;
+export interface TemplatesPostOperationRequest {
+    templatesPostRequest: TemplatesPostRequest;
 }
 
 /**
@@ -157,129 +103,113 @@ export interface UploadTemplateRequest {
 export class TuixTimesheetsClientApi extends runtime.BaseAPI {
 
     /**
-     * Add a user to a company
-     * Add a user to a company
+     * Get all clients
      */
-    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.');
-        }
-
+    async clientsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientsGet200ResponseInner>>> {
         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: `/clients`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: UserDTOToJSON(requestParameters.userDTO),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientsGet200ResponseInnerFromJSON));
     }
 
     /**
-     * Add a user to a company
-     * Add a user to a company
+     * Get all clients
      */
-    async addUserToCompany(requestParameters: AddUserToCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.addUserToCompanyRaw(requestParameters, initOverrides);
+    async clientsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientsGet200ResponseInner>> {
+        const response = await this.clientsGetRaw(initOverrides);
+        return await response.value();
     }
 
     /**
-     * Create client
+     * Delete 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.');
+    async clientsIdDeleteRaw(requestParameters: ClientsIdDeleteRequest, 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 clientsIdDelete.');
         }
 
         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',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientDTOToJSON(requestParameters.clientDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
     }
 
     /**
-     * Create client
+     * Delete client
      */
-    async createClient(requestParameters: CreateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
-        const response = await this.createClientRaw(requestParameters, initOverrides);
+    async clientsIdDelete(requestParameters: ClientsIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
+        const response = await this.clientsIdDeleteRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create a company
-     * Creates a new company
+     * Get client by id
      */
-    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.');
+    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.');
         }
 
         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: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: CompanyDTOToJSON(requestParameters.companyDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
     }
 
     /**
-     * Create a company
-     * Creates a new company
+     * Get client by id
      */
-    async createCompany(requestParameters: CreateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
-        const response = await this.createCompanyRaw(requestParameters, initOverrides);
+    async clientsIdGet(requestParameters: ClientsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
+        const response = await this.clientsIdGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * 
+     * Update client
      */
-    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.');
+    async clientsIdPatchRaw(requestParameters: ClientsIdPatchRequest, 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.clientsGet200ResponseInner === null || requestParameters.clientsGet200ResponseInner === undefined) {
+            throw new runtime.RequiredError('clientsGet200ResponseInner','Required parameter requestParameters.clientsGet200ResponseInner was null or undefined when calling clientsIdPatch.');
         }
 
         const queryParameters: any = {};
@@ -288,31 +218,35 @@ 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: `/subscriptions`,
-            method: 'POST',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: CreateSubscriptionDTOToJSON(requestParameters.createSubscriptionDTO),
+            body: ClientsGet200ResponseInnerToJSON(requestParameters.clientsGet200ResponseInner),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
     }
 
     /**
-     * 
+     * Update client
      */
-    async createSubscription(requestParameters: CreateSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Subscription> {
-        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
+    async clientsIdPatch(requestParameters: ClientsIdPatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
+        const response = await this.clientsIdPatchRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Create user
+     * Create client
      */
-    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.');
+    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.');
         }
 
         const queryParameters: any = {};
@@ -321,33 +255,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: `/test-users`,
+            path: `/clients`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: UserDTOScToJSON(requestParameters.userDTOSc),
+            body: ClientsGet200ResponseInnerToJSON(requestParameters.clientsGet200ResponseInner),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
     }
 
     /**
-     * Create user
+     * Create client
      */
-    async createTestUser(requestParameters: CreateTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
-        const response = await this.createTestUserRaw(requestParameters, initOverrides);
+    async clientsPost(requestParameters: ClientsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
+        const response = await this.clientsPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Delete client
+     * Get all companies
      */
-    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.');
-        }
-
+    async companiesGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CompaniesGet200ResponseInner>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -357,32 +291,27 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/companies`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CompaniesGet200ResponseInnerFromJSON));
     }
 
     /**
-     * Delete client
+     * Get all companies
      */
-    async deleteClient(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
-        const response = await this.deleteClientRaw(requestParameters, initOverrides);
+    async companiesGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CompaniesGet200ResponseInner>> {
+        const response = await this.companiesGetRaw(initOverrides);
         return await response.value();
     }
 
     /**
-     * Delete a company
-     * delete a company
+     * Delete a company by ID
      */
-    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 deleteCompany.');
-        }
-
+    async companiesIdDeleteRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -392,7 +321,7 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/companies/{id}`,
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -402,109 +331,87 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
     }
 
     /**
-     * Delete a company
-     * delete a company
+     * Delete a company by ID
      */
-    async deleteCompany(requestParameters: DeleteCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.deleteCompanyRaw(requestParameters, initOverrides);
+    async companiesIdDelete(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.companiesIdDeleteRaw(initOverrides);
     }
 
     /**
-     * 
+     * Get a company by ID
      */
-    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.');
-        }
-
+    async companiesIdGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompaniesGet200ResponseInner>> {
         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
-     */
-    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 deleteTestUser.');
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
         }
 
-        const queryParameters: any = {};
-
-        const headerParameters: runtime.HTTPHeaders = {};
-
         const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/companies/{id}`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
     }
 
     /**
-     * Delete user
+     * Get a company by ID
      */
-    async deleteTestUser(requestParameters: DeleteTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.deleteTestUserRaw(requestParameters, initOverrides);
+    async companiesIdGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
+        const response = await this.companiesIdGetRaw(initOverrides);
+        return await response.value();
     }
 
     /**
-     * Get client by id
+     * Update a company by ID
      */
-    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 getClientById.');
+    async companiesIdPatchRaw(requestParameters: CompaniesIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompaniesGet200ResponseInner>> {
+        if (requestParameters.companiesIdPatchRequest === null || requestParameters.companiesIdPatchRequest === undefined) {
+            throw new runtime.RequiredError('companiesIdPatchRequest','Required parameter requestParameters.companiesIdPatchRequest was null or undefined when calling companiesIdPatch.');
         }
 
         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/{id}`,
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: CompaniesIdPatchRequestToJSON(requestParameters.companiesIdPatchRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
     }
 
     /**
-     * Get client by id
+     * Update a company by ID
      */
-    async getClientById(requestParameters: GetClientByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
-        const response = await this.getClientByIdRaw(requestParameters, initOverrides);
+    async companiesIdPatch(requestParameters: CompaniesIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
+        const response = await this.companiesIdPatchRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get all clients
+     * Remove a user from a company
      */
-    async getClientsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientDTO>>> {
+    async companiesIdUserIdDeleteRaw(requestParameters: CompaniesIdUserIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.userId === null || requestParameters.userId === undefined) {
+            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling companiesIdUserIdDelete.');
+        }
+
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -514,28 +421,26 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/clients`,
-            method: 'GET',
+            path: `/companies/{id}/{userId}`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientDTOFromJSON));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get all clients
+     * Remove a user from a company
      */
-    async getClients(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientDTO>> {
-        const response = await this.getClientsRaw(initOverrides);
-        return await response.value();
+    async companiesIdUserIdDelete(requestParameters: CompaniesIdUserIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.companiesIdUserIdDeleteRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get all companies a user belongs to
-     * Get all companies a user belongs to
+     * Get all users from a company
      */
-    async getCompaniesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CompanyDTO>>> {
+    async companiesIdUsersGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<object>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -545,225 +450,162 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/companies`,
+            path: `/companies/{id}/users`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CompanyDTOFromJSON));
+        return new runtime.JSONApiResponse<any>(response);
     }
 
     /**
-     * Get all companies a user belongs to
-     * Get all companies a user belongs to
+     * Get all users from a company
      */
-    async getCompanies(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CompanyDTO>> {
-        const response = await this.getCompaniesRaw(initOverrides);
+    async companiesIdUsersGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<object>> {
+        const response = await this.companiesIdUsersGetRaw(initOverrides);
         return await response.value();
     }
 
     /**
-     * Get a company
-     * Get a company by ID
+     * Add a user to a company
      */
-    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.');
+    async companiesIdUsersPostRaw(requestParameters: CompaniesIdUsersPostRequest, 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 companiesIdUsersPost.');
         }
 
         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: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
-    }
-
-    /**
-     * Get a company
-     * Get a company by ID
-     */
-    async getCompanyById(requestParameters: GetCompanyByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompanyDTO> {
-        const response = await this.getCompanyByIdRaw(requestParameters, 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',
+            path: `/companies/{id}/users`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: requestParameters.body as any,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubscriptionFromJSON));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * 
+     * Add a user to a company
      */
-    async getSubscriptions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Subscription>> {
-        const response = await this.getSubscriptionsRaw(initOverrides);
-        return await response.value();
+    async companiesIdUsersPost(requestParameters: CompaniesIdUsersPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.companiesIdUsersPostRaw(requestParameters, initOverrides);
     }
 
     /**
-     * 
+     * Creates a new company
      */
-    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.');
+    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.');
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        const response = await this.request({
-            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
+        headerParameters['Content-Type'] = 'application/json';
 
-        if (this.isJsonMime(response.headers.get('content-type'))) {
-            return new runtime.JSONApiResponse<string>(response);
-        } else {
-            return new runtime.TextApiResponse(response) as any;
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
         }
-    }
-
-    /**
-     * 
-     */
-    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 = {};
 
         const response = await this.request({
-            path: `/templates`,
-            method: 'GET',
+            path: `/companies`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: CompaniesPostRequestToJSON(requestParameters.companiesPostRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(EmailTemplatesFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
     }
 
     /**
-     * 
+     * Creates a new company
      */
-    async getTemplates(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<EmailTemplates>> {
-        const response = await this.getTemplatesRaw(initOverrides);
+    async companiesPost(requestParameters: CompaniesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
+        const response = await this.companiesPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get user by id
      */
-    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.');
+    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.');
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
         const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/emails/send`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: EmailsSendPostRequestToJSON(requestParameters.emailsSendPostRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get user by id
      */
-    async getTestUserById(requestParameters: GetTestUserByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
-        const response = await this.getTestUserByIdRaw(requestParameters, initOverrides);
-        return await response.value();
+    async emailsSendPost(requestParameters: EmailsSendPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.emailsSendPostRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get all users
      */
-    async getTestUsersRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UserDTOSc>>> {
+    async subscriptionsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/test-users`,
+            path: `/subscriptions`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UserDTOScFromJSON));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get all users
      */
-    async getTestUsers(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UserDTOSc>> {
-        const response = await this.getTestUsersRaw(initOverrides);
-        return await response.value();
+    async subscriptionsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.subscriptionsGetRaw(initOverrides);
     }
 
     /**
-     * Remove a user from a company
-     * Remove a user from a company
      */
-    async removeUserFromCompanyRaw(requestParameters: RemoveUserFromCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    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 removeUserFromCompany.');
-        }
-
-        if (requestParameters.userId === null || requestParameters.userId === undefined) {
-            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling removeUserFromCompany.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling subscriptionsIdDelete.');
         }
 
         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}/{userId}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
+            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -773,19 +615,16 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
     }
 
     /**
-     * Remove a user from a company
-     * Remove a user from a company
      */
-    async removeUserFromCompany(requestParameters: RemoveUserFromCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.removeUserFromCompanyRaw(requestParameters, initOverrides);
+    async subscriptionsIdDelete(requestParameters: SubscriptionsIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.subscriptionsIdDeleteRaw(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.');
+    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.');
         }
 
         const queryParameters: any = {};
@@ -795,116 +634,27 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         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`,
+            path: `/subscriptions/newsletter`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: formParams,
+            body: requestParameters.body as any,
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * 
      */
-    async sendEmail(requestParameters: SendEmailRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.sendEmailRaw(requestParameters, initOverrides);
+    async subscriptionsNewsletterPost(requestParameters: SubscriptionsNewsletterPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.subscriptionsNewsletterPostRaw(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.');
+    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.');
         }
 
         const queryParameters: any = {};
@@ -914,118 +664,77 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
         const response = await this.request({
-            path: `/subscriptions/newsletter`,
+            path: `/subscriptions`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: SendNewsletterDtoToJSON(requestParameters.sendNewsletterDto),
+            body: requestParameters.body as any,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionsSentResponseDtoFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * 
      */
-    async sendNewsletterToSubscribers(requestParameters: SendNewsletterToSubscribersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionsSentResponseDto> {
-        const response = await this.sendNewsletterToSubscribersRaw(requestParameters, initOverrides);
-        return await response.value();
+    async subscriptionsPost(requestParameters: SubscriptionsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.subscriptionsPostRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Update client
      */
-    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 updateClient.');
-        }
-
-        if (requestParameters.clientDTO === null || requestParameters.clientDTO === undefined) {
-            throw new runtime.RequiredError('clientDTO','Required parameter requestParameters.clientDTO was null or undefined when calling updateClient.');
-        }
-
+    async templatesGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         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: 'PATCH',
+            path: `/templates`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientDTOToJSON(requestParameters.clientDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Update client
      */
-    async updateClient(requestParameters: UpdateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
-        const response = await this.updateClientRaw(requestParameters, initOverrides);
-        return await response.value();
+    async templatesGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.templatesGetRaw(initOverrides);
     }
 
     /**
-     * Update a company
-     * Update a company by ID
      */
-    async updateCompanyRaw(requestParameters: UpdateCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompanyDTO>> {
+    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 updateCompany.');
-        }
-
-        if (requestParameters.companyDTO === null || requestParameters.companyDTO === undefined) {
-            throw new runtime.RequiredError('companyDTO','Required parameter requestParameters.companyDTO was null or undefined when calling updateCompany.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling templatesIdGet.');
         }
 
         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: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: CompanyDTOToJSON(requestParameters.companyDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyDTOFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * 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();
+    async templatesIdGet(requestParameters: TemplatesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.templatesIdGetRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Update user
      */
-    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 updateTestUser.');
-        }
-
-        if (requestParameters.userDTOSc === null || requestParameters.userDTOSc === undefined) {
-            throw new runtime.RequiredError('userDTOSc','Required parameter requestParameters.userDTOSc was null or undefined when calling updateTestUser.');
+    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.');
         }
 
         const queryParameters: any = {};
@@ -1034,82 +743,21 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
 
         headerParameters['Content-Type'] = 'application/json';
 
-        const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'PATCH',
-            headers: headerParameters,
-            query: queryParameters,
-            body: UserDTOScToJSON(requestParameters.userDTOSc),
-        }, initOverrides);
-
-        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
-    }
-
-    /**
-     * Update user
-     */
-    async updateTestUser(requestParameters: UpdateTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
-        const response = await this.updateTestUserRaw(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 = {};
-
-        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,
+            body: TemplatesPostRequestToJSON(requestParameters.templatesPostRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => EmailTemplatesFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * 
      */
-    async uploadTemplate(requestParameters: UploadTemplateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EmailTemplates> {
-        const response = await this.uploadTemplateRaw(requestParameters, initOverrides);
-        return await response.value();
+    async templatesPost(requestParameters: TemplatesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.templatesPostRaw(requestParameters, initOverrides);
     }
 
 }