tuix-timesheets-api 0.6.1 → 0.7.0

package/apis/TuixTimesheetsClientApi.js

@@ -44,91 +44,74 @@ const index_1 = require("../models/index");
  */
 class TuixTimesheetsClientApi extends runtime.BaseAPI {
     /**
-     * Get all clients
-     */
-    async clientsGetRaw(initOverrides) {
-        const queryParameters = {};
-        const headerParameters = {};
-        if (this.configuration && this.configuration.apiKey) {
-            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
-        }
-        const response = await this.request({
-            path: `/clients`,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.ClientsGet200ResponseInnerFromJSON));
-    }
-    /**
-     * Get all clients
-     */
-    async clientsGet(initOverrides) {
-        const response = await this.clientsGetRaw(initOverrides);
-        return await response.value();
-    }
-    /**
-     * Delete a client by ID
+     * Add a user to a company
+     * Add a user to a company
      */
-    async clientsIdDeleteRaw(requestParameters, initOverrides) {
+    async addUserToCompanyRaw(requestParameters, initOverrides) {
         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 addUserToCompany.');
+        }
+        if (requestParameters.userDTO === null || requestParameters.userDTO === undefined) {
+            throw new runtime.RequiredError('userDTO', 'Required parameter requestParameters.userDTO was null or undefined when calling addUserToCompany.');
         }
         const queryParameters = {};
         const headerParameters = {};
+        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: (0, index_1.UserDTOToJSON)(requestParameters.userDTO),
         }, initOverrides);
         return new runtime.VoidApiResponse(response);
     }
     /**
-     * Delete a client by ID
+     * Add a user to a company
+     * Add a user to a company
      */
-    async clientsIdDelete(requestParameters, initOverrides) {
-        await this.clientsIdDeleteRaw(requestParameters, initOverrides);
+    async addUserToCompany(requestParameters, initOverrides) {
+        await this.addUserToCompanyRaw(requestParameters, initOverrides);
     }
     /**
-     * Get a client by ID
+     * Create client
      */
-    async clientsIdGetRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling clientsIdGet.');
+    async createClientRaw(requestParameters, initOverrides) {
+        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 = {};
         const headerParameters = {};
+        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: `/clients`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.ClientDTOToJSON)(requestParameters.clientDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientsGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
     }
     /**
-     * Get a client by ID
+     * Create client
      */
-    async clientsIdGet(requestParameters, initOverrides) {
-        const response = await this.clientsIdGetRaw(requestParameters, initOverrides);
+    async createClient(requestParameters, initOverrides) {
+        const response = await this.createClientRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Update a client by ID
+     * Create a company
+     * Creates a new company
      */
-    async clientsIdPatchRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling clientsIdPatch.');
-        }
-        if (requestParameters.clientsIdPatchRequest === null || requestParameters.clientsIdPatchRequest === undefined) {
-            throw new runtime.RequiredError('clientsIdPatchRequest', 'Required parameter requestParameters.clientsIdPatchRequest was null or undefined when calling clientsIdPatch.');
+    async createCompanyRaw(requestParameters, initOverrides) {
+        if (requestParameters.companyDTO === null || requestParameters.companyDTO === undefined) {
+            throw new runtime.RequiredError('companyDTO', 'Required parameter requestParameters.companyDTO was null or undefined when calling createCompany.');
         }
         const queryParameters = {};
         const headerParameters = {};
@@ -137,80 +120,82 @@ class TuixTimesheetsClientApi extends runtime.BaseAPI {
             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: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.ClientsIdPatchRequestToJSON)(requestParameters.clientsIdPatchRequest),
+            body: (0, index_1.CompanyDTOToJSON)(requestParameters.companyDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientsGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompanyDTOFromJSON)(jsonValue));
     }
     /**
-     * Update a client by ID
+     * Create a company
+     * Creates a new company
      */
-    async clientsIdPatch(requestParameters, initOverrides) {
-        const response = await this.clientsIdPatchRaw(requestParameters, initOverrides);
+    async createCompany(requestParameters, initOverrides) {
+        const response = await this.createCompanyRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Create a new client
+     *
      */
-    async clientsPostRaw(requestParameters, initOverrides) {
-        if (requestParameters.clientsGet200ResponseInner === null || requestParameters.clientsGet200ResponseInner === undefined) {
-            throw new runtime.RequiredError('clientsGet200ResponseInner', 'Required parameter requestParameters.clientsGet200ResponseInner was null or undefined when calling clientsPost.');
+    async createSubscriptionRaw(requestParameters, initOverrides) {
+        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 = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
-        if (this.configuration && this.configuration.apiKey) {
-            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
-        }
         const response = await this.request({
-            path: `/clients`,
+            path: `/subscriptions`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.ClientsGet200ResponseInnerToJSON)(requestParameters.clientsGet200ResponseInner),
+            body: (0, index_1.CreateSubscriptionDTOToJSON)(requestParameters.createSubscriptionDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientsGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SubscriptionFromJSON)(jsonValue));
     }
     /**
-     * Create a new client
+     *
      */
-    async clientsPost(requestParameters, initOverrides) {
-        const response = await this.clientsPostRaw(requestParameters, initOverrides);
+    async createSubscription(requestParameters, initOverrides) {
+        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Get all companies
+     * Delete client
      */
-    async companiesGetRaw(initOverrides) {
+    async deleteClientRaw(requestParameters, initOverrides) {
+        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 = {};
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
         }
         const response = await this.request({
-            path: `/companies`,
-            method: 'GET',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.CompaniesGet200ResponseInnerFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
     }
     /**
-     * Get all companies
+     * Delete client
      */
-    async companiesGet(initOverrides) {
-        const response = await this.companiesGetRaw(initOverrides);
+    async deleteClient(requestParameters, initOverrides) {
+        const response = await this.deleteClientRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Delete a company by ID
+     * Delete a company
+     * delete a company
      */
-    async companiesIdDeleteRaw(requestParameters, initOverrides) {
+    async deleteCompanyRaw(requestParameters, initOverrides) {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling companiesIdDelete.');
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling deleteCompany.');
         }
         const queryParameters = {};
         const headerParameters = {};
@@ -226,237 +211,230 @@ class TuixTimesheetsClientApi extends runtime.BaseAPI {
         return new runtime.VoidApiResponse(response);
     }
     /**
-     * Delete a company by ID
+     * Delete a company
+     * delete a company
      */
-    async companiesIdDelete(requestParameters, initOverrides) {
-        await this.companiesIdDeleteRaw(requestParameters, initOverrides);
+    async deleteCompany(requestParameters, initOverrides) {
+        await this.deleteCompanyRaw(requestParameters, initOverrides);
     }
     /**
-     * Get a company by ID
+     *
      */
-    async companiesIdGetRaw(requestParameters, initOverrides) {
+    async deleteSubscriptionRaw(requestParameters, initOverrides) {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling companiesIdGet.');
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling deleteSubscription.');
         }
         const queryParameters = {};
         const headerParameters = {};
-        if (this.configuration && this.configuration.apiKey) {
-            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
-        }
         const response = await this.request({
-            path: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompaniesGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     * Get a company by ID
+     *
      */
-    async companiesIdGet(requestParameters, initOverrides) {
-        const response = await this.companiesIdGetRaw(requestParameters, initOverrides);
-        return await response.value();
+    async deleteSubscription(requestParameters, initOverrides) {
+        await this.deleteSubscriptionRaw(requestParameters, initOverrides);
     }
     /**
-     * Update a company by ID
+     * Get client by id
      */
-    async companiesIdPatchRaw(requestParameters, initOverrides) {
+    async getClientByIdRaw(requestParameters, initOverrides) {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling companiesIdPatch.');
-        }
-        if (requestParameters.companiesIdPatchRequest === null || requestParameters.companiesIdPatchRequest === undefined) {
-            throw new runtime.RequiredError('companiesIdPatchRequest', 'Required parameter requestParameters.companiesIdPatchRequest was null or undefined when calling companiesIdPatch.');
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling getClientById.');
         }
         const queryParameters = {};
         const headerParameters = {};
-        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: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CompaniesIdPatchRequestToJSON)(requestParameters.companiesIdPatchRequest),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompaniesGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
     }
     /**
-     * Update a company by ID
+     * Get client by id
      */
-    async companiesIdPatch(requestParameters, initOverrides) {
-        const response = await this.companiesIdPatchRaw(requestParameters, initOverrides);
+    async getClientById(requestParameters, initOverrides) {
+        const response = await this.getClientByIdRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Remove a user from a company
+     * Get all clients
      */
-    async companiesIdUserIdDeleteRaw(requestParameters, initOverrides) {
-        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 getClientsRaw(initOverrides) {
         const queryParameters = {};
         const headerParameters = {};
         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))),
-            method: 'DELETE',
+            path: `/clients`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.ClientDTOFromJSON));
     }
     /**
-     * Remove a user from a company
+     * Get all clients
      */
-    async companiesIdUserIdDelete(requestParameters, initOverrides) {
-        await this.companiesIdUserIdDeleteRaw(requestParameters, initOverrides);
+    async getClients(initOverrides) {
+        const response = await this.getClientsRaw(initOverrides);
+        return await response.value();
     }
     /**
-     * Get all users from a company
+     * Get all companies a user belongs to
+     * Get all companies a user belongs to
      */
-    async companiesIdUsersGetRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling companiesIdUsersGet.');
-        }
+    async getCompaniesRaw(initOverrides) {
         const queryParameters = {};
         const headerParameters = {};
         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: `/companies`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.CompanyDTOFromJSON));
     }
     /**
-     * Get all users from a company
+     * Get all companies a user belongs to
+     * Get all companies a user belongs to
      */
-    async companiesIdUsersGet(requestParameters, initOverrides) {
-        const response = await this.companiesIdUsersGetRaw(requestParameters, initOverrides);
+    async getCompanies(initOverrides) {
+        const response = await this.getCompaniesRaw(initOverrides);
         return await response.value();
     }
     /**
-     * Add a user to a company
+     * Get a company
+     * Get a company by ID
      */
-    async companiesIdUsersPostRaw(requestParameters, initOverrides) {
+    async getCompanyByIdRaw(requestParameters, initOverrides) {
         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.');
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling getCompanyById.');
         }
         const queryParameters = {};
         const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
         }
         const response = await this.request({
-            path: `/companies/{id}/users`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'POST',
+            path: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body,
         }, initOverrides);
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompanyDTOFromJSON)(jsonValue));
     }
     /**
-     * Add a user to a company
+     * Get a company
+     * Get a company by ID
      */
-    async companiesIdUsersPost(requestParameters, initOverrides) {
-        await this.companiesIdUsersPostRaw(requestParameters, initOverrides);
+    async getCompanyById(requestParameters, initOverrides) {
+        const response = await this.getCompanyByIdRaw(requestParameters, initOverrides);
+        return await response.value();
     }
     /**
-     * Creates a new company
+     *
      */
-    async companiesPostRaw(requestParameters, initOverrides) {
-        if (requestParameters.companiesPostRequest === null || requestParameters.companiesPostRequest === undefined) {
-            throw new runtime.RequiredError('companiesPostRequest', 'Required parameter requestParameters.companiesPostRequest was null or undefined when calling companiesPost.');
-        }
+    async getSubscriptionsRaw(initOverrides) {
         const queryParameters = {};
         const headerParameters = {};
-        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: `/subscriptions`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CompaniesPostRequestToJSON)(requestParameters.companiesPostRequest),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompaniesGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.SubscriptionFromJSON));
     }
     /**
-     * Creates a new company
+     *
      */
-    async companiesPost(requestParameters, initOverrides) {
-        const response = await this.companiesPostRaw(requestParameters, initOverrides);
+    async getSubscriptions(initOverrides) {
+        const response = await this.getSubscriptionsRaw(initOverrides);
         return await response.value();
     }
     /**
+     *
      */
-    async emailsSendPostRaw(requestParameters, initOverrides) {
-        if (requestParameters.emailsSendPostRequest === null || requestParameters.emailsSendPostRequest === undefined) {
-            throw new runtime.RequiredError('emailsSendPostRequest', 'Required parameter requestParameters.emailsSendPostRequest was null or undefined when calling emailsSendPost.');
+    async getTemplateByIdRaw(requestParameters, initOverrides) {
+        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 = {};
         const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
         const response = await this.request({
-            path: `/emails/send`,
-            method: 'POST',
+            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.EmailsSendPostRequestToJSON)(requestParameters.emailsSendPostRequest),
         }, initOverrides);
-        return new runtime.VoidApiResponse(response);
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse(response);
+        }
+        else {
+            return new runtime.TextApiResponse(response);
+        }
     }
     /**
+     *
      */
-    async emailsSendPost(requestParameters, initOverrides) {
-        await this.emailsSendPostRaw(requestParameters, initOverrides);
+    async getTemplateById(requestParameters, initOverrides) {
+        const response = await this.getTemplateByIdRaw(requestParameters, initOverrides);
+        return await response.value();
     }
     /**
+     *
      */
-    async subscriptionsGetRaw(initOverrides) {
+    async getTemplatesRaw(initOverrides) {
         const queryParameters = {};
         const headerParameters = {};
         const response = await this.request({
-            path: `/subscriptions`,
+            path: `/templates`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.EmailTemplatesFromJSON));
     }
     /**
+     *
      */
-    async subscriptionsGet(initOverrides) {
-        await this.subscriptionsGetRaw(initOverrides);
+    async getTemplates(initOverrides) {
+        const response = await this.getTemplatesRaw(initOverrides);
+        return await response.value();
     }
     /**
+     * Remove a user from a company
+     * Remove a user from a company
      */
-    async subscriptionsIdDeleteRaw(requestParameters, initOverrides) {
+    async removeUserFromCompanyRaw(requestParameters, initOverrides) {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling subscriptionsIdDelete.');
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling removeUserFromCompany.');
+        }
+        if (requestParameters.userId === null || requestParameters.userId === undefined) {
+            throw new runtime.RequiredError('userId', 'Required parameter requestParameters.userId was null or undefined when calling removeUserFromCompany.');
         }
         const queryParameters = {};
         const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
+        }
         const response = await this.request({
-            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/companies/{id}/{userId}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -464,239 +442,246 @@ class TuixTimesheetsClientApi extends runtime.BaseAPI {
         return new runtime.VoidApiResponse(response);
     }
     /**
+     * Remove a user from a company
+     * Remove a user from a company
      */
-    async subscriptionsIdDelete(requestParameters, initOverrides) {
-        await this.subscriptionsIdDeleteRaw(requestParameters, initOverrides);
+    async removeUserFromCompany(requestParameters, initOverrides) {
+        await this.removeUserFromCompanyRaw(requestParameters, initOverrides);
     }
     /**
+     *
      */
-    async subscriptionsNewsletterPostRaw(requestParameters, initOverrides) {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body', 'Required parameter requestParameters.body was null or undefined when calling subscriptionsNewsletterPost.');
+    async sdkTestRaw(requestParameters, initOverrides) {
+        if (requestParameters.sDKTestRequestDTO === null || requestParameters.sDKTestRequestDTO === undefined) {
+            throw new runtime.RequiredError('sDKTestRequestDTO', 'Required parameter requestParameters.sDKTestRequestDTO was null or undefined when calling sdkTest.');
         }
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         const response = await this.request({
-            path: `/subscriptions/newsletter`,
+            path: `/sdkTest`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body,
+            body: (0, index_1.SDKTestRequestDTOToJSON)(requestParameters.sDKTestRequestDTO),
         }, initOverrides);
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SDKTestResponseDTOFromJSON)(jsonValue));
     }
     /**
+     *
      */
-    async subscriptionsNewsletterPost(requestParameters, initOverrides) {
-        await this.subscriptionsNewsletterPostRaw(requestParameters, initOverrides);
+    async sdkTest(requestParameters, initOverrides) {
+        const response = await this.sdkTestRaw(requestParameters, initOverrides);
+        return await response.value();
     }
     /**
+     *
      */
-    async subscriptionsPostRaw(requestParameters, initOverrides) {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body', 'Required parameter requestParameters.body was null or undefined when calling subscriptionsPost.');
+    async sendEmailRaw(requestParameters, initOverrides) {
+        if (requestParameters.from === null || requestParameters.from === undefined) {
+            throw new runtime.RequiredError('from', 'Required parameter requestParameters.from was null or undefined when calling sendEmail.');
         }
-        const queryParameters = {};
-        const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
-        const response = await this.request({
-            path: `/subscriptions`,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-            body: requestParameters.body,
-        }, initOverrides);
-        return new runtime.VoidApiResponse(response);
-    }
-    /**
-     */
-    async subscriptionsPost(requestParameters, initOverrides) {
-        await this.subscriptionsPostRaw(requestParameters, initOverrides);
-    }
-    /**
-     */
-    async templatesGetRaw(initOverrides) {
-        const queryParameters = {};
-        const headerParameters = {};
-        const response = await this.request({
-            path: `/templates`,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.VoidApiResponse(response);
-    }
-    /**
-     */
-    async templatesGet(initOverrides) {
-        await this.templatesGetRaw(initOverrides);
-    }
-    /**
-     */
-    async templatesIdGetRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling templatesIdGet.');
+        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 = {};
         const headerParameters = {};
+        const consumes = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+        let formParams;
+        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);
+        }
+        if (requestParameters.to !== undefined) {
+            formParams.append('to', requestParameters.to);
+        }
+        if (requestParameters.subject !== undefined) {
+            formParams.append('subject', requestParameters.subject);
+        }
+        if (requestParameters.body !== undefined) {
+            formParams.append('body', requestParameters.body);
+        }
+        if (requestParameters.data !== undefined) {
+            formParams.append('data', requestParameters.data);
+        }
+        if (requestParameters.templateUUID !== undefined) {
+            formParams.append('templateUUID', requestParameters.templateUUID);
+        }
+        if (requestParameters.file !== undefined) {
+            formParams.append('file', requestParameters.file);
+        }
         const response = await this.request({
-            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/emails/send`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: formParams,
         }, initOverrides);
         return new runtime.VoidApiResponse(response);
     }
     /**
+     *
      */
-    async templatesIdGet(requestParameters, initOverrides) {
-        await this.templatesIdGetRaw(requestParameters, initOverrides);
+    async sendEmail(requestParameters, initOverrides) {
+        await this.sendEmailRaw(requestParameters, initOverrides);
     }
     /**
+     *
      */
-    async templatesPostRaw(requestParameters, initOverrides) {
-        if (requestParameters.templatesPostRequest === null || requestParameters.templatesPostRequest === undefined) {
-            throw new runtime.RequiredError('templatesPostRequest', 'Required parameter requestParameters.templatesPostRequest was null or undefined when calling templatesPost.');
+    async sendNewsletterToSubscribersRaw(requestParameters, initOverrides) {
+        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 = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         const response = await this.request({
-            path: `/templates`,
+            path: `/subscriptions/newsletter`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.TemplatesPostRequestToJSON)(requestParameters.templatesPostRequest),
-        }, initOverrides);
-        return new runtime.VoidApiResponse(response);
-    }
-    /**
-     */
-    async templatesPost(requestParameters, initOverrides) {
-        await this.templatesPostRaw(requestParameters, initOverrides);
-    }
-    /**
-     * Get all users
-     */
-    async testUsersGetRaw(initOverrides) {
-        const queryParameters = {};
-        const headerParameters = {};
-        const response = await this.request({
-            path: `/test-users`,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
+            body: (0, index_1.SendNewsletterDtoToJSON)(requestParameters.sendNewsletterDto),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.TestUsersGet200ResponseInnerFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SubscriptionsSentResponseDtoFromJSON)(jsonValue));
     }
     /**
-     * Get all users
+     *
      */
-    async testUsersGet(initOverrides) {
-        const response = await this.testUsersGetRaw(initOverrides);
+    async sendNewsletterToSubscribers(requestParameters, initOverrides) {
+        const response = await this.sendNewsletterToSubscribersRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Delete user
+     * Update client
      */
-    async testUsersIdDeleteRaw(requestParameters, initOverrides) {
+    async updateClientRaw(requestParameters, initOverrides) {
         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 = {};
-        const headerParameters = {};
-        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, initOverrides) {
-        await this.testUsersIdDeleteRaw(requestParameters, initOverrides);
-    }
-    /**
-     * Get user by id
-     */
-    async testUsersIdGetRaw(requestParameters, initOverrides) {
-        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 = {};
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
+        }
         const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.ClientDTOToJSON)(requestParameters.clientDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TestUsersGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
     }
     /**
-     * Get user by id
+     * Update client
      */
-    async testUsersIdGet(requestParameters, initOverrides) {
-        const response = await this.testUsersIdGetRaw(requestParameters, initOverrides);
+    async updateClient(requestParameters, initOverrides) {
+        const response = await this.updateClientRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Update user
+     * Update a company
+     * Update a company by ID
      */
-    async testUsersIdPatchRaw(requestParameters, initOverrides) {
+    async updateCompanyRaw(requestParameters, initOverrides) {
         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 updateCompany.');
         }
-        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.companyDTO === null || requestParameters.companyDTO === undefined) {
+            throw new runtime.RequiredError('companyDTO', 'Required parameter requestParameters.companyDTO was null or undefined when calling updateCompany.');
         }
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
+        }
         const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/companies/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.TestUsersGet200ResponseInnerToJSON)(requestParameters.testUsersGet200ResponseInner),
+            body: (0, index_1.CompanyDTOToJSON)(requestParameters.companyDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TestUsersGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompanyDTOFromJSON)(jsonValue));
     }
     /**
-     * Update user
+     * Update a company
+     * Update a company by ID
      */
-    async testUsersIdPatch(requestParameters, initOverrides) {
-        const response = await this.testUsersIdPatchRaw(requestParameters, initOverrides);
+    async updateCompany(requestParameters, initOverrides) {
+        const response = await this.updateCompanyRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Create user
+     *
      */
-    async testUsersPostRaw(requestParameters, initOverrides) {
-        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, initOverrides) {
+        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 = {};
         const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
+        const consumes = [
+            { contentType: 'multipart/form-data' },
+        ];
+        // @ts-ignore: canConsumeForm may be unused
+        const canConsumeForm = runtime.canConsumeForm(consumes);
+        let formParams;
+        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);
+        }
+        if (requestParameters.file !== undefined) {
+            formParams.append('file', requestParameters.file);
+        }
         const response = await this.request({
-            path: `/test-users`,
+            path: `/templates`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.TestUsersGet200ResponseInnerToJSON)(requestParameters.testUsersGet200ResponseInner),
+            body: formParams,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.TestUsersGet200ResponseInnerFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.EmailTemplatesFromJSON)(jsonValue));
     }
     /**
-     * Create user
+     *
      */
-    async testUsersPost(requestParameters, initOverrides) {
-        const response = await this.testUsersPostRaw(requestParameters, initOverrides);
+    async uploadTemplate(requestParameters, initOverrides) {
+        const response = await this.uploadTemplateRaw(requestParameters, initOverrides);
         return await response.value();
     }
 }