tuix-timesheets-api 0.5.24 → 0.6.0

package/apis/TuixTimesheetsClientApi.js

@@ -44,192 +44,179 @@ const index_1 = require("../models/index");
  */
 class TuixTimesheetsClientApi extends runtime.BaseAPI {
     /**
-     * Add a user to a company
-     * Add a user to a company
+     * Get all clients
      */
-    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 addUserToCompany.');
-        }
-        if (requestParameters.userDTO === null || requestParameters.userDTO === undefined) {
-            throw new runtime.RequiredError('userDTO', 'Required parameter requestParameters.userDTO was null or undefined when calling addUserToCompany.');
-        }
+    async clientsGetRaw(initOverrides) {
         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: `/clients`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.UserDTOToJSON)(requestParameters.userDTO),
         }, initOverrides);
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.ClientsGet200ResponseInnerFromJSON));
     }
     /**
-     * Add a user to a company
-     * Add a user to a company
+     * Get all clients
      */
-    async addUserToCompany(requestParameters, initOverrides) {
-        await this.addUserToCompanyRaw(requestParameters, initOverrides);
+    async clientsGet(initOverrides) {
+        const response = await this.clientsGetRaw(initOverrides);
+        return await response.value();
     }
     /**
-     * Create client
+     * Delete client
      */
-    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.');
+    async clientsIdDeleteRaw(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.');
         }
         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`,
-            method: 'POST',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.ClientDTOToJSON)(requestParameters.clientDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientsGet200ResponseInnerFromJSON)(jsonValue));
     }
     /**
-     * Create client
+     * Delete client
      */
-    async createClient(requestParameters, initOverrides) {
-        const response = await this.createClientRaw(requestParameters, initOverrides);
+    async clientsIdDelete(requestParameters, initOverrides) {
+        const response = await this.clientsIdDeleteRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Create a company
-     * Creates a new company
+     * Get client by id
      */
-    async createCompanyRaw(requestParameters, initOverrides) {
-        if (requestParameters.companyDTO === null || requestParameters.companyDTO === undefined) {
-            throw new runtime.RequiredError('companyDTO', 'Required parameter requestParameters.companyDTO was null or undefined when calling createCompany.');
+    async clientsIdGetRaw(requestParameters, initOverrides) {
+        if (requestParameters.id === null || requestParameters.id === undefined) {
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling clientsIdGet.');
         }
         const queryParameters = {};
         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: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CompanyDTOToJSON)(requestParameters.companyDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompanyDTOFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientsGet200ResponseInnerFromJSON)(jsonValue));
     }
     /**
-     * Create a company
-     * Creates a new company
+     * Get client by id
      */
-    async createCompany(requestParameters, initOverrides) {
-        const response = await this.createCompanyRaw(requestParameters, initOverrides);
+    async clientsIdGet(requestParameters, initOverrides) {
+        const response = await this.clientsIdGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     *
+     * Update client
      */
-    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.');
+    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.clientsGet200ResponseInner === null || requestParameters.clientsGet200ResponseInner === undefined) {
+            throw new runtime.RequiredError('clientsGet200ResponseInner', 'Required parameter requestParameters.clientsGet200ResponseInner was null or undefined when calling clientsIdPatch.');
         }
         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: `/subscriptions`,
-            method: 'POST',
+            path: `/clients/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CreateSubscriptionDTOToJSON)(requestParameters.createSubscriptionDTO),
+            body: (0, index_1.ClientsGet200ResponseInnerToJSON)(requestParameters.clientsGet200ResponseInner),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SubscriptionFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientsGet200ResponseInnerFromJSON)(jsonValue));
     }
     /**
-     *
+     * Update client
      */
-    async createSubscription(requestParameters, initOverrides) {
-        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
+    async clientsIdPatch(requestParameters, initOverrides) {
+        const response = await this.clientsIdPatchRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Create user
+     * Create client
      */
-    async createTestUserRaw(requestParameters, initOverrides) {
-        if (requestParameters.userDTOSc === null || requestParameters.userDTOSc === undefined) {
-            throw new runtime.RequiredError('userDTOSc', 'Required parameter requestParameters.userDTOSc was null or undefined when calling createTestUser.');
+    async clientsPostRaw(requestParameters, initOverrides) {
+        if (requestParameters.clientsGet200ResponseInner === null || requestParameters.clientsGet200ResponseInner === undefined) {
+            throw new runtime.RequiredError('clientsGet200ResponseInner', 'Required parameter requestParameters.clientsGet200ResponseInner was null or undefined when calling clientsPost.');
         }
         const queryParameters = {};
         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`,
+            path: `/clients`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.UserDTOScToJSON)(requestParameters.userDTOSc),
+            body: (0, index_1.ClientsGet200ResponseInnerToJSON)(requestParameters.clientsGet200ResponseInner),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.UserDTOScFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientsGet200ResponseInnerFromJSON)(jsonValue));
     }
     /**
-     * Create user
+     * Create client
      */
-    async createTestUser(requestParameters, initOverrides) {
-        const response = await this.createTestUserRaw(requestParameters, initOverrides);
+    async clientsPost(requestParameters, initOverrides) {
+        const response = await this.clientsPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Delete client
+     * Get all companies
      */
-    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.');
-        }
+    async companiesGetRaw(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/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/companies`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.CompaniesGet200ResponseInnerFromJSON));
     }
     /**
-     * Delete client
+     * Get all companies
      */
-    async deleteClient(requestParameters, initOverrides) {
-        const response = await this.deleteClientRaw(requestParameters, initOverrides);
+    async companiesGet(initOverrides) {
+        const response = await this.companiesGetRaw(initOverrides);
         return await response.value();
     }
     /**
-     * Delete a company
-     * delete a company
+     * Delete a company by ID
      */
-    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 deleteCompany.');
-        }
+    async companiesIdDeleteRaw(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}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            path: `/companies/{id}`,
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -237,298 +224,222 @@ class TuixTimesheetsClientApi extends runtime.BaseAPI {
         return new runtime.VoidApiResponse(response);
     }
     /**
-     * Delete a company
-     * delete a company
+     * Delete a company by ID
      */
-    async deleteCompany(requestParameters, initOverrides) {
-        await this.deleteCompanyRaw(requestParameters, initOverrides);
+    async companiesIdDelete(initOverrides) {
+        await this.companiesIdDeleteRaw(initOverrides);
     }
     /**
-     *
+     * Get a company by ID
      */
-    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 deleteSubscription.');
-        }
+    async companiesIdGetRaw(initOverrides) {
         const queryParameters = {};
         const headerParameters = {};
-        const response = await this.request({
-            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.VoidApiResponse(response);
-    }
-    /**
-     *
-     */
-    async deleteSubscription(requestParameters, initOverrides) {
-        await this.deleteSubscriptionRaw(requestParameters, initOverrides);
-    }
-    /**
-     * Delete user
-     */
-    async deleteTestUserRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling deleteTestUser.');
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
         }
-        const queryParameters = {};
-        const headerParameters = {};
         const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'DELETE',
+            path: `/companies/{id}`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompaniesGet200ResponseInnerFromJSON)(jsonValue));
     }
     /**
-     * Delete user
+     * Get a company by ID
      */
-    async deleteTestUser(requestParameters, initOverrides) {
-        await this.deleteTestUserRaw(requestParameters, initOverrides);
+    async companiesIdGet(initOverrides) {
+        const response = await this.companiesIdGetRaw(initOverrides);
+        return await response.value();
     }
     /**
-     * Get client by id
+     * Update a company by ID
      */
-    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 getClientById.');
+    async companiesIdPatchRaw(requestParameters, initOverrides) {
+        if (requestParameters.companiesIdPatchRequest === null || requestParameters.companiesIdPatchRequest === undefined) {
+            throw new runtime.RequiredError('companiesIdPatchRequest', 'Required parameter requestParameters.companiesIdPatchRequest was null or undefined when calling companiesIdPatch.');
         }
         const queryParameters = {};
         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: `/companies/{id}`,
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CompaniesIdPatchRequestToJSON)(requestParameters.companiesIdPatchRequest),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompaniesGet200ResponseInnerFromJSON)(jsonValue));
     }
     /**
-     * Get client by id
+     * Update a company by ID
      */
-    async getClientById(requestParameters, initOverrides) {
-        const response = await this.getClientByIdRaw(requestParameters, initOverrides);
+    async companiesIdPatch(requestParameters, initOverrides) {
+        const response = await this.companiesIdPatchRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Get all clients
+     * Remove a user from a company
      */
-    async getClientsRaw(initOverrides) {
+    async companiesIdUserIdDeleteRaw(requestParameters, initOverrides) {
+        if (requestParameters.userId === null || requestParameters.userId === undefined) {
+            throw new runtime.RequiredError('userId', 'Required parameter requestParameters.userId was null or undefined when calling companiesIdUserIdDelete.');
+        }
         const queryParameters = {};
         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',
+            path: `/companies/{id}/{userId}`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters.userId))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.ClientDTOFromJSON));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     * Get all clients
+     * Remove a user from a company
      */
-    async getClients(initOverrides) {
-        const response = await this.getClientsRaw(initOverrides);
-        return await response.value();
+    async companiesIdUserIdDelete(requestParameters, initOverrides) {
+        await this.companiesIdUserIdDeleteRaw(requestParameters, initOverrides);
     }
     /**
-     * Get all companies a user belongs to
-     * Get all companies a user belongs to
+     * Get all users from a company
      */
-    async getCompaniesRaw(initOverrides) {
+    async companiesIdUsersGetRaw(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`,
+            path: `/companies/{id}/users`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.CompanyDTOFromJSON));
+        return new runtime.JSONApiResponse(response);
     }
     /**
-     * Get all companies a user belongs to
-     * Get all companies a user belongs to
+     * Get all users from a company
      */
-    async getCompanies(initOverrides) {
-        const response = await this.getCompaniesRaw(initOverrides);
+    async companiesIdUsersGet(initOverrides) {
+        const response = await this.companiesIdUsersGetRaw(initOverrides);
         return await response.value();
     }
     /**
-     * Get a company
-     * Get a company by ID
+     * Add a user to a company
      */
-    async getCompanyByIdRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling getCompanyById.');
+    async companiesIdUsersPostRaw(requestParameters, initOverrides) {
+        if (requestParameters.body === null || requestParameters.body === undefined) {
+            throw new runtime.RequiredError('body', 'Required parameter requestParameters.body was null or undefined when calling companiesIdUsersPost.');
         }
         const queryParameters = {};
         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: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompanyDTOFromJSON)(jsonValue));
-    }
-    /**
-     * Get a company
-     * Get a company by ID
-     */
-    async getCompanyById(requestParameters, initOverrides) {
-        const response = await this.getCompanyByIdRaw(requestParameters, initOverrides);
-        return await response.value();
-    }
-    /**
-     *
-     */
-    async getSubscriptionsRaw(initOverrides) {
-        const queryParameters = {};
-        const headerParameters = {};
-        const response = await this.request({
-            path: `/subscriptions`,
-            method: 'GET',
+            path: `/companies/{id}/users`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: requestParameters.body,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.SubscriptionFromJSON));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     *
+     * Add a user to a company
      */
-    async getSubscriptions(initOverrides) {
-        const response = await this.getSubscriptionsRaw(initOverrides);
-        return await response.value();
+    async companiesIdUsersPost(requestParameters, initOverrides) {
+        await this.companiesIdUsersPostRaw(requestParameters, initOverrides);
     }
     /**
-     *
+     * Creates a new company
      */
-    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.');
+    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.');
         }
         const queryParameters = {};
         const headerParameters = {};
-        const response = await this.request({
-            path: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        if (this.isJsonMime(response.headers.get('content-type'))) {
-            return new runtime.JSONApiResponse(response);
-        }
-        else {
-            return new runtime.TextApiResponse(response);
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = this.configuration.apiKey("Authorization"); // auth0Authorizer authentication
         }
-    }
-    /**
-     *
-     */
-    async getTemplateById(requestParameters, initOverrides) {
-        const response = await this.getTemplateByIdRaw(requestParameters, initOverrides);
-        return await response.value();
-    }
-    /**
-     *
-     */
-    async getTemplatesRaw(initOverrides) {
-        const queryParameters = {};
-        const headerParameters = {};
         const response = await this.request({
-            path: `/templates`,
-            method: 'GET',
+            path: `/companies`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CompaniesPostRequestToJSON)(requestParameters.companiesPostRequest),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.EmailTemplatesFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompaniesGet200ResponseInnerFromJSON)(jsonValue));
     }
     /**
-     *
+     * Creates a new company
      */
-    async getTemplates(initOverrides) {
-        const response = await this.getTemplatesRaw(initOverrides);
+    async companiesPost(requestParameters, initOverrides) {
+        const response = await this.companiesPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     * Get user by id
      */
-    async getTestUserByIdRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling getTestUserById.');
+    async emailsSendPostRaw(requestParameters, initOverrides) {
+        if (requestParameters.emailsSendPostRequest === null || requestParameters.emailsSendPostRequest === undefined) {
+            throw new runtime.RequiredError('emailsSendPostRequest', 'Required parameter requestParameters.emailsSendPostRequest was null or undefined when calling emailsSendPost.');
         }
         const queryParameters = {};
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'GET',
+            path: `/emails/send`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.EmailsSendPostRequestToJSON)(requestParameters.emailsSendPostRequest),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.UserDTOScFromJSON)(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     * Get user by id
      */
-    async getTestUserById(requestParameters, initOverrides) {
-        const response = await this.getTestUserByIdRaw(requestParameters, initOverrides);
-        return await response.value();
+    async emailsSendPost(requestParameters, initOverrides) {
+        await this.emailsSendPostRaw(requestParameters, initOverrides);
     }
     /**
-     * Get all users
      */
-    async getTestUsersRaw(initOverrides) {
+    async subscriptionsGetRaw(initOverrides) {
         const queryParameters = {};
         const headerParameters = {};
         const response = await this.request({
-            path: `/test-users`,
+            path: `/subscriptions`,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.UserDTOScFromJSON));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     * Get all users
      */
-    async getTestUsers(initOverrides) {
-        const response = await this.getTestUsersRaw(initOverrides);
-        return await response.value();
+    async subscriptionsGet(initOverrides) {
+        await this.subscriptionsGetRaw(initOverrides);
     }
     /**
-     * Remove a user from a company
-     * Remove a user from a company
      */
-    async removeUserFromCompanyRaw(requestParameters, initOverrides) {
+    async subscriptionsIdDeleteRaw(requestParameters, initOverrides) {
         if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling removeUserFromCompany.');
-        }
-        if (requestParameters.userId === null || requestParameters.userId === undefined) {
-            throw new runtime.RequiredError('userId', 'Required parameter requestParameters.userId was null or undefined when calling removeUserFromCompany.');
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling subscriptionsIdDelete.');
         }
         const queryParameters = {};
         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))),
+            path: `/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -536,276 +447,117 @@ class TuixTimesheetsClientApi extends runtime.BaseAPI {
         return new runtime.VoidApiResponse(response);
     }
     /**
-     * Remove a user from a company
-     * Remove a user from a company
      */
-    async removeUserFromCompany(requestParameters, initOverrides) {
-        await this.removeUserFromCompanyRaw(requestParameters, initOverrides);
+    async subscriptionsIdDelete(requestParameters, initOverrides) {
+        await this.subscriptionsIdDeleteRaw(requestParameters, initOverrides);
     }
     /**
-     *
      */
-    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.');
+    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.');
         }
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         const response = await this.request({
-            path: `/sdkTest`,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-            body: (0, index_1.SDKTestRequestDTOToJSON)(requestParameters.sDKTestRequestDTO),
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SDKTestResponseDTOFromJSON)(jsonValue));
-    }
-    /**
-     *
-     */
-    async sdkTest(requestParameters, initOverrides) {
-        const response = await this.sdkTestRaw(requestParameters, initOverrides);
-        return await response.value();
-    }
-    /**
-     *
-     */
-    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.');
-        }
-        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: `/emails/send`,
+            path: `/subscriptions/newsletter`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: formParams,
+            body: requestParameters.body,
         }, initOverrides);
         return new runtime.VoidApiResponse(response);
     }
     /**
-     *
      */
-    async sendEmail(requestParameters, initOverrides) {
-        await this.sendEmailRaw(requestParameters, initOverrides);
+    async subscriptionsNewsletterPost(requestParameters, initOverrides) {
+        await this.subscriptionsNewsletterPostRaw(requestParameters, initOverrides);
     }
     /**
-     *
      */
-    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.');
+    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.');
         }
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         const response = await this.request({
-            path: `/subscriptions/newsletter`,
+            path: `/subscriptions`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.SendNewsletterDtoToJSON)(requestParameters.sendNewsletterDto),
+            body: requestParameters.body,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SubscriptionsSentResponseDtoFromJSON)(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     *
      */
-    async sendNewsletterToSubscribers(requestParameters, initOverrides) {
-        const response = await this.sendNewsletterToSubscribersRaw(requestParameters, initOverrides);
-        return await response.value();
+    async subscriptionsPost(requestParameters, initOverrides) {
+        await this.subscriptionsPostRaw(requestParameters, initOverrides);
     }
     /**
-     * Update client
      */
-    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 updateClient.');
-        }
-        if (requestParameters.clientDTO === null || requestParameters.clientDTO === undefined) {
-            throw new runtime.RequiredError('clientDTO', 'Required parameter requestParameters.clientDTO was null or undefined when calling updateClient.');
-        }
+    async templatesGetRaw(initOverrides) {
         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: 'PATCH',
+            path: `/templates`,
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.ClientDTOToJSON)(requestParameters.clientDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ClientDTOFromJSON)(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     * Update client
      */
-    async updateClient(requestParameters, initOverrides) {
-        const response = await this.updateClientRaw(requestParameters, initOverrides);
-        return await response.value();
+    async templatesGet(initOverrides) {
+        await this.templatesGetRaw(initOverrides);
     }
     /**
-     * Update a company
-     * Update a company by ID
      */
-    async updateCompanyRaw(requestParameters, 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 updateCompany.');
-        }
-        if (requestParameters.companyDTO === null || requestParameters.companyDTO === undefined) {
-            throw new runtime.RequiredError('companyDTO', 'Required parameter requestParameters.companyDTO was null or undefined when calling updateCompany.');
+            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling templatesIdGet.');
         }
         const queryParameters = {};
         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: `/templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CompanyDTOToJSON)(requestParameters.companyDTO),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompanyDTOFromJSON)(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     * Update a company
-     * Update a company by ID
      */
-    async updateCompany(requestParameters, initOverrides) {
-        const response = await this.updateCompanyRaw(requestParameters, initOverrides);
-        return await response.value();
+    async templatesIdGet(requestParameters, initOverrides) {
+        await this.templatesIdGetRaw(requestParameters, initOverrides);
     }
     /**
-     * Update user
      */
-    async updateTestUserRaw(requestParameters, initOverrides) {
-        if (requestParameters.id === null || requestParameters.id === undefined) {
-            throw new runtime.RequiredError('id', 'Required parameter requestParameters.id was null or undefined when calling updateTestUser.');
-        }
-        if (requestParameters.userDTOSc === null || requestParameters.userDTOSc === undefined) {
-            throw new runtime.RequiredError('userDTOSc', 'Required parameter requestParameters.userDTOSc was null or undefined when calling updateTestUser.');
+    async templatesPostRaw(requestParameters, initOverrides) {
+        if (requestParameters.templatesPostRequest === null || requestParameters.templatesPostRequest === undefined) {
+            throw new runtime.RequiredError('templatesPostRequest', 'Required parameter requestParameters.templatesPostRequest was null or undefined when calling templatesPost.');
         }
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
-        const response = await this.request({
-            path: `/test-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
-            method: 'PATCH',
-            headers: headerParameters,
-            query: queryParameters,
-            body: (0, index_1.UserDTOScToJSON)(requestParameters.userDTOSc),
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.UserDTOScFromJSON)(jsonValue));
-    }
-    /**
-     * Update user
-     */
-    async updateTestUser(requestParameters, initOverrides) {
-        const response = await this.updateTestUserRaw(requestParameters, initOverrides);
-        return await response.value();
-    }
-    /**
-     *
-     */
-    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 = {};
-        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: `/templates`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: formParams,
+            body: (0, index_1.TemplatesPostRequestToJSON)(requestParameters.templatesPostRequest),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.EmailTemplatesFromJSON)(jsonValue));
+        return new runtime.VoidApiResponse(response);
     }
     /**
-     *
      */
-    async uploadTemplate(requestParameters, initOverrides) {
-        const response = await this.uploadTemplateRaw(requestParameters, initOverrides);
-        return await response.value();
+    async templatesPost(requestParameters, initOverrides) {
+        await this.templatesPostRaw(requestParameters, initOverrides);
     }
 }
 exports.TuixTimesheetsClientApi = TuixTimesheetsClientApi;