nordlet 0.3.4 → 0.3.7

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

@@ -48,30 +48,32 @@ class PurchasesClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {NordletApi.PostV1PurchasesInvoicesCreateRequest} request
+     * @param {NordletApi.InvoicesCreatePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesCreate({
+     *     await client.purchases.invoicesCreate({
      *         partnerId: "partnerId",
      *         documentNumber: "documentNumber",
-     *         documentDate: "documentDate",
+     *         documentDate: "2026-07-01",
      *         lines: [{}]
      *     })
      */
-    postV1PurchasesInvoicesCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesCreate(request, requestOptions));
+    invoicesCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesCreate(request, requestOptions));
     }
-    async __postV1PurchasesInvoicesCreate(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({
@@ -102,12 +104,16 @@ class PurchasesClient {
                     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:
@@ -125,27 +131,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/invoices/create");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesInvoicesGetRequest} request
+     * @param {NordletApi.InvoicesGetPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesGet({
+     *     await client.purchases.invoicesGet({
      *         id: "id"
      *     })
      */
-    postV1PurchasesInvoicesGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesGet(request, requestOptions));
+    invoicesGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesGet(request, requestOptions));
     }
-    async __postV1PurchasesInvoicesGet(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({
@@ -176,12 +184,16 @@ class PurchasesClient {
                     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:
@@ -199,27 +211,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/invoices/get");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesInvoicesUpdateRequest} request
+     * @param {NordletApi.InvoicesUpdatePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesUpdate({
+     *     await client.purchases.invoicesUpdate({
      *         id: "id"
      *     })
      */
-    postV1PurchasesInvoicesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesUpdate(request, requestOptions));
+    invoicesUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesUpdate(request, requestOptions));
     }
-    async __postV1PurchasesInvoicesUpdate(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({
@@ -250,12 +264,16 @@ class PurchasesClient {
                     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:
@@ -273,27 +291,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/invoices/update");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesInvoicesDeleteRequest} request
+     * @param {NordletApi.InvoicesDeletePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesDelete({
+     *     await client.purchases.invoicesDelete({
      *         id: "id"
      *     })
      */
-    postV1PurchasesInvoicesDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesDelete(request, requestOptions));
+    invoicesDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesDelete(request, requestOptions));
     }
-    async __postV1PurchasesInvoicesDelete(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({
@@ -324,12 +344,16 @@ class PurchasesClient {
                     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:
@@ -347,27 +371,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/invoices/delete");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesInvoicesRegisterRequest} request
+     * @param {NordletApi.InvoicesRegisterPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesRegister({
+     *     await client.purchases.invoicesRegister({
      *         id: "id"
      *     })
      */
-    postV1PurchasesInvoicesRegister(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesRegister(request, requestOptions));
+    invoicesRegister(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesRegister(request, requestOptions));
     }
-    async __postV1PurchasesInvoicesRegister(request, requestOptions) {
+    async __invoicesRegister(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({
@@ -398,12 +424,16 @@ class PurchasesClient {
                     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:
@@ -421,25 +451,27 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/invoices/register");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesInvoicesListRequest} request
+     * @param {NordletApi.InvoicesListPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesList()
+     *     await client.purchases.invoicesList()
      */
-    postV1PurchasesInvoicesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesList(request, requestOptions));
+    invoicesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesList(request, requestOptions));
     }
-    async __postV1PurchasesInvoicesList(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({
@@ -470,12 +502,16 @@ class PurchasesClient {
                     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:
@@ -493,29 +529,31 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/invoices/list");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersCreateRequest} request
+     * @param {NordletApi.OrdersCreatePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersCreate({
+     *     await client.purchases.ordersCreate({
      *         partnerId: "partnerId",
-     *         orderDate: "orderDate",
+     *         orderDate: "2026-07-01",
      *         lines: [{}]
      *     })
      */
-    postV1PurchasesOrdersCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersCreate(request, requestOptions));
+    ordersCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersCreate(request, requestOptions));
     }
-    async __postV1PurchasesOrdersCreate(request, requestOptions) {
+    async __ordersCreate(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 +584,16 @@ class PurchasesClient {
                     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:
@@ -569,27 +611,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/create");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersUpdateRequest} request
+     * @param {NordletApi.OrdersUpdatePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersUpdate({
+     *     await client.purchases.ordersUpdate({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersUpdate(request, requestOptions));
+    ordersUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersUpdate(request, requestOptions));
     }
-    async __postV1PurchasesOrdersUpdate(request, requestOptions) {
+    async __ordersUpdate(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({
@@ -620,12 +664,16 @@ class PurchasesClient {
                     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:
@@ -643,27 +691,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/update");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersGetRequest} request
+     * @param {NordletApi.OrdersGetPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersGet({
+     *     await client.purchases.ordersGet({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersGet(request, requestOptions));
+    ordersGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersGet(request, requestOptions));
     }
-    async __postV1PurchasesOrdersGet(request, requestOptions) {
+    async __ordersGet(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({
@@ -694,12 +744,16 @@ class PurchasesClient {
                     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:
@@ -717,25 +771,27 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/get");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersListRequest} request
+     * @param {NordletApi.OrdersListPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersList()
+     *     await client.purchases.ordersList()
      */
-    postV1PurchasesOrdersList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersList(request, requestOptions));
+    ordersList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersList(request, requestOptions));
     }
-    async __postV1PurchasesOrdersList(request = {}, requestOptions) {
+    async __ordersList(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({
@@ -766,12 +822,16 @@ class PurchasesClient {
                     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:
@@ -789,27 +849,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/list");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersSubmitRequest} request
+     * @param {NordletApi.OrdersSubmitPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersSubmit({
+     *     await client.purchases.ordersSubmit({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersSubmit(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersSubmit(request, requestOptions));
+    ordersSubmit(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersSubmit(request, requestOptions));
     }
-    async __postV1PurchasesOrdersSubmit(request, requestOptions) {
+    async __ordersSubmit(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({
@@ -840,12 +902,16 @@ class PurchasesClient {
                     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:
@@ -863,27 +929,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/submit");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersApproveRequest} request
+     * @param {NordletApi.OrdersApprovePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersApprove({
+     *     await client.purchases.ordersApprove({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersApprove(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersApprove(request, requestOptions));
+    ordersApprove(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersApprove(request, requestOptions));
     }
-    async __postV1PurchasesOrdersApprove(request, requestOptions) {
+    async __ordersApprove(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({
@@ -914,12 +982,16 @@ class PurchasesClient {
                     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:
@@ -937,27 +1009,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/approve");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersRejectRequest} request
+     * @param {NordletApi.OrdersRejectPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersReject({
+     *     await client.purchases.ordersReject({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersReject(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersReject(request, requestOptions));
+    ordersReject(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersReject(request, requestOptions));
     }
-    async __postV1PurchasesOrdersReject(request, requestOptions) {
+    async __ordersReject(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({
@@ -988,12 +1062,16 @@ class PurchasesClient {
                     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:
@@ -1011,27 +1089,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/reject");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersCancelRequest} request
+     * @param {NordletApi.OrdersCancelPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersCancel({
+     *     await client.purchases.ordersCancel({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersCancel(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersCancel(request, requestOptions));
+    ordersCancel(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersCancel(request, requestOptions));
     }
-    async __postV1PurchasesOrdersCancel(request, requestOptions) {
+    async __ordersCancel(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({
@@ -1062,12 +1142,16 @@ class PurchasesClient {
                     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:
@@ -1085,27 +1169,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/cancel");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersCloseRequest} request
+     * @param {NordletApi.OrdersClosePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersClose({
+     *     await client.purchases.ordersClose({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersClose(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersClose(request, requestOptions));
+    ordersClose(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersClose(request, requestOptions));
     }
-    async __postV1PurchasesOrdersClose(request, requestOptions) {
+    async __ordersClose(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({
@@ -1136,12 +1222,16 @@ class PurchasesClient {
                     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:
@@ -1159,27 +1249,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/close");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesOrdersDeleteRequest} request
+     * @param {NordletApi.OrdersDeletePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersDelete({
+     *     await client.purchases.ordersDelete({
      *         id: "id"
      *     })
      */
-    postV1PurchasesOrdersDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersDelete(request, requestOptions));
+    ordersDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ordersDelete(request, requestOptions));
     }
-    async __postV1PurchasesOrdersDelete(request, requestOptions) {
+    async __ordersDelete(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({
@@ -1210,12 +1302,16 @@ class PurchasesClient {
                     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:
@@ -1233,32 +1329,34 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/delete");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesReceiptsCreateRequest} request
+     * @param {NordletApi.ReceiptsCreatePurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesReceiptsCreate({
+     *     await client.purchases.receiptsCreate({
      *         orderId: "orderId",
-     *         receiptDate: "receiptDate",
+     *         receiptDate: "2026-07-01",
      *         lines: [{
      *                 orderLineId: "orderLineId",
-     *                 quantity: "quantity"
+     *                 quantity: "121.0000"
      *             }]
      *     })
      */
-    postV1PurchasesReceiptsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesReceiptsCreate(request, requestOptions));
+    receiptsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__receiptsCreate(request, requestOptions));
     }
-    async __postV1PurchasesReceiptsCreate(request, requestOptions) {
+    async __receiptsCreate(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({
@@ -1289,12 +1387,16 @@ class PurchasesClient {
                     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:
@@ -1312,27 +1414,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/receipts/create");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesReceiptsGetRequest} request
+     * @param {NordletApi.ReceiptsGetPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesReceiptsGet({
+     *     await client.purchases.receiptsGet({
      *         id: "id"
      *     })
      */
-    postV1PurchasesReceiptsGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesReceiptsGet(request, requestOptions));
+    receiptsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__receiptsGet(request, requestOptions));
     }
-    async __postV1PurchasesReceiptsGet(request, requestOptions) {
+    async __receiptsGet(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({
@@ -1363,12 +1467,16 @@ class PurchasesClient {
                     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:
@@ -1386,25 +1494,27 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/receipts/get");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesReceiptsListRequest} request
+     * @param {NordletApi.ReceiptsListPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesReceiptsList()
+     *     await client.purchases.receiptsList()
      */
-    postV1PurchasesReceiptsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesReceiptsList(request, requestOptions));
+    receiptsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__receiptsList(request, requestOptions));
     }
-    async __postV1PurchasesReceiptsList(request = {}, requestOptions) {
+    async __receiptsList(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({
@@ -1435,12 +1545,16 @@ class PurchasesClient {
                     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:
@@ -1458,27 +1572,29 @@ class PurchasesClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/receipts/list");
     }
     /**
-     * @param {NordletApi.PostV1PurchasesInvoicesMatchRequest} request
+     * @param {NordletApi.InvoicesMatchPurchasesRequest} request
      * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesMatch({
+     *     await client.purchases.invoicesMatch({
      *         invoiceId: "invoiceId"
      *     })
      */
-    postV1PurchasesInvoicesMatch(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesMatch(request, requestOptions));
+    invoicesMatch(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__invoicesMatch(request, requestOptions));
     }
-    async __postV1PurchasesInvoicesMatch(request, requestOptions) {
+    async __invoicesMatch(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({
@@ -1509,12 +1625,16 @@ class PurchasesClient {
                     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: