nordlet 0.3.4 → 0.3.7

package/dist/api/resources/sales/client/Client.js

@@ -48,28 +48,30 @@ class SalesClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesCreateRequest} request
+     * @param {NordletApi.InvoicesCreateSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesCreate({
+     *     await client.sales.invoicesCreate({
      *         partnerId: "partnerId",
      *         lines: [{}]
      *     })
      */
-    postV1SalesInvoicesCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesCreate(request, requestOptions));
+    invoicesCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesCreate(request, requestOptions));
     }
-    async __postV1SalesInvoicesCreate(request, requestOptions) {
+    async __invoicesCreate(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -100,12 +102,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -123,27 +129,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/create");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesGetRequest} request
+     * @param {NordletApi.InvoicesGetSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesGet({
+     *     await client.sales.invoicesGet({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesGet(request, requestOptions));
+    invoicesGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesGet(request, requestOptions));
     }
-    async __postV1SalesInvoicesGet(request, requestOptions) {
+    async __invoicesGet(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -163,10 +171,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -174,12 +179,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -197,27 +206,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/get");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesPdfRequest} request
+     * @param {NordletApi.InvoicesPdfSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesPdf({
+     *     await client.sales.invoicesPdf({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesPdf(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesPdf(request, requestOptions));
+    invoicesPdf(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesPdf(request, requestOptions));
     }
-    async __postV1SalesInvoicesPdf(request, requestOptions) {
+    async __invoicesPdf(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -237,10 +248,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -248,12 +256,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -271,27 +283,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/pdf");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesSendRequest} request
+     * @param {NordletApi.InvoicesSendSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesSend({
+     *     await client.sales.invoicesSend({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesSend(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesSend(request, requestOptions));
+    invoicesSend(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesSend(request, requestOptions));
     }
-    async __postV1SalesInvoicesSend(request, requestOptions) {
+    async __invoicesSend(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -311,10 +325,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -322,12 +333,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -345,27 +360,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/send");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesPeppolXmlRequest} request
+     * @param {NordletApi.InvoicesPeppolXmlSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesPeppolXml({
+     *     await client.sales.invoicesPeppolXml({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesPeppolXml(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesPeppolXml(request, requestOptions));
+    invoicesPeppolXml(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesPeppolXml(request, requestOptions));
     }
-    async __postV1SalesInvoicesPeppolXml(request, requestOptions) {
+    async __invoicesPeppolXml(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -396,12 +413,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -419,27 +440,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/peppol-xml");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesPeppolSendRequest} request
+     * @param {NordletApi.InvoicesPeppolSendSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesPeppolSend({
+     *     await client.sales.invoicesPeppolSend({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesPeppolSend(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesPeppolSend(request, requestOptions));
+    invoicesPeppolSend(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesPeppolSend(request, requestOptions));
     }
-    async __postV1SalesInvoicesPeppolSend(request, requestOptions) {
+    async __invoicesPeppolSend(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -470,12 +493,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -495,27 +522,29 @@ class SalesClient {
     /**
      * Render an issued invoice as the national e-invoicing payload for the company country: FatturaPA (IT), KSeF FA(3) (PL) or UBL CIUS-RO (RO). Review the warnings - data the invoice does not carry is flagged, never invented.
      *
-     * @param {NordletApi.PostV1SalesInvoicesEinvoiceXmlRequest} request
+     * @param {NordletApi.InvoicesEinvoiceXmlSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesEinvoiceXml({
+     *     await client.sales.invoicesEinvoiceXml({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesEinvoiceXml(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesEinvoiceXml(request, requestOptions));
+    invoicesEinvoiceXml(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesEinvoiceXml(request, requestOptions));
     }
-    async __postV1SalesInvoicesEinvoiceXml(request, requestOptions) {
+    async __invoicesEinvoiceXml(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -546,12 +575,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -571,27 +604,29 @@ class SalesClient {
     /**
      * Build the national e-invoicing payload and deliver it over the transport configured for the country gateway in compliance settings. With transport=direct the request talks to the tax authority itself - SdICoop over 2-way TLS for Italy, a KSeF session for Poland, ANAF SPV OAuth for Romania - and returns the national number as soon as the channel assigns one. With transport=bridge the payload goes to the configured bridge endpoint (an accredited intermediary or connector) instead.
      *
-     * @param {NordletApi.PostV1SalesInvoicesEinvoiceSendRequest} request
+     * @param {NordletApi.InvoicesEinvoiceSendSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesEinvoiceSend({
+     *     await client.sales.invoicesEinvoiceSend({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesEinvoiceSend(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesEinvoiceSend(request, requestOptions));
+    invoicesEinvoiceSend(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesEinvoiceSend(request, requestOptions));
     }
-    async __postV1SalesInvoicesEinvoiceSend(request, requestOptions) {
+    async __invoicesEinvoiceSend(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -622,12 +657,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -647,27 +686,29 @@ class SalesClient {
     /**
      * Ask the national e-invoicing channel what happened to an invoice that was already sent, and store the answer. Italy, Poland and Romania return the outcome only on request - none of them calls back - so this is the way the national number and any rejection reason reach the invoice.
      *
-     * @param {NordletApi.PostV1SalesInvoicesEinvoiceStatusRequest} request
+     * @param {NordletApi.InvoicesEinvoiceStatusSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesEinvoiceStatus({
+     *     await client.sales.invoicesEinvoiceStatus({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesEinvoiceStatus(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesEinvoiceStatus(request, requestOptions));
+    invoicesEinvoiceStatus(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesEinvoiceStatus(request, requestOptions));
     }
-    async __postV1SalesInvoicesEinvoiceStatus(request, requestOptions) {
+    async __invoicesEinvoiceStatus(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -698,12 +739,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -721,27 +766,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/einvoice-status");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesUpdateRequest} request
+     * @param {NordletApi.InvoicesUpdateSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesUpdate({
+     *     await client.sales.invoicesUpdate({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesUpdate(request, requestOptions));
+    invoicesUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesUpdate(request, requestOptions));
     }
-    async __postV1SalesInvoicesUpdate(request, requestOptions) {
+    async __invoicesUpdate(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -772,12 +819,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -795,27 +846,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/update");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesDeleteRequest} request
+     * @param {NordletApi.InvoicesDeleteSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesDelete({
+     *     await client.sales.invoicesDelete({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesDelete(request, requestOptions));
+    invoicesDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesDelete(request, requestOptions));
     }
-    async __postV1SalesInvoicesDelete(request, requestOptions) {
+    async __invoicesDelete(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -846,12 +899,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -869,27 +926,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/delete");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesIssueRequest} request
+     * @param {NordletApi.InvoicesIssueSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesIssue({
+     *     await client.sales.invoicesIssue({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesIssue(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesIssue(request, requestOptions));
+    invoicesIssue(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesIssue(request, requestOptions));
     }
-    async __postV1SalesInvoicesIssue(request, requestOptions) {
+    async __invoicesIssue(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -920,12 +979,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -943,27 +1006,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/issue");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesLockRequest} request
+     * @param {NordletApi.InvoicesLockSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesLock({
+     *     await client.sales.invoicesLock({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesLock(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesLock(request, requestOptions));
+    invoicesLock(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesLock(request, requestOptions));
     }
-    async __postV1SalesInvoicesLock(request, requestOptions) {
+    async __invoicesLock(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -983,10 +1048,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -994,12 +1056,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1017,27 +1083,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/lock");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesUnlockRequest} request
+     * @param {NordletApi.InvoicesUnlockSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesUnlock({
+     *     await client.sales.invoicesUnlock({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesUnlock(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesUnlock(request, requestOptions));
+    invoicesUnlock(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesUnlock(request, requestOptions));
     }
-    async __postV1SalesInvoicesUnlock(request, requestOptions) {
+    async __invoicesUnlock(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1068,12 +1136,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1091,27 +1163,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/unlock");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesPaymentLinkRequest} request
+     * @param {NordletApi.InvoicesPaymentLinkSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesPaymentLink({
+     *     await client.sales.invoicesPaymentLink({
      *         id: "id"
      *     })
      */
-    postV1SalesInvoicesPaymentLink(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesPaymentLink(request, requestOptions));
+    invoicesPaymentLink(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesPaymentLink(request, requestOptions));
     }
-    async __postV1SalesInvoicesPaymentLink(request, requestOptions) {
+    async __invoicesPaymentLink(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1142,12 +1216,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1165,25 +1243,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/payment-link");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesPaymentSettingsGetRequest} request
+     * @param {NordletApi.InvoicesPaymentSettingsGetSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesPaymentSettingsGet()
+     *     await client.sales.invoicesPaymentSettingsGet()
      */
-    postV1SalesInvoicesPaymentSettingsGet(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesPaymentSettingsGet(request, requestOptions));
+    invoicesPaymentSettingsGet(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesPaymentSettingsGet(request, requestOptions));
     }
-    async __postV1SalesInvoicesPaymentSettingsGet(request = {}, requestOptions) {
+    async __invoicesPaymentSettingsGet(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1214,12 +1294,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1237,25 +1321,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/payment-settings/get");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesPaymentSettingsUpdateRequest} request
+     * @param {NordletApi.InvoicesPaymentSettingsUpdateSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesPaymentSettingsUpdate({})
+     *     await client.sales.invoicesPaymentSettingsUpdate({})
      */
-    postV1SalesInvoicesPaymentSettingsUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesPaymentSettingsUpdate(request, requestOptions));
+    invoicesPaymentSettingsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesPaymentSettingsUpdate(request, requestOptions));
     }
-    async __postV1SalesInvoicesPaymentSettingsUpdate(request, requestOptions) {
+    async __invoicesPaymentSettingsUpdate(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1286,12 +1372,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1309,25 +1399,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/payment-settings/update");
     }
     /**
-     * @param {NordletApi.PostV1SalesRecognitionSchedulesListRequest} request
+     * @param {NordletApi.RecognitionSchedulesListSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRecognitionSchedulesList()
+     *     await client.sales.recognitionSchedulesList()
      */
-    postV1SalesRecognitionSchedulesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRecognitionSchedulesList(request, requestOptions));
+    recognitionSchedulesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recognitionSchedulesList(request, requestOptions));
     }
-    async __postV1SalesRecognitionSchedulesList(request = {}, requestOptions) {
+    async __recognitionSchedulesList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1358,12 +1450,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1381,28 +1477,30 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/recognition-schedules/list");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesApplyAdvanceRequest} request
+     * @param {NordletApi.InvoicesApplyAdvanceSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesApplyAdvance({
+     *     await client.sales.invoicesApplyAdvance({
      *         advanceId: "advanceId",
      *         invoiceId: "invoiceId"
      *     })
      */
-    postV1SalesInvoicesApplyAdvance(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesApplyAdvance(request, requestOptions));
+    invoicesApplyAdvance(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesApplyAdvance(request, requestOptions));
     }
-    async __postV1SalesInvoicesApplyAdvance(request, requestOptions) {
+    async __invoicesApplyAdvance(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1433,12 +1531,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1456,25 +1558,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/apply-advance");
     }
     /**
-     * @param {NordletApi.PostV1SalesInvoicesListRequest} request
+     * @param {NordletApi.InvoicesListSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesInvoicesList()
+     *     await client.sales.invoicesList()
      */
-    postV1SalesInvoicesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesInvoicesList(request, requestOptions));
+    invoicesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesList(request, requestOptions));
     }
-    async __postV1SalesInvoicesList(request = {}, requestOptions) {
+    async __invoicesList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1494,10 +1598,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1505,12 +1606,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1528,27 +1633,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/invoices/list");
     }
     /**
-     * @param {NordletApi.PostV1SalesActsCreateRequest} request
+     * @param {NordletApi.ActsCreateSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesActsCreate({
+     *     await client.sales.actsCreate({
      *         partnerId: "partnerId"
      *     })
      */
-    postV1SalesActsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesActsCreate(request, requestOptions));
+    actsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__actsCreate(request, requestOptions));
     }
-    async __postV1SalesActsCreate(request, requestOptions) {
+    async __actsCreate(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1568,10 +1675,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1579,12 +1683,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1602,27 +1710,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/acts/create");
     }
     /**
-     * @param {NordletApi.PostV1SalesActsUpdateRequest} request
+     * @param {NordletApi.ActsUpdateSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesActsUpdate({
+     *     await client.sales.actsUpdate({
      *         id: "id"
      *     })
      */
-    postV1SalesActsUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesActsUpdate(request, requestOptions));
+    actsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__actsUpdate(request, requestOptions));
     }
-    async __postV1SalesActsUpdate(request, requestOptions) {
+    async __actsUpdate(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1642,10 +1752,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1653,12 +1760,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1676,27 +1787,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/acts/update");
     }
     /**
-     * @param {NordletApi.PostV1SalesActsIssueRequest} request
+     * @param {NordletApi.ActsIssueSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesActsIssue({
+     *     await client.sales.actsIssue({
      *         id: "id"
      *     })
      */
-    postV1SalesActsIssue(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesActsIssue(request, requestOptions));
+    actsIssue(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__actsIssue(request, requestOptions));
     }
-    async __postV1SalesActsIssue(request, requestOptions) {
+    async __actsIssue(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1716,10 +1829,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1727,12 +1837,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1750,27 +1864,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/acts/issue");
     }
     /**
-     * @param {NordletApi.PostV1SalesActsCancelRequest} request
+     * @param {NordletApi.ActsCancelSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesActsCancel({
+     *     await client.sales.actsCancel({
      *         id: "id"
      *     })
      */
-    postV1SalesActsCancel(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesActsCancel(request, requestOptions));
+    actsCancel(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__actsCancel(request, requestOptions));
     }
-    async __postV1SalesActsCancel(request, requestOptions) {
+    async __actsCancel(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1790,10 +1906,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1801,12 +1914,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1824,27 +1941,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/acts/cancel");
     }
     /**
-     * @param {NordletApi.PostV1SalesActsGetRequest} request
+     * @param {NordletApi.ActsGetSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesActsGet({
+     *     await client.sales.actsGet({
      *         id: "id"
      *     })
      */
-    postV1SalesActsGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesActsGet(request, requestOptions));
+    actsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__actsGet(request, requestOptions));
     }
-    async __postV1SalesActsGet(request, requestOptions) {
+    async __actsGet(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1864,10 +1983,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1875,12 +1991,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1898,25 +2018,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/acts/get");
     }
     /**
-     * @param {NordletApi.PostV1SalesActsListRequest} request
+     * @param {NordletApi.ActsListSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesActsList()
+     *     await client.sales.actsList()
      */
-    postV1SalesActsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesActsList(request, requestOptions));
+    actsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__actsList(request, requestOptions));
     }
-    async __postV1SalesActsList(request = {}, requestOptions) {
+    async __actsList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1936,10 +2058,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1947,12 +2066,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1970,27 +2093,29 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/acts/list");
     }
     /**
-     * @param {NordletApi.PostV1SalesActsPdfRequest} request
+     * @param {NordletApi.ActsPdfSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesActsPdf({
+     *     await client.sales.actsPdf({
      *         id: "id"
      *     })
      */
-    postV1SalesActsPdf(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesActsPdf(request, requestOptions));
+    actsPdf(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__actsPdf(request, requestOptions));
     }
-    async __postV1SalesActsPdf(request, requestOptions) {
+    async __actsPdf(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -2010,10 +2135,7 @@ class SalesClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -2021,12 +2143,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -2044,762 +2170,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/acts/pdf");
     }
     /**
-     * @param {NordletApi.PostV1OperationTypesCreateRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1OperationTypesCreate({
-     *         code: "code",
-     *         name: "name"
-     *     })
-     */
-    postV1OperationTypesCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1OperationTypesCreate(request, requestOptions));
-    }
-    async __postV1OperationTypesCreate(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/operation-types/create"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/operation-types/create");
-    }
-    /**
-     * @param {NordletApi.PostV1OperationTypesUpdateRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1OperationTypesUpdate({
-     *         id: "id"
-     *     })
-     */
-    postV1OperationTypesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1OperationTypesUpdate(request, requestOptions));
-    }
-    async __postV1OperationTypesUpdate(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/operation-types/update"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/operation-types/update");
-    }
-    /**
-     * @param {NordletApi.PostV1OperationTypesGetRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1OperationTypesGet({
-     *         id: "id"
-     *     })
-     */
-    postV1OperationTypesGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1OperationTypesGet(request, requestOptions));
-    }
-    async __postV1OperationTypesGet(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/operation-types/get"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/operation-types/get");
-    }
-    /**
-     * @param {NordletApi.PostV1OperationTypesDeleteRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1OperationTypesDelete({
-     *         id: "id"
-     *     })
-     */
-    postV1OperationTypesDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1OperationTypesDelete(request, requestOptions));
-    }
-    async __postV1OperationTypesDelete(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/operation-types/delete"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/operation-types/delete");
-    }
-    /**
-     * @param {NordletApi.PostV1OperationTypesListRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1OperationTypesList()
-     */
-    postV1OperationTypesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1OperationTypesList(request, requestOptions));
-    }
-    async __postV1OperationTypesList(request = {}, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/operation-types/list"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/operation-types/list");
-    }
-    /**
-     * @param {NordletApi.PostV1DocumentSeriesCreateRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1DocumentSeriesCreate({
-     *         prefix: "prefix"
-     *     })
-     */
-    postV1DocumentSeriesCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DocumentSeriesCreate(request, requestOptions));
-    }
-    async __postV1DocumentSeriesCreate(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/document-series/create"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/document-series/create");
-    }
-    /**
-     * @param {NordletApi.PostV1DocumentSeriesUpdateRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1DocumentSeriesUpdate({
-     *         id: "id"
-     *     })
-     */
-    postV1DocumentSeriesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DocumentSeriesUpdate(request, requestOptions));
-    }
-    async __postV1DocumentSeriesUpdate(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/document-series/update"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/document-series/update");
-    }
-    /**
-     * @param {NordletApi.PostV1DocumentSeriesGetRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1DocumentSeriesGet({
-     *         id: "id"
-     *     })
-     */
-    postV1DocumentSeriesGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DocumentSeriesGet(request, requestOptions));
-    }
-    async __postV1DocumentSeriesGet(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/document-series/get"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/document-series/get");
-    }
-    /**
-     * @param {NordletApi.PostV1DocumentSeriesDeleteRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1DocumentSeriesDelete({
-     *         id: "id"
-     *     })
-     */
-    postV1DocumentSeriesDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DocumentSeriesDelete(request, requestOptions));
-    }
-    async __postV1DocumentSeriesDelete(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/document-series/delete"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/document-series/delete");
-    }
-    /**
-     * @param {NordletApi.PostV1DocumentSeriesListRequest} request
-     * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.sales.postV1DocumentSeriesList()
-     */
-    postV1DocumentSeriesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DocumentSeriesList(request, requestOptions));
-    }
-    async __postV1DocumentSeriesList(request = {}, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/document-series/list"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/document-series/list");
-    }
-    /**
-     * @param {NordletApi.PostV1SalesRecognitionComputeRequest} request
+     * @param {NordletApi.RecognitionComputeSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRecognitionCompute()
+     *     await client.sales.recognitionCompute()
      */
-    postV1SalesRecognitionCompute(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRecognitionCompute(request, requestOptions));
+    recognitionCompute(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recognitionCompute(request, requestOptions));
     }
-    async __postV1SalesRecognitionCompute(request = {}, requestOptions) {
+    async __recognitionCompute(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -2830,12 +2221,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -2853,25 +2248,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/recognition/compute");
     }
     /**
-     * @param {NordletApi.PostV1SalesRecognitionRunRequest} request
+     * @param {NordletApi.RecognitionRunSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRecognitionRun()
+     *     await client.sales.recognitionRun()
      */
-    postV1SalesRecognitionRun(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRecognitionRun(request, requestOptions));
+    recognitionRun(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recognitionRun(request, requestOptions));
     }
-    async __postV1SalesRecognitionRun(request = {}, requestOptions) {
+    async __recognitionRun(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -2902,12 +2299,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -2925,28 +2326,30 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/recognition/run");
     }
     /**
-     * @param {NordletApi.PostV1SalesRecognitionProgressRequest} request
+     * @param {NordletApi.RecognitionProgressSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRecognitionProgress({
+     *     await client.sales.recognitionProgress({
      *         invoiceLineId: "invoiceLineId",
-     *         percentComplete: "percentComplete"
+     *         percentComplete: "121.00"
      *     })
      */
-    postV1SalesRecognitionProgress(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRecognitionProgress(request, requestOptions));
+    recognitionProgress(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recognitionProgress(request, requestOptions));
     }
-    async __postV1SalesRecognitionProgress(request, requestOptions) {
+    async __recognitionProgress(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -2977,12 +2380,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -3002,28 +2409,30 @@ class SalesClient {
     /**
      * Apply an IFRS 15 contract modification to a deferred invoice line. Prospective: cancel the pending schedule and respread the unrecognized remainder over the new terms. Cumulative catch-up (ratable only): recompute revenue as if the new terms applied from the start and post the difference immediately.
      *
-     * @param {NordletApi.PostV1SalesRecognitionModifyRequest} request
+     * @param {NordletApi.RecognitionModifySalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRecognitionModify({
+     *     await client.sales.recognitionModify({
      *         invoiceLineId: "invoiceLineId",
      *         approach: "prospective"
      *     })
      */
-    postV1SalesRecognitionModify(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRecognitionModify(request, requestOptions));
+    recognitionModify(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recognitionModify(request, requestOptions));
     }
-    async __postV1SalesRecognitionModify(request, requestOptions) {
+    async __recognitionModify(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -3054,12 +2463,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -3077,25 +2490,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/recognition/modify");
     }
     /**
-     * @param {NordletApi.PostV1SalesRecognitionRunsListRequest} request
+     * @param {NordletApi.RecognitionRunsListSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRecognitionRunsList()
+     *     await client.sales.recognitionRunsList()
      */
-    postV1SalesRecognitionRunsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRecognitionRunsList(request, requestOptions));
+    recognitionRunsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recognitionRunsList(request, requestOptions));
     }
-    async __postV1SalesRecognitionRunsList(request = {}, requestOptions) {
+    async __recognitionRunsList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -3126,12 +2541,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -3149,25 +2568,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/recognition/runs/list");
     }
     /**
-     * @param {NordletApi.PostV1SalesRecognitionSummaryRequest} request
+     * @param {NordletApi.RecognitionSummarySalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRecognitionSummary()
+     *     await client.sales.recognitionSummary()
      */
-    postV1SalesRecognitionSummary(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRecognitionSummary(request, requestOptions));
+    recognitionSummary(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recognitionSummary(request, requestOptions));
     }
-    async __postV1SalesRecognitionSummary(request = {}, requestOptions) {
+    async __recognitionSummary(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -3198,12 +2619,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -3221,25 +2646,27 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/recognition/summary");
     }
     /**
-     * @param {NordletApi.PostV1SalesRefundLiabilityListRequest} request
+     * @param {NordletApi.RefundLiabilityListSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRefundLiabilityList()
+     *     await client.sales.refundLiabilityList()
      */
-    postV1SalesRefundLiabilityList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRefundLiabilityList(request, requestOptions));
+    refundLiabilityList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__refundLiabilityList(request, requestOptions));
     }
-    async __postV1SalesRefundLiabilityList(request = {}, requestOptions) {
+    async __refundLiabilityList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -3270,12 +2697,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -3293,28 +2724,30 @@ class SalesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/sales/refund-liability/list");
     }
     /**
-     * @param {NordletApi.PostV1SalesRefundLiabilityTrueUpRequest} request
+     * @param {NordletApi.RefundLiabilityTrueUpSalesRequest} request
      * @param {SalesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link NordletApi.BadRequestError}
      * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.PaymentRequiredError}
      * @throws {@link NordletApi.ForbiddenError}
      * @throws {@link NordletApi.NotFoundError}
      * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.ContentTooLargeError}
      * @throws {@link NordletApi.UnprocessableEntityError}
      * @throws {@link NordletApi.TooManyRequestsError}
      * @throws {@link NordletApi.InternalServerError}
      *
      * @example
-     *     await client.sales.postV1SalesRefundLiabilityTrueUp({
+     *     await client.sales.refundLiabilityTrueUp({
      *         invoiceId: "invoiceId",
-     *         estimatedTotal: "estimatedTotal"
+     *         estimatedTotal: "121.0000"
      *     })
      */
-    postV1SalesRefundLiabilityTrueUp(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1SalesRefundLiabilityTrueUp(request, requestOptions));
+    refundLiabilityTrueUp(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__refundLiabilityTrueUp(request, requestOptions));
     }
-    async __postV1SalesRefundLiabilityTrueUp(request, requestOptions) {
+    async __refundLiabilityTrueUp(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -3345,12 +2778,16 @@ class SalesClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429: