tuix-timesheets-api 0.5.13 → 0.5.15

package/apis/TuixTimesheetsClientApi.ts

@@ -15,137 +15,137 @@
 
 import * as runtime from '../runtime';
 import type {
-  ClientsGet200ResponseInner,
-  ClientsPost400Response,
-  CompaniesGet200ResponseInner,
-  CompaniesIdPatchRequest,
-  CompaniesPostRequest,
-  SubscriptionsGet200ResponseInner,
-  SubscriptionsNewsletterPost201Response,
-  SubscriptionsNewsletterPostRequest,
-  SubscriptionsPostRequest,
-  TemplatesGet200ResponseInner,
-  TestUsersGet200ResponseInner,
+  ClientDTO,
+  Company,
+  CreateCompanyDTO,
+  CreateSubscriptionDTO,
+  EmailTemplates,
+  ErrorDTO,
+  SendNewsletterDto,
+  Subscription,
+  SubscriptionsSentResponseDto,
+  UpdateCompanyDto,
+  UserDTOSc,
 } from '../models/index';
 import {
-    ClientsGet200ResponseInnerFromJSON,
-    ClientsGet200ResponseInnerToJSON,
-    ClientsPost400ResponseFromJSON,
-    ClientsPost400ResponseToJSON,
-    CompaniesGet200ResponseInnerFromJSON,
-    CompaniesGet200ResponseInnerToJSON,
-    CompaniesIdPatchRequestFromJSON,
-    CompaniesIdPatchRequestToJSON,
-    CompaniesPostRequestFromJSON,
-    CompaniesPostRequestToJSON,
-    SubscriptionsGet200ResponseInnerFromJSON,
-    SubscriptionsGet200ResponseInnerToJSON,
-    SubscriptionsNewsletterPost201ResponseFromJSON,
-    SubscriptionsNewsletterPost201ResponseToJSON,
-    SubscriptionsNewsletterPostRequestFromJSON,
-    SubscriptionsNewsletterPostRequestToJSON,
-    SubscriptionsPostRequestFromJSON,
-    SubscriptionsPostRequestToJSON,
-    TemplatesGet200ResponseInnerFromJSON,
-    TemplatesGet200ResponseInnerToJSON,
-    TestUsersGet200ResponseInnerFromJSON,
-    TestUsersGet200ResponseInnerToJSON,
+    ClientDTOFromJSON,
+    ClientDTOToJSON,
+    CompanyFromJSON,
+    CompanyToJSON,
+    CreateCompanyDTOFromJSON,
+    CreateCompanyDTOToJSON,
+    CreateSubscriptionDTOFromJSON,
+    CreateSubscriptionDTOToJSON,
+    EmailTemplatesFromJSON,
+    EmailTemplatesToJSON,
+    ErrorDTOFromJSON,
+    ErrorDTOToJSON,
+    SendNewsletterDtoFromJSON,
+    SendNewsletterDtoToJSON,
+    SubscriptionFromJSON,
+    SubscriptionToJSON,
+    SubscriptionsSentResponseDtoFromJSON,
+    SubscriptionsSentResponseDtoToJSON,
+    UpdateCompanyDtoFromJSON,
+    UpdateCompanyDtoToJSON,
+    UserDTOScFromJSON,
+    UserDTOScToJSON,
 } from '../models/index';
 
-export interface ClientsIdDeleteRequest {
+export interface CompaniesControllerAddUserToCompanyRequest {
     id: string;
+    body: object;
 }
 
-export interface ClientsIdGetRequest {
-    id: string;
+export interface CompaniesControllerCreateRequest {
+    createCompanyDTO: CreateCompanyDTO;
 }
 
-export interface ClientsIdPatchRequest {
+export interface CompaniesControllerFindOneRequest {
     id: string;
-    clientsGet200ResponseInner: ClientsGet200ResponseInner;
 }
 
-export interface ClientsPostRequest {
-    clientsGet200ResponseInner: ClientsGet200ResponseInner;
+export interface CompaniesControllerGetCompanyUsersRequest {
+    id: string;
 }
 
-export interface CompaniesIdDeleteRequest {
+export interface CompaniesControllerRemoveRequest {
     id: string;
 }
 
-export interface CompaniesIdGetRequest {
+export interface CompaniesControllerRemoveUserFromCompanyRequest {
     id: string;
+    userId: string;
 }
 
-export interface CompaniesIdPatchOperationRequest {
+export interface CompaniesControllerUpdateRequest {
     id: string;
-    companiesIdPatchRequest: CompaniesIdPatchRequest;
+    updateCompanyDto: UpdateCompanyDto;
 }
 
-export interface CompaniesIdUserIdDeleteRequest {
-    id: string;
-    userId: string;
+export interface CreateClientRequest {
+    clientDTO: ClientDTO;
 }
 
-export interface CompaniesIdUsersGetRequest {
-    id: string;
+export interface CreateSubscriptionRequest {
+    createSubscriptionDTO: CreateSubscriptionDTO;
 }
 
-export interface CompaniesIdUsersPostRequest {
-    id: string;
-    body: object;
+export interface CreateTestUserRequest {
+    userDTOSc: UserDTOSc;
 }
 
-export interface CompaniesPostOperationRequest {
-    companiesPostRequest: CompaniesPostRequest;
+export interface DeleteClientRequest {
+    id: string;
 }
 
-export interface EmailsSendPostRequest {
-    from: string;
-    to: string;
-    subject: string;
-    templateUUID: string;
-    body?: string;
-    data?: string;
-    file?: Blob;
+export interface DeleteSubscriptionRequest {
+    id: string;
 }
 
-export interface SubscriptionsIdDeleteRequest {
+export interface DeleteTestUserRequest {
     id: string;
 }
 
-export interface SubscriptionsNewsletterPostOperationRequest {
-    subscriptionsNewsletterPostRequest: SubscriptionsNewsletterPostRequest;
+export interface GetClientByIdRequest {
+    id: string;
 }
 
-export interface SubscriptionsPostOperationRequest {
-    subscriptionsPostRequest: SubscriptionsPostRequest;
+export interface GetTemplateByIdRequest {
+    id: string;
 }
 
-export interface TemplatesIdGetRequest {
+export interface GetTestUserByIdRequest {
     id: string;
 }
 
-export interface TemplatesPostRequest {
-    name: string;
-    file: Blob;
+export interface SendEmailRequest {
+    from: string;
+    to: string;
+    subject: string;
+    templateUUID: string;
+    body?: string;
+    data?: string;
+    file?: Blob;
 }
 
-export interface TestUsersIdDeleteRequest {
-    id: string;
+export interface SendNewsletterToSubscribersRequest {
+    sendNewsletterDto: SendNewsletterDto;
 }
 
-export interface TestUsersIdGetRequest {
+export interface UpdateClientRequest {
     id: string;
+    clientDTO: ClientDTO;
 }
 
-export interface TestUsersIdPatchRequest {
+export interface UpdateTestUserRequest {
     id: string;
-    testUsersGet200ResponseInner: TestUsersGet200ResponseInner;
+    userDTOSc: UserDTOSc;
 }
 
-export interface TestUsersPostRequest {
-    testUsersGet200ResponseInner: TestUsersGet200ResponseInner;
+export interface UploadTemplateRequest {
+    name: string;
+    file: Blob;
 }
 
 /**
@@ -154,165 +154,154 @@ export interface TestUsersPostRequest {
 export class TuixTimesheetsClientApi extends runtime.BaseAPI {
 
     /**
-     * Get all clients
-     */
-    async clientsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientsGet200ResponseInner>>> {
-        const queryParameters: any = {};
-
-        const headerParameters: runtime.HTTPHeaders = {};
-
-        const response = await this.request({
-            path: `/clients`,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientsGet200ResponseInnerFromJSON));
-    }
-
-    /**
-     * Get all clients
-     */
-    async clientsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientsGet200ResponseInner>> {
-        const response = await this.clientsGetRaw(initOverrides);
-        return await response.value();
-    }
-
-    /**
-     * Delete client
+     * Add a user to a company
      */
-    async clientsIdDeleteRaw(requestParameters: ClientsIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ClientsGet200ResponseInner>> {
+    async companiesControllerAddUserToCompanyRaw(requestParameters: CompaniesControllerAddUserToCompanyRequest, 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.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling companiesControllerAddUserToCompany.');
+        }
+
+        if (requestParameters.body === null || requestParameters.body === undefined) {
+            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling companiesControllerAddUserToCompany.');
         }
 
         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: `/companies/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: requestParameters.body as any,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Delete client
+     * Add a user to a company
      */
-    async clientsIdDelete(requestParameters: ClientsIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
-        const response = await this.clientsIdDeleteRaw(requestParameters, initOverrides);
-        return await response.value();
+    async companiesControllerAddUserToCompany(requestParameters: CompaniesControllerAddUserToCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.companiesControllerAddUserToCompanyRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get client by id
+     * 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 companiesControllerCreateRaw(requestParameters: CompaniesControllerCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Company>> {
+        if (requestParameters.createCompanyDTO === null || requestParameters.createCompanyDTO === undefined) {
+            throw new runtime.RequiredError('createCompanyDTO','Required parameter requestParameters.createCompanyDTO was null or undefined when calling companiesControllerCreate.');
         }
 
         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: CreateCompanyDTOToJSON(requestParameters.createCompanyDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyFromJSON(jsonValue));
     }
 
     /**
-     * Get client by id
+     * Creates a new company
      */
-    async clientsIdGet(requestParameters: ClientsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
-        const response = await this.clientsIdGetRaw(requestParameters, initOverrides);
+    async companiesControllerCreate(requestParameters: CompaniesControllerCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Company> {
+        const response = await this.companiesControllerCreateRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Update client
+     * Get all companies
      */
-    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.');
-        }
-
+    async companiesControllerFindAllRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Company>>> {
         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: `/companies`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientsGet200ResponseInnerToJSON(requestParameters.clientsGet200ResponseInner),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CompanyFromJSON));
     }
 
     /**
-     * Update client
+     * Get all companies
      */
-    async clientsIdPatch(requestParameters: ClientsIdPatchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
-        const response = await this.clientsIdPatchRaw(requestParameters, initOverrides);
+    async companiesControllerFindAll(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Company>> {
+        const response = await this.companiesControllerFindAllRaw(initOverrides);
         return await response.value();
     }
 
     /**
-     * Create client
+     * Get a company by ID
      */
-    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 companiesControllerFindOneRaw(requestParameters: CompaniesControllerFindOneRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Company>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling companiesControllerFindOne.');
         }
 
         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: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientsGet200ResponseInnerToJSON(requestParameters.clientsGet200ResponseInner),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => ClientsGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyFromJSON(jsonValue));
     }
 
     /**
-     * Create client
+     * Get a company by ID
      */
-    async clientsPost(requestParameters: ClientsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientsGet200ResponseInner> {
-        const response = await this.clientsPostRaw(requestParameters, initOverrides);
+    async companiesControllerFindOne(requestParameters: CompaniesControllerFindOneRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Company> {
+        const response = await this.companiesControllerFindOneRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Get all companies
+     * Get all users from a company
      */
-    async companiesGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CompaniesGet200ResponseInner>>> {
+    async companiesControllerGetCompanyUsersRaw(requestParameters: CompaniesControllerGetCompanyUsersRequest, 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 companiesControllerGetCompanyUsers.');
+        }
+
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -322,29 +311,29 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/companies`,
+            path: `/companies/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CompaniesGet200ResponseInnerFromJSON));
+        return new runtime.JSONApiResponse<any>(response);
     }
 
     /**
-     * Get all companies
+     * Get all users from a company
      */
-    async companiesGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CompaniesGet200ResponseInner>> {
-        const response = await this.companiesGetRaw(initOverrides);
+    async companiesControllerGetCompanyUsers(requestParameters: CompaniesControllerGetCompanyUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<object>> {
+        const response = await this.companiesControllerGetCompanyUsersRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * Delete a company by ID
      */
-    async companiesIdDeleteRaw(requestParameters: CompaniesIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async companiesControllerRemoveRaw(requestParameters: CompaniesControllerRemoveRequest, 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 companiesControllerRemove.');
         }
 
         const queryParameters: any = {};
@@ -368,16 +357,20 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
     /**
      * Delete a company by ID
      */
-    async companiesIdDelete(requestParameters: CompaniesIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.companiesIdDeleteRaw(requestParameters, initOverrides);
+    async companiesControllerRemove(requestParameters: CompaniesControllerRemoveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.companiesControllerRemoveRaw(requestParameters, initOverrides);
     }
 
     /**
-     * Get a company by ID
+     * Remove a user from a company
      */
-    async companiesIdGetRaw(requestParameters: CompaniesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompaniesGet200ResponseInner>> {
+    async companiesControllerRemoveUserFromCompanyRaw(requestParameters: CompaniesControllerRemoveUserFromCompanyRequest, 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 companiesControllerRemoveUserFromCompany.');
+        }
+
+        if (requestParameters.userId === null || requestParameters.userId === undefined) {
+            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling companiesControllerRemoveUserFromCompany.');
         }
 
         const queryParameters: any = {};
@@ -389,33 +382,32 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            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);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * Get a company by ID
+     * Remove a user from a company
      */
-    async companiesIdGet(requestParameters: CompaniesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
-        const response = await this.companiesIdGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async companiesControllerRemoveUserFromCompany(requestParameters: CompaniesControllerRemoveUserFromCompanyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.companiesControllerRemoveUserFromCompanyRaw(requestParameters, initOverrides);
     }
 
     /**
      * Update a company by ID
      */
-    async companiesIdPatchRaw(requestParameters: CompaniesIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompaniesGet200ResponseInner>> {
+    async companiesControllerUpdateRaw(requestParameters: CompaniesControllerUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Company>> {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling companiesIdPatch.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling companiesControllerUpdate.');
         }
 
-        if (requestParameters.companiesIdPatchRequest === null || requestParameters.companiesIdPatchRequest === undefined) {
-            throw new runtime.RequiredError('companiesIdPatchRequest','Required parameter requestParameters.companiesIdPatchRequest was null or undefined when calling companiesIdPatch.');
+        if (requestParameters.updateCompanyDto === null || requestParameters.updateCompanyDto === undefined) {
+            throw new runtime.RequiredError('updateCompanyDto','Required parameter requestParameters.updateCompanyDto was null or undefined when calling companiesControllerUpdate.');
         }
 
         const queryParameters: any = {};
@@ -433,101 +425,92 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: CompaniesIdPatchRequestToJSON(requestParameters.companiesIdPatchRequest),
+            body: UpdateCompanyDtoToJSON(requestParameters.updateCompanyDto),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CompanyFromJSON(jsonValue));
     }
 
     /**
      * Update a company by ID
      */
-    async companiesIdPatch(requestParameters: CompaniesIdPatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
-        const response = await this.companiesIdPatchRaw(requestParameters, initOverrides);
+    async companiesControllerUpdate(requestParameters: CompaniesControllerUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Company> {
+        const response = await this.companiesControllerUpdateRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Remove a user from a company
+     * Create client
      */
-    async companiesIdUserIdDeleteRaw(requestParameters: CompaniesIdUserIdDeleteRequest, 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 companiesIdUserIdDelete.');
-        }
-
-        if (requestParameters.userId === null || requestParameters.userId === undefined) {
-            throw new runtime.RequiredError('userId','Required parameter requestParameters.userId was null or undefined when calling companiesIdUserIdDelete.');
+    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 = {};
 
-        if (this.configuration && this.configuration.apiKey) {
-            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
-        }
+        headerParameters['Content-Type'] = 'application/json';
 
         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`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: ClientDTOToJSON(requestParameters.clientDTO),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * Remove a user from a company
+     * Create client
      */
-    async companiesIdUserIdDelete(requestParameters: CompaniesIdUserIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.companiesIdUserIdDeleteRaw(requestParameters, initOverrides);
+    async createClient(requestParameters: CreateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.createClientRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Get all users from a company
+     * 
      */
-    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 createSubscriptionRaw(requestParameters: CreateSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Subscription>> {
+        if (requestParameters.createSubscriptionDTO === null || requestParameters.createSubscriptionDTO === undefined) {
+            throw new runtime.RequiredError('createSubscriptionDTO','Required parameter requestParameters.createSubscriptionDTO was null or undefined when calling createSubscription.');
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (this.configuration && this.configuration.apiKey) {
-            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
-        }
+        headerParameters['Content-Type'] = 'application/json';
 
         const response = await this.request({
-            path: `/companies/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/subscriptions`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: CreateSubscriptionDTOToJSON(requestParameters.createSubscriptionDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse<any>(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionFromJSON(jsonValue));
     }
 
     /**
-     * Get all users from a company
+     * 
      */
-    async companiesIdUsersGet(requestParameters: CompaniesIdUsersGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<object>> {
-        const response = await this.companiesIdUsersGetRaw(requestParameters, initOverrides);
+    async createSubscription(requestParameters: CreateSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Subscription> {
+        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Add a user to a company
+     * Create user
      */
-    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 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 = {};
@@ -536,276 +519,233 @@ 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: `/companies/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/test-users`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
+            body: UserDTOScToJSON(requestParameters.userDTOSc),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
     }
 
     /**
-     * Add a user to a company
+     * Create user
      */
-    async companiesIdUsersPost(requestParameters: CompaniesIdUsersPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.companiesIdUsersPostRaw(requestParameters, initOverrides);
+    async createTestUser(requestParameters: CreateTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserDTOSc> {
+        const response = await this.createTestUserRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * Creates a new company
+     * Delete client
      */
-    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 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 = {};
 
-        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: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-            body: CompaniesPostRequestToJSON(requestParameters.companiesPostRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CompaniesGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * Creates a new company
+     * Delete client
      */
-    async companiesPost(requestParameters: CompaniesPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompaniesGet200ResponseInner> {
-        const response = await this.companiesPostRaw(requestParameters, initOverrides);
+    async deleteClient(requestParameters: DeleteClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.deleteClientRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * 
      */
-    async emailsSendPostRaw(requestParameters: EmailsSendPostRequest, 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 emailsSendPost.');
-        }
-
-        if (requestParameters.to === null || requestParameters.to === undefined) {
-            throw new runtime.RequiredError('to','Required parameter requestParameters.to was null or undefined when calling emailsSendPost.');
-        }
-
-        if (requestParameters.subject === null || requestParameters.subject === undefined) {
-            throw new runtime.RequiredError('subject','Required parameter requestParameters.subject was null or undefined when calling emailsSendPost.');
-        }
-
-        if (requestParameters.templateUUID === null || requestParameters.templateUUID === undefined) {
-            throw new runtime.RequiredError('templateUUID','Required parameter requestParameters.templateUUID was null or undefined when calling emailsSendPost.');
+    async deleteSubscriptionRaw(requestParameters: DeleteSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling deleteSubscription.');
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        const 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);
-        }
+        const response = await this.request({
+            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
 
-        if (requestParameters.subject !== undefined) {
-            formParams.append('subject', requestParameters.subject as any);
-        }
+        return new runtime.VoidApiResponse(response);
+    }
 
-        if (requestParameters.body !== undefined) {
-            formParams.append('body', requestParameters.body as any);
-        }
+    /**
+     * 
+     */
+    async deleteSubscription(requestParameters: DeleteSubscriptionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteSubscriptionRaw(requestParameters, initOverrides);
+    }
 
-        if (requestParameters.data !== undefined) {
-            formParams.append('data', requestParameters.data as any);
+    /**
+     * 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 (requestParameters.templateUUID !== undefined) {
-            formParams.append('templateUUID', requestParameters.templateUUID as any);
-        }
+        const queryParameters: any = {};
 
-        if (requestParameters.file !== undefined) {
-            formParams.append('file', requestParameters.file as any);
-        }
+        const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/emails/send`,
-            method: 'POST',
+            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-            body: formParams,
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
     }
 
     /**
-     * 
+     * Delete user
      */
-    async emailsSendPost(requestParameters: EmailsSendPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.emailsSendPostRaw(requestParameters, initOverrides);
+    async deleteTestUser(requestParameters: DeleteTestUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteTestUserRaw(requestParameters, initOverrides);
     }
 
     /**
-     * 
+     * Get client by id
      */
-    async subscriptionsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<SubscriptionsGet200ResponseInner>>> {
+    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.');
+        }
+
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/subscriptions`,
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubscriptionsGet200ResponseInnerFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * 
+     * Get client by id
      */
-    async subscriptionsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<SubscriptionsGet200ResponseInner>> {
-        const response = await this.subscriptionsGetRaw(initOverrides);
+    async getClientById(requestParameters: GetClientByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.getClientByIdRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * 
+     * Get all clients
      */
-    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 getClientsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ClientDTO>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/clients`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ClientDTOFromJSON));
     }
 
     /**
-     * 
+     * Get all clients
      */
-    async subscriptionsIdDelete(requestParameters: SubscriptionsIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.subscriptionsIdDeleteRaw(requestParameters, initOverrides);
+    async getClients(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ClientDTO>> {
+        const response = await this.getClientsRaw(initOverrides);
+        return await response.value();
     }
 
     /**
      * 
      */
-    async subscriptionsNewsletterPostRaw(requestParameters: SubscriptionsNewsletterPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscriptionsNewsletterPost201Response>> {
-        if (requestParameters.subscriptionsNewsletterPostRequest === null || requestParameters.subscriptionsNewsletterPostRequest === undefined) {
-            throw new runtime.RequiredError('subscriptionsNewsletterPostRequest','Required parameter requestParameters.subscriptionsNewsletterPostRequest was null or undefined when calling subscriptionsNewsletterPost.');
-        }
-
+    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: `/subscriptions/newsletter`,
-            method: 'POST',
+            path: `/subscriptions`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: SubscriptionsNewsletterPostRequestToJSON(requestParameters.subscriptionsNewsletterPostRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionsNewsletterPost201ResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SubscriptionFromJSON));
     }
 
     /**
      * 
      */
-    async subscriptionsNewsletterPost(requestParameters: SubscriptionsNewsletterPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionsNewsletterPost201Response> {
-        const response = await this.subscriptionsNewsletterPostRaw(requestParameters, initOverrides);
+    async getSubscriptions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Subscription>> {
+        const response = await this.getSubscriptionsRaw(initOverrides);
         return await response.value();
     }
 
     /**
      * 
      */
-    async subscriptionsPostRaw(requestParameters: SubscriptionsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubscriptionsGet200ResponseInner>> {
-        if (requestParameters.subscriptionsPostRequest === null || requestParameters.subscriptionsPostRequest === undefined) {
-            throw new runtime.RequiredError('subscriptionsPostRequest','Required parameter requestParameters.subscriptionsPostRequest was null or undefined when calling subscriptionsPost.');
+    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 = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
         const response = await this.request({
-            path: `/subscriptions`,
-            method: 'POST',
+            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: SubscriptionsPostRequestToJSON(requestParameters.subscriptionsPostRequest),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionsGet200ResponseInnerFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
      * 
      */
-    async subscriptionsPost(requestParameters: SubscriptionsPostOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SubscriptionsGet200ResponseInner> {
-        const response = await this.subscriptionsPostRaw(requestParameters, initOverrides);
+    async getTemplateById(requestParameters: GetTemplateByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.getTemplateByIdRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
      * 
      */
-    async templatesGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<TemplatesGet200ResponseInner>>> {
+    async getTemplatesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<EmailTemplates>>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -817,23 +757,23 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(TemplatesGet200ResponseInnerFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(EmailTemplatesFromJSON));
     }
 
     /**
      * 
      */
-    async templatesGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<TemplatesGet200ResponseInner>> {
-        const response = await this.templatesGetRaw(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 templatesIdGetRaw(requestParameters: TemplatesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+    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 templatesIdGet.');
+            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling getTestUserById.');
         }
 
         const queryParameters: any = {};
@@ -841,37 +781,67 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
 
-        if (this.isJsonMime(response.headers.get('content-type'))) {
-            return new runtime.JSONApiResponse<string>(response);
-        } else {
-            return new runtime.TextApiResponse(response) as any;
-        }
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserDTOScFromJSON(jsonValue));
     }
 
     /**
-     * 
+     * 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();
+    }
+
+    /**
+     * Get all users
+     */
+    async getTestUsersRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UserDTOSc>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/test-users`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UserDTOScFromJSON));
+    }
+
+    /**
+     * Get all users
      */
-    async templatesIdGet(requestParameters: TemplatesIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
-        const response = await this.templatesIdGetRaw(requestParameters, initOverrides);
+    async getTestUsers(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UserDTOSc>> {
+        const response = await this.getTestUsersRaw(initOverrides);
         return await response.value();
     }
 
     /**
      * 
      */
-    async templatesPostRaw(requestParameters: TemplatesPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TemplatesGet200ResponseInner>> {
-        if (requestParameters.name === null || requestParameters.name === undefined) {
-            throw new runtime.RequiredError('name','Required parameter requestParameters.name 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.file === null || requestParameters.file === undefined) {
-            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling templatesPost.');
+        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 = {};
@@ -894,8 +864,28 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.name !== undefined) {
-            formParams.append('name', requestParameters.name as any);
+        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) {
@@ -903,119 +893,103 @@ export class TuixTimesheetsClientApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/templates`,
+            path: `/emails/send`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: formParams,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TemplatesGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
 
     /**
      * 
      */
-    async templatesPost(requestParameters: TemplatesPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TemplatesGet200ResponseInner> {
-        const response = await this.templatesPostRaw(requestParameters, initOverrides);
-        return await response.value();
+    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.');
         }
 
-        const queryParameters: any = {};
-
-        const headerParameters: runtime.HTTPHeaders = {};
-
-        const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-
-        return new runtime.VoidApiResponse(response);
-    }
-
-    /**
-     * Delete user
-     */
-    async testUsersIdDelete(requestParameters: TestUsersIdDeleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.testUsersIdDeleteRaw(requestParameters, initOverrides);
-    }
-
-    /**
-     * Get user by id
-     */
-    async testUsersIdGetRaw(requestParameters: TestUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TestUsersGet200ResponseInner>> {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling testUsersIdGet.');
+        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';
+
         const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: ClientDTOToJSON(requestParameters.clientDTO),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => TestUsersGet200ResponseInnerFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => ClientDTOFromJSON(jsonValue));
     }
 
     /**
-     * Get user by id
+     * Update client
      */
-    async testUsersIdGet(requestParameters: TestUsersIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TestUsersGet200ResponseInner> {
-        const response = await this.testUsersIdGetRaw(requestParameters, initOverrides);
+    async updateClient(requestParameters: UpdateClientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClientDTO> {
+        const response = await this.updateClientRaw(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 = {};
@@ -1029,50 +1003,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();
     }