nordlet 0.3.4 → 0.3.7

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

@@ -48,29 +48,31 @@ class DeclarationsClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtIntrastatComputeRequest} request
+     * @param {NordletApi.LtIntrastatComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtIntrastatCompute({
+     *     await client.declarations.ltIntrastatCompute({
      *         year: 1000000,
      *         month: 1000000,
      *         flow: "arrivals"
      *     })
      */
-    postV1DeclarationsLtIntrastatCompute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtIntrastatCompute(request, requestOptions));
+    ltIntrastatCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltIntrastatCompute(request, requestOptions));
     }
-    async __postV1DeclarationsLtIntrastatCompute(request, requestOptions) {
+    async __ltIntrastatCompute(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({
@@ -101,12 +103,16 @@ class DeclarationsClient {
                     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:
@@ -124,27 +130,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/intrastat/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtIvazGenerateRequest} request
+     * @param {NordletApi.LtIvazGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtIvazGenerate({
+     *     await client.declarations.ltIvazGenerate({
      *         waybillIds: ["waybillIds"]
      *     })
      */
-    postV1DeclarationsLtIvazGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtIvazGenerate(request, requestOptions));
+    ltIvazGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltIvazGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsLtIvazGenerate(request, requestOptions) {
+    async __ltIvazGenerate(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({
@@ -175,12 +183,16 @@ class DeclarationsClient {
                     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:
@@ -198,27 +210,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/ivaz/generate");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtIntrastatObligationRequest} request
+     * @param {NordletApi.LtIntrastatObligationDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtIntrastatObligation({
+     *     await client.declarations.ltIntrastatObligation({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsLtIntrastatObligation(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtIntrastatObligation(request, requestOptions));
+    ltIntrastatObligation(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltIntrastatObligation(request, requestOptions));
     }
-    async __postV1DeclarationsLtIntrastatObligation(request, requestOptions) {
+    async __ltIntrastatObligation(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({
@@ -249,12 +263,16 @@ class DeclarationsClient {
                     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:
@@ -272,28 +290,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/intrastat/obligation");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtIsafGenerateRequest} request
+     * @param {NordletApi.LtIsafGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtIsafGenerate({
+     *     await client.declarations.ltIsafGenerate({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsLtIsafGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtIsafGenerate(request, requestOptions));
+    ltIsafGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltIsafGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsLtIsafGenerate(request, requestOptions) {
+    async __ltIsafGenerate(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 DeclarationsClient {
                     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,28 +371,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/isaf/generate");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtFr0600ComputeRequest} request
+     * @param {NordletApi.LtFr0600ComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtFr0600Compute({
+     *     await client.declarations.ltFr0600Compute({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsLtFr0600Compute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtFr0600Compute(request, requestOptions));
+    ltFr0600Compute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltFr0600Compute(request, requestOptions));
     }
-    async __postV1DeclarationsLtFr0600Compute(request, requestOptions) {
+    async __ltFr0600Compute(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({
@@ -399,12 +425,16 @@ class DeclarationsClient {
                     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:
@@ -422,28 +452,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/fr0600/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtGpm313ComputeRequest} request
+     * @param {NordletApi.LtGpm313ComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtGpm313Compute({
+     *     await client.declarations.ltGpm313Compute({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsLtGpm313Compute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtGpm313Compute(request, requestOptions));
+    ltGpm313Compute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltGpm313Compute(request, requestOptions));
     }
-    async __postV1DeclarationsLtGpm313Compute(request, requestOptions) {
+    async __ltGpm313Compute(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({
@@ -474,12 +506,16 @@ class DeclarationsClient {
                     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:
@@ -497,28 +533,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/gpm313/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtSamComputeRequest} request
+     * @param {NordletApi.LtSamComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtSamCompute({
+     *     await client.declarations.ltSamCompute({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsLtSamCompute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtSamCompute(request, requestOptions));
+    ltSamCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltSamCompute(request, requestOptions));
     }
-    async __postV1DeclarationsLtSamCompute(request, requestOptions) {
+    async __ltSamCompute(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({
@@ -549,12 +587,16 @@ class DeclarationsClient {
                     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:
@@ -572,29 +614,31 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/sam/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtSdGenerateRequest} request
+     * @param {NordletApi.LtSdGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtSdGenerate({
+     *     await client.declarations.ltSdGenerate({
      *         type: "1-SD",
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1DeclarationsLtSdGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtSdGenerate(request, requestOptions));
+    ltSdGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltSdGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsLtSdGenerate(request, requestOptions) {
+    async __ltSdGenerate(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({
@@ -625,12 +669,16 @@ class DeclarationsClient {
                     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:
@@ -648,28 +696,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/sd/generate");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtSaftGenerateRequest} request
+     * @param {NordletApi.LtSaftGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtSaftGenerate({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.declarations.ltSaftGenerate({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1DeclarationsLtSaftGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtSaftGenerate(request, requestOptions));
+    ltSaftGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltSaftGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsLtSaftGenerate(request, requestOptions) {
+    async __ltSaftGenerate(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({
@@ -700,12 +750,16 @@ class DeclarationsClient {
                     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:
@@ -723,27 +777,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/saft/generate");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtIvazAmendRequest} request
+     * @param {NordletApi.LtIvazAmendDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtIvazAmend({
+     *     await client.declarations.ltIvazAmend({
      *         waybillIds: ["waybillIds"]
      *     })
      */
-    postV1DeclarationsLtIvazAmend(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtIvazAmend(request, requestOptions));
+    ltIvazAmend(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltIvazAmend(request, requestOptions));
     }
-    async __postV1DeclarationsLtIvazAmend(request, requestOptions) {
+    async __ltIvazAmend(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({
@@ -774,12 +830,16 @@ class DeclarationsClient {
                     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:
@@ -797,30 +857,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/ivaz/amend");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtIvazCancelRequest} request
+     * @param {NordletApi.LtIvazCancelDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtIvazCancel({
+     *     await client.declarations.ltIvazCancel({
      *         entries: [{
      *                 waybillId: "waybillId",
      *                 reason: "1"
      *             }]
      *     })
      */
-    postV1DeclarationsLtIvazCancel(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtIvazCancel(request, requestOptions));
+    ltIvazCancel(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltIvazCancel(request, requestOptions));
     }
-    async __postV1DeclarationsLtIvazCancel(request, requestOptions) {
+    async __ltIvazCancel(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({
@@ -851,12 +913,16 @@ class DeclarationsClient {
                     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:
@@ -874,28 +940,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/ivaz/cancel");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtFr0564ComputeRequest} request
+     * @param {NordletApi.LtFr0564ComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtFr0564Compute({
+     *     await client.declarations.ltFr0564Compute({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsLtFr0564Compute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtFr0564Compute(request, requestOptions));
+    ltFr0564Compute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltFr0564Compute(request, requestOptions));
     }
-    async __postV1DeclarationsLtFr0564Compute(request, requestOptions) {
+    async __ltFr0564Compute(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({
@@ -926,12 +994,16 @@ class DeclarationsClient {
                     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:
@@ -949,27 +1021,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/fr0564/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtGpm312ComputeRequest} request
+     * @param {NordletApi.LtGpm312ComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtGpm312Compute({
+     *     await client.declarations.ltGpm312Compute({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsLtGpm312Compute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtGpm312Compute(request, requestOptions));
+    ltGpm312Compute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltGpm312Compute(request, requestOptions));
     }
-    async __postV1DeclarationsLtGpm312Compute(request, requestOptions) {
+    async __ltGpm312Compute(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({
@@ -1000,12 +1074,16 @@ class DeclarationsClient {
                     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:
@@ -1023,27 +1101,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/gpm312/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsLtPln204ComputeRequest} request
+     * @param {NordletApi.LtPln204ComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtPln204Compute({
+     *     await client.declarations.ltPln204Compute({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsLtPln204Compute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtPln204Compute(request, requestOptions));
+    ltPln204Compute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltPln204Compute(request, requestOptions));
     }
-    async __postV1DeclarationsLtPln204Compute(request, requestOptions) {
+    async __ltPln204Compute(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({
@@ -1074,12 +1154,16 @@ class DeclarationsClient {
                     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:
@@ -1097,28 +1181,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/lt/pln204/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuOssComputeRequest} request
+     * @param {NordletApi.EuOssComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuOssCompute({
+     *     await client.declarations.euOssCompute({
      *         year: 1000000,
      *         quarter: 1000000
      *     })
      */
-    postV1DeclarationsEuOssCompute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuOssCompute(request, requestOptions));
+    euOssCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euOssCompute(request, requestOptions));
     }
-    async __postV1DeclarationsEuOssCompute(request, requestOptions) {
+    async __euOssCompute(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({
@@ -1149,12 +1235,16 @@ class DeclarationsClient {
                     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:
@@ -1172,28 +1262,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/oss/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuIossComputeRequest} request
+     * @param {NordletApi.EuIossComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuIossCompute({
+     *     await client.declarations.euIossCompute({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsEuIossCompute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuIossCompute(request, requestOptions));
+    euIossCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euIossCompute(request, requestOptions));
     }
-    async __postV1DeclarationsEuIossCompute(request, requestOptions) {
+    async __euIossCompute(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({
@@ -1224,12 +1316,16 @@ class DeclarationsClient {
                     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:
@@ -1247,25 +1343,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/ioss/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuDistanceSalesThresholdGetRequest} request
+     * @param {NordletApi.EuDistanceSalesThresholdGetDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuDistanceSalesThresholdGet()
+     *     await client.declarations.euDistanceSalesThresholdGet()
      */
-    postV1DeclarationsEuDistanceSalesThresholdGet(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuDistanceSalesThresholdGet(request, requestOptions));
+    euDistanceSalesThresholdGet(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euDistanceSalesThresholdGet(request, requestOptions));
     }
-    async __postV1DeclarationsEuDistanceSalesThresholdGet(request = {}, requestOptions) {
+    async __euDistanceSalesThresholdGet(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({
@@ -1296,12 +1394,16 @@ class DeclarationsClient {
                     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:
@@ -1319,25 +1421,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/distance-sales-threshold/get");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuUnionTurnoverGetRequest} request
+     * @param {NordletApi.EuUnionTurnoverGetDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuUnionTurnoverGet()
+     *     await client.declarations.euUnionTurnoverGet()
      */
-    postV1DeclarationsEuUnionTurnoverGet(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuUnionTurnoverGet(request, requestOptions));
+    euUnionTurnoverGet(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euUnionTurnoverGet(request, requestOptions));
     }
-    async __postV1DeclarationsEuUnionTurnoverGet(request = {}, requestOptions) {
+    async __euUnionTurnoverGet(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({
@@ -1368,12 +1472,16 @@ class DeclarationsClient {
                     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:
@@ -1391,28 +1499,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/union-turnover/get");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuSmeCrossBorderReportComputeRequest} request
+     * @param {NordletApi.EuSmeCrossBorderReportComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuSmeCrossBorderReportCompute({
+     *     await client.declarations.euSmeCrossBorderReportCompute({
      *         year: 1000000,
      *         quarter: 1000000
      *     })
      */
-    postV1DeclarationsEuSmeCrossBorderReportCompute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuSmeCrossBorderReportCompute(request, requestOptions));
+    euSmeCrossBorderReportCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euSmeCrossBorderReportCompute(request, requestOptions));
     }
-    async __postV1DeclarationsEuSmeCrossBorderReportCompute(request, requestOptions) {
+    async __euSmeCrossBorderReportCompute(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({
@@ -1443,12 +1553,16 @@ class DeclarationsClient {
                     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:
@@ -1466,25 +1580,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/sme-cross-border-report/compute");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuSmeThresholdsListRequest} request
+     * @param {NordletApi.EuSmeThresholdsListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuSmeThresholdsList()
+     *     await client.declarations.euSmeThresholdsList()
      */
-    postV1DeclarationsEuSmeThresholdsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuSmeThresholdsList(request, requestOptions));
+    euSmeThresholdsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euSmeThresholdsList(request, requestOptions));
     }
-    async __postV1DeclarationsEuSmeThresholdsList(request = {}, requestOptions) {
+    async __euSmeThresholdsList(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({
@@ -1515,12 +1631,16 @@ class DeclarationsClient {
                     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:
@@ -1538,25 +1658,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/sme-thresholds/list");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuSmeThresholdGetRequest} request
+     * @param {NordletApi.EuSmeThresholdGetDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuSmeThresholdGet()
+     *     await client.declarations.euSmeThresholdGet()
      */
-    postV1DeclarationsEuSmeThresholdGet(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuSmeThresholdGet(request, requestOptions));
+    euSmeThresholdGet(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euSmeThresholdGet(request, requestOptions));
     }
-    async __postV1DeclarationsEuSmeThresholdGet(request = {}, requestOptions) {
+    async __euSmeThresholdGet(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({
@@ -1587,12 +1709,16 @@ class DeclarationsClient {
                     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:
@@ -1610,25 +1736,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/sme-threshold/get");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuVatReturnPacksListRequest} request
+     * @param {NordletApi.EuVatReturnPacksListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuVatReturnPacksList()
+     *     await client.declarations.euVatReturnPacksList()
      */
-    postV1DeclarationsEuVatReturnPacksList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuVatReturnPacksList(request, requestOptions));
+    euVatReturnPacksList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euVatReturnPacksList(request, requestOptions));
     }
-    async __postV1DeclarationsEuVatReturnPacksList(request = {}, requestOptions) {
+    async __euVatReturnPacksList(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({
@@ -1659,12 +1787,16 @@ class DeclarationsClient {
                     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:
@@ -1682,29 +1814,31 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/vat-return/packs/list");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsEuVatReturnComputeRequest} request
+     * @param {NordletApi.EuVatReturnComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEuVatReturnCompute({
+     *     await client.declarations.euVatReturnCompute({
      *         countryCode: "countryCode",
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsEuVatReturnCompute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuVatReturnCompute(request, requestOptions));
+    euVatReturnCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euVatReturnCompute(request, requestOptions));
     }
-    async __postV1DeclarationsEuVatReturnCompute(request, requestOptions) {
+    async __euVatReturnCompute(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({
@@ -1735,12 +1869,16 @@ class DeclarationsClient {
                     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:
@@ -1760,30 +1898,32 @@ class DeclarationsClient {
     /**
      * Generate the Polish JPK_V7M(3) file (VAT declaration with evidence) for a month, per the MF schema in force since February 2026. Amounts must already be in PLN; rows are marked BFK until a KSeF integration supplies invoice numbers. Review the warnings before submitting via e-dokumenty.mf.gov.pl.
      *
-     * @param {NordletApi.PostV1DeclarationsPlJpkV7MGenerateRequest} request
+     * @param {NordletApi.PlJpkV7MGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlJpkV7MGenerate({
+     *     await client.declarations.plJpkV7MGenerate({
      *         year: 1000000,
      *         month: 1000000,
      *         kodUrzedu: "kodUrzedu",
      *         email: "email"
      *     })
      */
-    postV1DeclarationsPlJpkV7MGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlJpkV7MGenerate(request, requestOptions));
+    plJpkV7MGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plJpkV7MGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsPlJpkV7MGenerate(request, requestOptions) {
+    async __plJpkV7MGenerate(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({
@@ -1814,12 +1954,16 @@ class DeclarationsClient {
                     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:
@@ -1839,28 +1983,30 @@ class DeclarationsClient {
     /**
      * Build the rows of the Polish recapitulative statement VAT-UE for a month: section C intra-Community supplies of goods, section D intra-Community acquisitions, section E services taxed where the customer is established. Amounts are full złoty per counterparty. The VAT-UE(5) file itself goes out from the EU sales list deadline in the calendar.
      *
-     * @param {NordletApi.PostV1DeclarationsPlVatUeGenerateRequest} request
+     * @param {NordletApi.PlVatUeGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlVatUeGenerate({
+     *     await client.declarations.plVatUeGenerate({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsPlVatUeGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlVatUeGenerate(request, requestOptions));
+    plVatUeGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plVatUeGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsPlVatUeGenerate(request, requestOptions) {
+    async __plVatUeGenerate(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({
@@ -1891,12 +2037,16 @@ class DeclarationsClient {
                     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:
@@ -1916,29 +2066,31 @@ class DeclarationsClient {
     /**
      * Build the rows of the Polish INTRASTAT declaration for a month, arrivals or dispatches, grouped by CN code, partner country, country of origin, partner VAT number, nature of transaction, transport and delivery terms. Values are whole złoty converted at the invoice rate; credit notes with goods lines are returns (code 21). Goods without a CN code are left out and named in the warnings. The IST message itself goes out from the Intrastat deadline in the calendar.
      *
-     * @param {NordletApi.PostV1DeclarationsPlIntrastatGenerateRequest} request
+     * @param {NordletApi.PlIntrastatGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlIntrastatGenerate({
+     *     await client.declarations.plIntrastatGenerate({
      *         year: 1000000,
      *         month: 1000000,
      *         flow: "arrivals"
      *     })
      */
-    postV1DeclarationsPlIntrastatGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlIntrastatGenerate(request, requestOptions));
+    plIntrastatGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plIntrastatGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsPlIntrastatGenerate(request, requestOptions) {
+    async __plIntrastatGenerate(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({
@@ -1969,12 +2121,16 @@ class DeclarationsClient {
                     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:
@@ -1994,28 +2150,30 @@ class DeclarationsClient {
     /**
      * List the invoices KSeF holds for this company as the buyer, for a window of acquisition timestamps. Each row carries the KSeF number and, when the document number matches a registered purchase invoice, the invoice it belongs to.
      *
-     * @param {NordletApi.PostV1DeclarationsPlKsefReceivedListRequest} request
+     * @param {NordletApi.PlKsefReceivedListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlKsefReceivedList({
+     *     await client.declarations.plKsefReceivedList({
      *         from: "2024-01-15T09:30:00Z",
      *         to: "2024-01-15T09:30:00Z"
      *     })
      */
-    postV1DeclarationsPlKsefReceivedList(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlKsefReceivedList(request, requestOptions));
+    plKsefReceivedList(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plKsefReceivedList(request, requestOptions));
     }
-    async __postV1DeclarationsPlKsefReceivedList(request, requestOptions) {
+    async __plKsefReceivedList(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({
@@ -2046,12 +2204,16 @@ class DeclarationsClient {
                     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:
@@ -2071,27 +2233,29 @@ class DeclarationsClient {
     /**
      * Read one invoice out of KSeF by its national number. With a purchase invoice given, the KSeF number is written onto that invoice, which is what makes the purchase row of JPK_V7M carry NrKSeF instead of the BFK marker.
      *
-     * @param {NordletApi.PostV1DeclarationsPlKsefReceivedFetchRequest} request
+     * @param {NordletApi.PlKsefReceivedFetchDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlKsefReceivedFetch({
+     *     await client.declarations.plKsefReceivedFetch({
      *         ksefNumber: "ksefNumber"
      *     })
      */
-    postV1DeclarationsPlKsefReceivedFetch(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlKsefReceivedFetch(request, requestOptions));
+    plKsefReceivedFetch(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plKsefReceivedFetch(request, requestOptions));
     }
-    async __postV1DeclarationsPlKsefReceivedFetch(request, requestOptions) {
+    async __plKsefReceivedFetch(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({
@@ -2122,12 +2286,16 @@ class DeclarationsClient {
                     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:
@@ -2147,25 +2315,27 @@ class DeclarationsClient {
     /**
      * The UPO for a KSeF session. KSeF issues one receipt per session rather than per invoice, so the session reference number from the send is what identifies it.
      *
-     * @param {NordletApi.PostV1DeclarationsPlKsefReceiptRequest} request
+     * @param {NordletApi.PlKsefReceiptDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlKsefReceipt()
+     *     await client.declarations.plKsefReceipt()
      */
-    postV1DeclarationsPlKsefReceipt(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlKsefReceipt(request, requestOptions));
+    plKsefReceipt(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plKsefReceipt(request, requestOptions));
     }
-    async __postV1DeclarationsPlKsefReceipt(request = {}, requestOptions) {
+    async __plKsefReceipt(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({
@@ -2196,12 +2366,16 @@ class DeclarationsClient {
                     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:
@@ -2221,27 +2395,29 @@ class DeclarationsClient {
     /**
      * The differences between the accounting result and the taxable profit: non-deductible expenses, income added to or left out of the tax base, extra deductible expenses, donations, losses carried forward, reliefs and tax credits. The annual corporate income tax return is built from them.
      *
-     * @param {NordletApi.PostV1DeclarationsTaxAdjustmentsListRequest} request
+     * @param {NordletApi.TaxAdjustmentsListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.taxAdjustmentsRecordedForATaxYear({
+     *     await client.declarations.taxAdjustmentsList({
      *         year: 1000000
      *     })
      */
-    taxAdjustmentsRecordedForATaxYear(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__taxAdjustmentsRecordedForATaxYear(request, requestOptions));
+    taxAdjustmentsList(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxAdjustmentsList(request, requestOptions));
     }
-    async __taxAdjustmentsRecordedForATaxYear(request, requestOptions) {
+    async __taxAdjustmentsList(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({
@@ -2272,12 +2448,16 @@ class DeclarationsClient {
                     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:
@@ -2295,30 +2475,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/tax-adjustments/list");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsTaxAdjustmentsCreateRequest} request
+     * @param {NordletApi.TaxAdjustmentsCreateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.recordATaxAdjustmentForATaxYear({
+     *     await client.declarations.taxAdjustmentsCreate({
      *         year: 1000000,
      *         kind: "non_deductible",
-     *         amount: "amount",
+     *         amount: "121.00",
      *         description: "description"
      *     })
      */
-    recordATaxAdjustmentForATaxYear(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__recordATaxAdjustmentForATaxYear(request, requestOptions));
+    taxAdjustmentsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxAdjustmentsCreate(request, requestOptions));
     }
-    async __recordATaxAdjustmentForATaxYear(request, requestOptions) {
+    async __taxAdjustmentsCreate(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({
@@ -2349,12 +2531,16 @@ class DeclarationsClient {
                     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:
@@ -2372,27 +2558,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/tax-adjustments/create");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsTaxAdjustmentsUpdateRequest} request
+     * @param {NordletApi.TaxAdjustmentsUpdateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.changeARecordedTaxAdjustment({
+     *     await client.declarations.taxAdjustmentsUpdate({
      *         id: "id"
      *     })
      */
-    changeARecordedTaxAdjustment(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__changeARecordedTaxAdjustment(request, requestOptions));
+    taxAdjustmentsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxAdjustmentsUpdate(request, requestOptions));
     }
-    async __changeARecordedTaxAdjustment(request, requestOptions) {
+    async __taxAdjustmentsUpdate(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({
@@ -2423,12 +2611,16 @@ class DeclarationsClient {
                     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:
@@ -2446,27 +2638,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/tax-adjustments/update");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsTaxAdjustmentsDeleteRequest} request
+     * @param {NordletApi.TaxAdjustmentsDeleteDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.removeARecordedTaxAdjustment({
+     *     await client.declarations.taxAdjustmentsDelete({
      *         id: "id"
      *     })
      */
-    removeARecordedTaxAdjustment(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__removeARecordedTaxAdjustment(request, requestOptions));
+    taxAdjustmentsDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxAdjustmentsDelete(request, requestOptions));
     }
-    async __removeARecordedTaxAdjustment(request, requestOptions) {
+    async __taxAdjustmentsDelete(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({
@@ -2497,12 +2691,16 @@ class DeclarationsClient {
                     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:
@@ -2522,28 +2720,30 @@ class DeclarationsClient {
     /**
      * What the company has paid the administration towards a tax before the return is filed: payments on account, tax withheld at source by others, a final settlement, and a refund received. Returns report these on their own lines, so the amount they ask for is the balance.
      *
-     * @param {NordletApi.PostV1DeclarationsTaxPaymentsListRequest} request
+     * @param {NordletApi.TaxPaymentsListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.paymentsAlreadyMadeTowardsATaxOfAYear({
+     *     await client.declarations.taxPaymentsList({
      *         tax: "corporate_income_tax",
      *         year: 1000000
      *     })
      */
-    paymentsAlreadyMadeTowardsATaxOfAYear(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__paymentsAlreadyMadeTowardsATaxOfAYear(request, requestOptions));
+    taxPaymentsList(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxPaymentsList(request, requestOptions));
     }
-    async __paymentsAlreadyMadeTowardsATaxOfAYear(request, requestOptions) {
+    async __taxPaymentsList(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({
@@ -2574,12 +2774,16 @@ class DeclarationsClient {
                     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:
@@ -2597,32 +2801,34 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/tax-payments/list");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsTaxPaymentsCreateRequest} request
+     * @param {NordletApi.TaxPaymentsCreateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.recordAPaymentMadeTowardsATax({
+     *     await client.declarations.taxPaymentsCreate({
      *         tax: "corporate_income_tax",
      *         year: 1000000,
      *         kind: "advance",
-     *         amount: "amount",
-     *         paidOn: "paidOn",
+     *         amount: "121.00",
+     *         paidOn: "2026-07-01",
      *         description: "description"
      *     })
      */
-    recordAPaymentMadeTowardsATax(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__recordAPaymentMadeTowardsATax(request, requestOptions));
+    taxPaymentsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxPaymentsCreate(request, requestOptions));
     }
-    async __recordAPaymentMadeTowardsATax(request, requestOptions) {
+    async __taxPaymentsCreate(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({
@@ -2653,12 +2859,16 @@ class DeclarationsClient {
                     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:
@@ -2676,27 +2886,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/tax-payments/create");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsTaxPaymentsUpdateRequest} request
+     * @param {NordletApi.TaxPaymentsUpdateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.changeARecordedTaxPayment({
+     *     await client.declarations.taxPaymentsUpdate({
      *         id: "id"
      *     })
      */
-    changeARecordedTaxPayment(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__changeARecordedTaxPayment(request, requestOptions));
+    taxPaymentsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxPaymentsUpdate(request, requestOptions));
     }
-    async __changeARecordedTaxPayment(request, requestOptions) {
+    async __taxPaymentsUpdate(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({
@@ -2727,12 +2939,16 @@ class DeclarationsClient {
                     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:
@@ -2750,27 +2966,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/tax-payments/update");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsTaxPaymentsDeleteRequest} request
+     * @param {NordletApi.TaxPaymentsDeleteDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.removeARecordedTaxPayment({
+     *     await client.declarations.taxPaymentsDelete({
      *         id: "id"
      *     })
      */
-    removeARecordedTaxPayment(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__removeARecordedTaxPayment(request, requestOptions));
+    taxPaymentsDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__taxPaymentsDelete(request, requestOptions));
     }
-    async __removeARecordedTaxPayment(request, requestOptions) {
+    async __taxPaymentsDelete(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({
@@ -2801,12 +3019,16 @@ class DeclarationsClient {
                     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:
@@ -2826,27 +3048,29 @@ class DeclarationsClient {
     /**
      * Whether the general meeting adopted the annual accounts and on which date, the date the accounts were prepared, and which directors signed them. The annual accounts filed with the trade register are built from these facts.
      *
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsGetRequest} request
+     * @param {NordletApi.AnnualAccountsGetDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.adoptionAndSigningFactsOfTheAnnualAccountsOfAYear({
+     *     await client.declarations.annualAccountsGet({
      *         year: 1000000
      *     })
      */
-    adoptionAndSigningFactsOfTheAnnualAccountsOfAYear(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__adoptionAndSigningFactsOfTheAnnualAccountsOfAYear(request, requestOptions));
+    annualAccountsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsGet(request, requestOptions));
     }
-    async __adoptionAndSigningFactsOfTheAnnualAccountsOfAYear(request, requestOptions) {
+    async __annualAccountsGet(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({
@@ -2877,12 +3101,16 @@ class DeclarationsClient {
                     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:
@@ -2900,29 +3128,31 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/get");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsSetRequest} request
+     * @param {NordletApi.AnnualAccountsSetDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.recordTheAdoptionAndPreparationOfTheAnnualAccountsOfAYear({
+     *     await client.declarations.annualAccountsSet({
      *         year: 1000000,
      *         adopted: true,
-     *         dateOfPreparation: "dateOfPreparation"
+     *         dateOfPreparation: "2026-07-01"
      *     })
      */
-    recordTheAdoptionAndPreparationOfTheAnnualAccountsOfAYear(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__recordTheAdoptionAndPreparationOfTheAnnualAccountsOfAYear(request, requestOptions));
+    annualAccountsSet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsSet(request, requestOptions));
     }
-    async __recordTheAdoptionAndPreparationOfTheAnnualAccountsOfAYear(request, requestOptions) {
+    async __annualAccountsSet(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({
@@ -2953,12 +3183,16 @@ class DeclarationsClient {
                     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:
@@ -2976,30 +3210,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/set");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsSignaturesCreateRequest} request
+     * @param {NordletApi.AnnualAccountsSignaturesCreateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.recordWhetherADirectorSignedTheAnnualAccountsOfAYear({
+     *     await client.declarations.annualAccountsSignaturesCreate({
      *         year: 1000000,
      *         directorName: "directorName",
      *         directorType: "managing_current",
      *         signed: true
      *     })
      */
-    recordWhetherADirectorSignedTheAnnualAccountsOfAYear(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__recordWhetherADirectorSignedTheAnnualAccountsOfAYear(request, requestOptions));
+    annualAccountsSignaturesCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsSignaturesCreate(request, requestOptions));
     }
-    async __recordWhetherADirectorSignedTheAnnualAccountsOfAYear(request, requestOptions) {
+    async __annualAccountsSignaturesCreate(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({
@@ -3030,12 +3266,16 @@ class DeclarationsClient {
                     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:
@@ -3053,30 +3293,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/signatures/create");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsSignaturesUpdateRequest} request
+     * @param {NordletApi.AnnualAccountsSignaturesUpdateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.changeARecordedDirectorSignature({
+     *     await client.declarations.annualAccountsSignaturesUpdate({
      *         id: "id",
      *         directorName: "directorName",
      *         directorType: "managing_current",
      *         signed: true
      *     })
      */
-    changeARecordedDirectorSignature(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__changeARecordedDirectorSignature(request, requestOptions));
+    annualAccountsSignaturesUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsSignaturesUpdate(request, requestOptions));
     }
-    async __changeARecordedDirectorSignature(request, requestOptions) {
+    async __annualAccountsSignaturesUpdate(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({
@@ -3107,12 +3349,16 @@ class DeclarationsClient {
                     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:
@@ -3130,27 +3376,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/signatures/update");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsSignaturesDeleteRequest} request
+     * @param {NordletApi.AnnualAccountsSignaturesDeleteDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.removeARecordedDirectorSignature({
+     *     await client.declarations.annualAccountsSignaturesDelete({
      *         id: "id"
      *     })
      */
-    removeARecordedDirectorSignature(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__removeARecordedDirectorSignature(request, requestOptions));
+    annualAccountsSignaturesDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsSignaturesDelete(request, requestOptions));
     }
-    async __removeARecordedDirectorSignature(request, requestOptions) {
+    async __annualAccountsSignaturesDelete(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({
@@ -3181,12 +3429,16 @@ class DeclarationsClient {
                     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:
@@ -3204,30 +3456,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/signatures/delete");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsDistributionsCreateRequest} request
+     * @param {NordletApi.AnnualAccountsDistributionsCreateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.recordADecisionToDistributeProfitADividendAnInterimDividendOrAPaymentTreatedAsOne({
+     *     await client.declarations.annualAccountsDistributionsCreate({
      *         year: 1000000,
-     *         decidedOn: "decidedOn",
+     *         decidedOn: "2026-07-01",
      *         kind: "dividend",
-     *         amount: "amount"
+     *         amount: "121.00"
      *     })
      */
-    recordADecisionToDistributeProfitADividendAnInterimDividendOrAPaymentTreatedAsOne(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__recordADecisionToDistributeProfitADividendAnInterimDividendOrAPaymentTreatedAsOne(request, requestOptions));
+    annualAccountsDistributionsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsDistributionsCreate(request, requestOptions));
     }
-    async __recordADecisionToDistributeProfitADividendAnInterimDividendOrAPaymentTreatedAsOne(request, requestOptions) {
+    async __annualAccountsDistributionsCreate(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({
@@ -3258,12 +3512,16 @@ class DeclarationsClient {
                     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:
@@ -3281,30 +3539,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/distributions/create");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsDistributionsUpdateRequest} request
+     * @param {NordletApi.AnnualAccountsDistributionsUpdateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.changeARecordedProfitDistribution({
+     *     await client.declarations.annualAccountsDistributionsUpdate({
      *         id: "id",
-     *         decidedOn: "decidedOn",
+     *         decidedOn: "2026-07-01",
      *         kind: "dividend",
-     *         amount: "amount"
+     *         amount: "121.00"
      *     })
      */
-    changeARecordedProfitDistribution(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__changeARecordedProfitDistribution(request, requestOptions));
+    annualAccountsDistributionsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsDistributionsUpdate(request, requestOptions));
     }
-    async __changeARecordedProfitDistribution(request, requestOptions) {
+    async __annualAccountsDistributionsUpdate(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({
@@ -3335,12 +3595,16 @@ class DeclarationsClient {
                     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:
@@ -3358,27 +3622,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/distributions/update");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsDistributionsDeleteRequest} request
+     * @param {NordletApi.AnnualAccountsDistributionsDeleteDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.removeARecordedProfitDistribution({
+     *     await client.declarations.annualAccountsDistributionsDelete({
      *         id: "id"
      *     })
      */
-    removeARecordedProfitDistribution(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__removeARecordedProfitDistribution(request, requestOptions));
+    annualAccountsDistributionsDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsDistributionsDelete(request, requestOptions));
     }
-    async __removeARecordedProfitDistribution(request, requestOptions) {
+    async __annualAccountsDistributionsDelete(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({
@@ -3409,12 +3675,16 @@ class DeclarationsClient {
                     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:
@@ -3434,29 +3704,31 @@ class DeclarationsClient {
     /**
      * Links a file uploaded through files/upload (its storageKey) to the annual accounts of the year as the notes, the management report, the auditor statement, the profit appropriation resolution, the approval certificate, the general data sheet, the full report as a pdf, or another document. Deposits that must carry these documents take them from here.
      *
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsAttachmentsAddRequest} request
+     * @param {NordletApi.AnnualAccountsAttachmentsAddDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.attachAnUploadedDocumentToTheAnnualAccountsOfAYear({
+     *     await client.declarations.annualAccountsAttachmentsAdd({
      *         year: 1000000,
      *         kind: "full_report",
      *         ref: "ref"
      *     })
      */
-    attachAnUploadedDocumentToTheAnnualAccountsOfAYear(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__attachAnUploadedDocumentToTheAnnualAccountsOfAYear(request, requestOptions));
+    annualAccountsAttachmentsAdd(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsAttachmentsAdd(request, requestOptions));
     }
-    async __attachAnUploadedDocumentToTheAnnualAccountsOfAYear(request, requestOptions) {
+    async __annualAccountsAttachmentsAdd(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({
@@ -3487,12 +3759,16 @@ class DeclarationsClient {
                     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:
@@ -3510,27 +3786,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/annual-accounts/attachments/add");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAnnualAccountsAttachmentsDeleteRequest} request
+     * @param {NordletApi.AnnualAccountsAttachmentsDeleteDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.removeADocumentAttachedToTheAnnualAccountsAndDeleteItsFile({
+     *     await client.declarations.annualAccountsAttachmentsDelete({
      *         id: "id"
      *     })
      */
-    removeADocumentAttachedToTheAnnualAccountsAndDeleteItsFile(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__removeADocumentAttachedToTheAnnualAccountsAndDeleteItsFile(request, requestOptions));
+    annualAccountsAttachmentsDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__annualAccountsAttachmentsDelete(request, requestOptions));
     }
-    async __removeADocumentAttachedToTheAnnualAccountsAndDeleteItsFile(request, requestOptions) {
+    async __annualAccountsAttachmentsDelete(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({
@@ -3561,12 +3839,16 @@ class DeclarationsClient {
                     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:
@@ -3586,27 +3868,29 @@ class DeclarationsClient {
     /**
      * Compute the company income tax return TD4 of a tax year from the ledger and the recorded tax adjustments: the accounting profit, the add-backs, deductions, capital allowances and losses brought forward, the chargeable income, the corporation tax at the rate of the year and the double tax relief, as the fields the company keys into TAXISnet or Tax For All. The Tax Department publishes no upload layout for the TD4; the XML is a working file.
      *
-     * @param {NordletApi.PostV1DeclarationsCyTd4GenerateRequest} request
+     * @param {NordletApi.CyTd4GenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsCyTd4Generate({
+     *     await client.declarations.cyTd4Generate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsCyTd4Generate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsCyTd4Generate(request, requestOptions));
+    cyTd4Generate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__cyTd4Generate(request, requestOptions));
     }
-    async __postV1DeclarationsCyTd4Generate(request, requestOptions) {
+    async __cyTd4Generate(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({
@@ -3637,12 +3921,16 @@ class DeclarationsClient {
                     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:
@@ -3662,27 +3950,29 @@ class DeclarationsClient {
     /**
      * Build the annual return HE32 of a year: the figures the Registrar’s e-filing screens ask for (company number, registered office, made-up-to date, share capital, register of members, directors and secretary, annual general meeting date, the accounts summary), the working file, and the printed form HE32(I) filled in as a PDF for signing and for keying into the Registrar’s system, which takes the return only through its own screens.
      *
-     * @param {NordletApi.PostV1DeclarationsCyHe32GenerateRequest} request
+     * @param {NordletApi.CyHe32GenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsCyHe32Generate({
+     *     await client.declarations.cyHe32Generate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsCyHe32Generate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsCyHe32Generate(request, requestOptions));
+    cyHe32Generate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__cyHe32Generate(request, requestOptions));
     }
-    async __postV1DeclarationsCyHe32Generate(request, requestOptions) {
+    async __cyHe32Generate(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({
@@ -3713,12 +4003,16 @@ class DeclarationsClient {
                     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:
@@ -3738,28 +4032,30 @@ class DeclarationsClient {
     /**
      * Build one of the German returns that ELSTER accepts only through a licensed ERiC transmission (E-Bilanz, Körperschaftsteuer, Gewerbesteuer with its Zerlegungserklärung, annual VAT return, Lohnsteuer-Anmeldung, Lohnsteuerbescheinigung) for the company to send through its own ELSTER-capable program. The period is the year, or YYYY-MM for the monthly Lohnsteuer-Anmeldung.
      *
-     * @param {NordletApi.PostV1DeclarationsDeReturnsGenerateRequest} request
+     * @param {NordletApi.DeReturnsGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsDeReturnsGenerate({
+     *     await client.declarations.deReturnsGenerate({
      *         ruleKey: "de-e-bilanz",
      *         period: "period"
      *     })
      */
-    postV1DeclarationsDeReturnsGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsDeReturnsGenerate(request, requestOptions));
+    deReturnsGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__deReturnsGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsDeReturnsGenerate(request, requestOptions) {
+    async __deReturnsGenerate(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({
@@ -3790,12 +4086,16 @@ class DeclarationsClient {
                     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:
@@ -3815,27 +4115,29 @@ class DeclarationsClient {
     /**
      * The facts of one year that the German annual returns (Körperschaftsteuer, Gewerbesteuer, Umsatzsteuererklärung) need and the ledger does not hold: changes of shareholders, contracts with shareholders, the tax contribution account, loss carry-back, the donation carry-forward, the business premises with the municipalities for the apportionment of the trade tax, the land values or property tax and the participations for the trade tax additions and reductions, the foreign income per country for the Anlage AESt, the date of leaving the small-business scheme and the Anlage UN answers of a company seated abroad. A key that is absent has not been answered.
      *
-     * @param {NordletApi.PostV1DeclarationsDeReturnFactsGetRequest} request
+     * @param {NordletApi.DeReturnFactsGetDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsDeReturnFactsGet({
+     *     await client.declarations.deReturnFactsGet({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsDeReturnFactsGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsDeReturnFactsGet(request, requestOptions));
+    deReturnFactsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__deReturnFactsGet(request, requestOptions));
     }
-    async __postV1DeclarationsDeReturnFactsGet(request, requestOptions) {
+    async __deReturnFactsGet(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({
@@ -3866,12 +4168,16 @@ class DeclarationsClient {
                     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:
@@ -3891,28 +4197,30 @@ class DeclarationsClient {
     /**
      * Replace the facts of one year for the German annual returns. The returns built afterwards read them; a key left out stays unanswered.
      *
-     * @param {NordletApi.PostV1DeclarationsDeReturnFactsSetRequest} request
+     * @param {NordletApi.DeReturnFactsSetDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsDeReturnFactsSet({
+     *     await client.declarations.deReturnFactsSet({
      *         year: 1000000,
      *         facts: {}
      *     })
      */
-    postV1DeclarationsDeReturnFactsSet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsDeReturnFactsSet(request, requestOptions));
+    deReturnFactsSet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__deReturnFactsSet(request, requestOptions));
     }
-    async __postV1DeclarationsDeReturnFactsSet(request, requestOptions) {
+    async __deReturnFactsSet(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({
@@ -3943,12 +4251,16 @@ class DeclarationsClient {
                     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:
@@ -3968,28 +4280,30 @@ class DeclarationsClient {
     /**
      * Build the DEÜV notifications of a month (Anmeldung for every start, Abmeldung for every leaving, in December the Jahresmeldung for everyone employed on 31 December) as DSME records with the DBME, DBNA, DBGB and DBAN blocks of Anlage 4 in force from 2026, from the approved payroll runs and the employee record, for the company's own transmission channel.
      *
-     * @param {NordletApi.PostV1DeclarationsDeDeuevGenerateRequest} request
+     * @param {NordletApi.DeDeuevGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsDeDeuevGenerate({
+     *     await client.declarations.deDeuevGenerate({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsDeDeuevGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsDeDeuevGenerate(request, requestOptions));
+    deDeuevGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__deDeuevGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsDeDeuevGenerate(request, requestOptions) {
+    async __deDeuevGenerate(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({
@@ -4020,12 +4334,16 @@ class DeclarationsClient {
                     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:
@@ -4045,28 +4363,30 @@ class DeclarationsClient {
     /**
      * Build the monthly contribution statement to the health insurers (Beitragsnachweis) from the payroll run: one fixed-length record BW02 per insurer, in the record layout in force from 2026, ready for the company's own transmission channel.
      *
-     * @param {NordletApi.PostV1DeclarationsDeBeitragsnachweisGenerateRequest} request
+     * @param {NordletApi.DeBeitragsnachweisGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsDeBeitragsnachweisGenerate({
+     *     await client.declarations.deBeitragsnachweisGenerate({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsDeBeitragsnachweisGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsDeBeitragsnachweisGenerate(request, requestOptions));
+    deBeitragsnachweisGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__deBeitragsnachweisGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsDeBeitragsnachweisGenerate(request, requestOptions) {
+    async __deBeitragsnachweisGenerate(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({
@@ -4097,12 +4417,16 @@ class DeclarationsClient {
                     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:
@@ -4122,27 +4446,29 @@ class DeclarationsClient {
     /**
      * Compute the oplysningsskema for selskaber (selskabsselvangivelsen) of an income year from the ledger and the recorded tax adjustments: accounting result before tax, tax adjustments, losses carried forward, taxable income, the 22 % corporation tax, reliefs and the balance, as the rubrikker the company keys into TastSelv Selskabsskat (DIAS). Skatteforvaltningen publishes no file format for the return; the XML is a working file.
      *
-     * @param {NordletApi.PostV1DeclarationsDkSelskabsskatGenerateRequest} request
+     * @param {NordletApi.DkSelskabsskatGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsDkSelskabsskatGenerate({
+     *     await client.declarations.dkSelskabsskatGenerate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsDkSelskabsskatGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsDkSelskabsskatGenerate(request, requestOptions));
+    dkSelskabsskatGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__dkSelskabsskatGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsDkSelskabsskatGenerate(request, requestOptions) {
+    async __dkSelskabsskatGenerate(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({
@@ -4173,12 +4499,16 @@ class DeclarationsClient {
                     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:
@@ -4198,28 +4528,30 @@ class DeclarationsClient {
     /**
      * Send one employment register (töötamise register) entry for an employment contract to e-MTA over X-tee: the start of work, or its end with the reason recorded on the contract.
      *
-     * @param {NordletApi.PostV1DeclarationsEeEmploymentRegisterSendRequest} request
+     * @param {NordletApi.EeEmploymentRegisterSendDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEeEmploymentRegisterSend({
+     *     await client.declarations.eeEmploymentRegisterSend({
      *         contractId: "contractId",
      *         event: "start"
      *     })
      */
-    postV1DeclarationsEeEmploymentRegisterSend(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEeEmploymentRegisterSend(request, requestOptions));
+    eeEmploymentRegisterSend(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__eeEmploymentRegisterSend(request, requestOptions));
     }
-    async __postV1DeclarationsEeEmploymentRegisterSend(request, requestOptions) {
+    async __eeEmploymentRegisterSend(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({
@@ -4250,12 +4582,16 @@ class DeclarationsClient {
                     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:
@@ -4275,25 +4611,27 @@ class DeclarationsClient {
     /**
      * Nordlet's declaración responsable for its VERI*FACTU invoicing system (Orden HAC/1177/2024, art. 15), as a PDF and as plain text.
      *
-     * @param {NordletApi.PostV1DeclarationsEsVerifactuDeclaracionResponsableRequest} request
+     * @param {NordletApi.EsVerifactuDeclaracionResponsableDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsEsVerifactuDeclaracionResponsable()
+     *     await client.declarations.esVerifactuDeclaracionResponsable()
      */
-    postV1DeclarationsEsVerifactuDeclaracionResponsable(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEsVerifactuDeclaracionResponsable(request, requestOptions));
+    esVerifactuDeclaracionResponsable(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__esVerifactuDeclaracionResponsable(request, requestOptions));
     }
-    async __postV1DeclarationsEsVerifactuDeclaracionResponsable(request = {}, requestOptions) {
+    async __esVerifactuDeclaracionResponsable(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({
@@ -4324,12 +4662,16 @@ class DeclarationsClient {
                     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:
@@ -4349,27 +4691,29 @@ class DeclarationsClient {
     /**
      * Build the Form CT1 of an accounting year as the ROS version 26 XML and the accompanying financial statements as inline XBRL on the FRS 102 Irish Extension 2026 taxonomy Revenue accepts, both from the ledger, the recorded tax adjustments, the annual accounts record and the officers, for upload through the company’s own ROS account. Says whether the company is above the iXBRL deferral limits (balance sheet total €4.4 million, turnover €8.8 million, 50 employees).
      *
-     * @param {NordletApi.PostV1DeclarationsIeCt1GenerateRequest} request
+     * @param {NordletApi.IeCt1GenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsIeCt1Generate({
+     *     await client.declarations.ieCt1Generate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsIeCt1Generate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsIeCt1Generate(request, requestOptions));
+    ieCt1Generate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ieCt1Generate(request, requestOptions));
     }
-    async __postV1DeclarationsIeCt1Generate(request, requestOptions) {
+    async __ieCt1Generate(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({
@@ -4400,12 +4744,16 @@ class DeclarationsClient {
                     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:
@@ -4425,27 +4773,29 @@ class DeclarationsClient {
     /**
      * Build the working paper for the Form B1 annual return of a financial year — company details, registered office, directors and secretary from Settings → Officers, the members from Settings → Shareholders, the issued share capital and the figures of the financial statements — in the order the CORE screens ask for them. The CRO publishes no file format for the B1, so it is keyed into CORE.
      *
-     * @param {NordletApi.PostV1DeclarationsIeB1GenerateRequest} request
+     * @param {NordletApi.IeB1GenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsIeB1Generate({
+     *     await client.declarations.ieB1Generate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsIeB1Generate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsIeB1Generate(request, requestOptions));
+    ieB1Generate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ieB1Generate(request, requestOptions));
     }
-    async __postV1DeclarationsIeB1Generate(request, requestOptions) {
+    async __ieB1Generate(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({
@@ -4476,12 +4826,16 @@ class DeclarationsClient {
                     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:
@@ -4501,27 +4855,29 @@ class DeclarationsClient {
     /**
      * Build the TD16-TD19 integration document for a registered purchase invoice and send it to the Sistema di Interscambio. Since July 2022 a purchase from a supplier established abroad is reported this way instead of the esterometro. The Italian VAT rate to self-assess is a judgement about the supply: pass vatRatePercent unless the purchase lines already carry it, otherwise the request is refused rather than guessed.
      *
-     * @param {NordletApi.PostV1DeclarationsItSdiPurchaseSendRequest} request
+     * @param {NordletApi.ItSdiPurchaseSendDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsItSdiPurchaseSend({
+     *     await client.declarations.itSdiPurchaseSend({
      *         purchaseInvoiceId: "purchaseInvoiceId"
      *     })
      */
-    postV1DeclarationsItSdiPurchaseSend(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsItSdiPurchaseSend(request, requestOptions));
+    itSdiPurchaseSend(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__itSdiPurchaseSend(request, requestOptions));
     }
-    async __postV1DeclarationsItSdiPurchaseSend(request, requestOptions) {
+    async __itSdiPurchaseSend(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({
@@ -4552,12 +4908,16 @@ class DeclarationsClient {
                     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:
@@ -4577,27 +4937,29 @@ class DeclarationsClient {
     /**
      * Render the TD16-TD19 integration document for a registered purchase invoice without sending it, so the rate and the document type can be checked first.
      *
-     * @param {NordletApi.PostV1DeclarationsItSdiPurchasePreviewRequest} request
+     * @param {NordletApi.ItSdiPurchasePreviewDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsItSdiPurchasePreview({
+     *     await client.declarations.itSdiPurchasePreview({
      *         purchaseInvoiceId: "purchaseInvoiceId"
      *     })
      */
-    postV1DeclarationsItSdiPurchasePreview(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsItSdiPurchasePreview(request, requestOptions));
+    itSdiPurchasePreview(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__itSdiPurchasePreview(request, requestOptions));
     }
-    async __postV1DeclarationsItSdiPurchasePreview(request, requestOptions) {
+    async __itSdiPurchasePreview(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({
@@ -4628,12 +4990,16 @@ class DeclarationsClient {
                     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:
@@ -4651,30 +5017,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/it/sdi/purchase-preview");
     }
     /**
-     * Upload the SAF-T file to i.SAF-T over the iSAFTUploaderService web service and start its processing. The submission itself is confirmed separately, because after confirmation the file can no longer be corrected.
+     * Upload the SAF-T file to i.SAF-T over the iSAFTUploaderService web service and start its processing. The file, the case reference and the status are kept as a declaration submission (submissionId), whose outcome Nordlet then checks with i.SAF-T. The submission itself is confirmed separately, because after confirmation the file can no longer be corrected. A range and data type already sent is sent again only with amend: true.
      *
-     * @param {NordletApi.PostV1DeclarationsLtSaftSendRequest} request
+     * @param {NordletApi.LtSaftSendDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtSaftSend({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.declarations.ltSaftSend({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1DeclarationsLtSaftSend(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtSaftSend(request, requestOptions));
+    ltSaftSend(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltSaftSend(request, requestOptions));
     }
-    async __postV1DeclarationsLtSaftSend(request, requestOptions) {
+    async __ltSaftSend(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({
@@ -4705,12 +5073,16 @@ class DeclarationsClient {
                     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:
@@ -4730,29 +5102,31 @@ class DeclarationsClient {
     /**
      * Render the Sodra 1-SD or 2-SD notice for the contracts starting or ending in the range as an .ffdata document for EDAS.
      *
-     * @param {NordletApi.PostV1DeclarationsLtSdFfdataRequest} request
+     * @param {NordletApi.LtSdFfdataDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtSdFfdata({
+     *     await client.declarations.ltSdFfdata({
      *         type: "1-SD",
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1DeclarationsLtSdFfdata(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtSdFfdata(request, requestOptions));
+    ltSdFfdata(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltSdFfdata(request, requestOptions));
     }
-    async __postV1DeclarationsLtSdFfdata(request, requestOptions) {
+    async __ltSdFfdata(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({
@@ -4783,12 +5157,16 @@ class DeclarationsClient {
                     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:
@@ -4808,27 +5186,29 @@ class DeclarationsClient {
     /**
      * Render the annual corporate income tax return PLN204 as an .ffdata document, including the PLN204S and PLN204Z annexes, from the ledger and the tax adjustments recorded for that year.
      *
-     * @param {NordletApi.PostV1DeclarationsLtPln204FfdataRequest} request
+     * @param {NordletApi.LtPln204FfdataDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLtPln204Ffdata({
+     *     await client.declarations.ltPln204Ffdata({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsLtPln204Ffdata(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLtPln204Ffdata(request, requestOptions));
+    ltPln204Ffdata(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ltPln204Ffdata(request, requestOptions));
     }
-    async __postV1DeclarationsLtPln204Ffdata(request, requestOptions) {
+    async __ltPln204Ffdata(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({
@@ -4859,12 +5239,16 @@ class DeclarationsClient {
                     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:
@@ -4884,27 +5268,29 @@ class DeclarationsClient {
     /**
      * Compute the company income tax return and self-assessment of a year of assessment from the ledger and the recorded tax adjustments: the accounting profit before tax, the add-backs and deductions, the approved donations, capital allowances and losses carried forward, the chargeable income, the 35 % charge, the relief against the tax and the allocation of the distributable profit to the five tax accounts. The Malta Tax and Customs Administration issues the return as a personalised spreadsheet to the registered tax practitioner and publishes no layout, so the XML is a working file and the figures are keyed into that spreadsheet.
      *
-     * @param {NordletApi.PostV1DeclarationsMtCompanyTaxGenerateRequest} request
+     * @param {NordletApi.MtCompanyTaxGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsMtCompanyTaxGenerate({
+     *     await client.declarations.mtCompanyTaxGenerate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsMtCompanyTaxGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsMtCompanyTaxGenerate(request, requestOptions));
+    mtCompanyTaxGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__mtCompanyTaxGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsMtCompanyTaxGenerate(request, requestOptions) {
+    async __mtCompanyTaxGenerate(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({
@@ -4935,12 +5321,16 @@ class DeclarationsClient {
                     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:
@@ -4960,27 +5350,29 @@ class DeclarationsClient {
     /**
      * Build the annual return of a year: the company number, registered office and made-up-to date, the share capital, the register of members, the directors and the company secretary and the accounts summary, as the figures the Malta Business Registry asks for on its own screens, plus the printed Annual Return Form of the Seventh Schedule filled in as a PDF for signing.
      *
-     * @param {NordletApi.PostV1DeclarationsMtAnnualReturnGenerateRequest} request
+     * @param {NordletApi.MtAnnualReturnGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsMtAnnualReturnGenerate({
+     *     await client.declarations.mtAnnualReturnGenerate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsMtAnnualReturnGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsMtAnnualReturnGenerate(request, requestOptions));
+    mtAnnualReturnGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__mtAnnualReturnGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsMtAnnualReturnGenerate(request, requestOptions) {
+    async __mtAnnualReturnGenerate(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({
@@ -5011,12 +5403,16 @@ class DeclarationsClient {
                     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:
@@ -5036,28 +5432,30 @@ class DeclarationsClient {
     /**
      * Generate JPK_FA(4), the on-demand structure with every sales invoice issued in a period, its VAT bases per rate and one row per invoice line. Filed only when the tax office asks for it.
      *
-     * @param {NordletApi.PostV1DeclarationsPlJpkFaGenerateRequest} request
+     * @param {NordletApi.PlJpkFaGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlJpkFaGenerate({
-     *         dateFrom: "dateFrom",
-     *         dateTo: "dateTo"
+     *     await client.declarations.plJpkFaGenerate({
+     *         dateFrom: "2026-07-01",
+     *         dateTo: "2026-07-01"
      *     })
      */
-    postV1DeclarationsPlJpkFaGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlJpkFaGenerate(request, requestOptions));
+    plJpkFaGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plJpkFaGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsPlJpkFaGenerate(request, requestOptions) {
+    async __plJpkFaGenerate(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({
@@ -5088,12 +5486,16 @@ class DeclarationsClient {
                     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:
@@ -5113,28 +5515,30 @@ class DeclarationsClient {
     /**
      * Generate JPK_KR(1), the on-demand structure with the chart of accounts and its opening balances and turnover, the journal and the double entries behind it. Filed only when the tax office asks for it.
      *
-     * @param {NordletApi.PostV1DeclarationsPlJpkKrGenerateRequest} request
+     * @param {NordletApi.PlJpkKrGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlJpkKrGenerate({
-     *         dateFrom: "dateFrom",
-     *         dateTo: "dateTo"
+     *     await client.declarations.plJpkKrGenerate({
+     *         dateFrom: "2026-07-01",
+     *         dateTo: "2026-07-01"
      *     })
      */
-    postV1DeclarationsPlJpkKrGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlJpkKrGenerate(request, requestOptions));
+    plJpkKrGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plJpkKrGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsPlJpkKrGenerate(request, requestOptions) {
+    async __plJpkKrGenerate(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({
@@ -5165,12 +5569,16 @@ class DeclarationsClient {
                     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:
@@ -5190,28 +5598,30 @@ class DeclarationsClient {
     /**
      * Generate JPK_MAG(2), the on-demand structure with the warehouse documents of one warehouse: goods received from outside (PZ) or internally (PW) and issued to a customer (WZ) or internally (RW). Filed only when the tax office asks for it.
      *
-     * @param {NordletApi.PostV1DeclarationsPlJpkMagGenerateRequest} request
+     * @param {NordletApi.PlJpkMagGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlJpkMagGenerate({
-     *         dateFrom: "dateFrom",
-     *         dateTo: "dateTo"
+     *     await client.declarations.plJpkMagGenerate({
+     *         dateFrom: "2026-07-01",
+     *         dateTo: "2026-07-01"
      *     })
      */
-    postV1DeclarationsPlJpkMagGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlJpkMagGenerate(request, requestOptions));
+    plJpkMagGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plJpkMagGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsPlJpkMagGenerate(request, requestOptions) {
+    async __plJpkMagGenerate(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({
@@ -5242,12 +5652,16 @@ class DeclarationsClient {
                     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:
@@ -5267,27 +5681,29 @@ class DeclarationsClient {
     /**
      * Generate PIT-11(29) for every person on the payroll of one year: the pay, the deductible costs, the advance withheld and the social and health contributions taken off it. One document per person, because that is how the form is filed.
      *
-     * @param {NordletApi.PostV1DeclarationsPlPit11GenerateRequest} request
+     * @param {NordletApi.PlPit11GenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlPit11Generate({
+     *     await client.declarations.plPit11Generate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsPlPit11Generate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlPit11Generate(request, requestOptions));
+    plPit11Generate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plPit11Generate(request, requestOptions));
     }
-    async __postV1DeclarationsPlPit11Generate(request, requestOptions) {
+    async __plPit11Generate(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({
@@ -5318,12 +5734,16 @@ class DeclarationsClient {
                     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:
@@ -5343,27 +5763,29 @@ class DeclarationsClient {
     /**
      * Generate CIT-8(34), the annual corporate income tax return, from the ledger of the year and the recorded tax adjustments. The tax office code and the small-taxpayer setting come from the e-Deklaracje compliance settings, the seat address from the JPK gateway settings. Names the annexes the figures would need, which are not produced.
      *
-     * @param {NordletApi.PostV1DeclarationsPlCit8GenerateRequest} request
+     * @param {NordletApi.PlCit8GenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlCit8Generate({
+     *     await client.declarations.plCit8Generate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsPlCit8Generate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlCit8Generate(request, requestOptions));
+    plCit8Generate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plCit8Generate(request, requestOptions));
     }
-    async __postV1DeclarationsPlCit8Generate(request, requestOptions) {
+    async __plCit8Generate(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({
@@ -5394,12 +5816,16 @@ class DeclarationsClient {
                     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:
@@ -5419,28 +5845,30 @@ class DeclarationsClient {
     /**
      * Compute the monthly ZUS DRA settlement from the payroll run of one month: the pension, disability, sickness, accident and health insurance contributions and the Labour Fund, Solidarity Fund and guaranteed benefits fund charges, each split between the insured person and the payer. The amounts are carried into Płatnik or ePłatnik by hand.
      *
-     * @param {NordletApi.PostV1DeclarationsPlZusDraComputeRequest} request
+     * @param {NordletApi.PlZusDraComputeDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlZusDraCompute({
+     *     await client.declarations.plZusDraCompute({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsPlZusDraCompute(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlZusDraCompute(request, requestOptions));
+    plZusDraCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plZusDraCompute(request, requestOptions));
     }
-    async __postV1DeclarationsPlZusDraCompute(request, requestOptions) {
+    async __plZusDraCompute(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({
@@ -5471,12 +5899,16 @@ class DeclarationsClient {
                     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:
@@ -5496,28 +5928,30 @@ class DeclarationsClient {
     /**
      * Build the KEDU file for one month: the ZUS DRA settlement and one ZUS RCA report per person on the payroll, in the schema kedu_5_4 that Płatnik and ePłatnik import. The payer REGON, short name and declaration deadline code come from the ZUS compliance settings; the insurance title code and working time of each person from the employee record.
      *
-     * @param {NordletApi.PostV1DeclarationsPlZusDraKeduRequest} request
+     * @param {NordletApi.PlZusDraKeduDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlZusDraKedu({
+     *     await client.declarations.plZusDraKedu({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsPlZusDraKedu(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlZusDraKedu(request, requestOptions));
+    plZusDraKedu(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plZusDraKedu(request, requestOptions));
     }
-    async __postV1DeclarationsPlZusDraKedu(request, requestOptions) {
+    async __plZusDraKedu(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({
@@ -5548,12 +5982,16 @@ class DeclarationsClient {
                     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:
@@ -5573,28 +6011,30 @@ class DeclarationsClient {
     /**
      * Fill the published ZUS DRA form for one month and return it as a PDF. The amounts, the payer identity and the deadline code are the same ones the KEDU file carries; blocks the payroll does not hold (paid benefits, bridging pensions, income declaration of a self-paying person) stay empty.
      *
-     * @param {NordletApi.PostV1DeclarationsPlZusDraPdfRequest} request
+     * @param {NordletApi.PlZusDraPdfDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsPlZusDraPdf({
+     *     await client.declarations.plZusDraPdf({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsPlZusDraPdf(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsPlZusDraPdf(request, requestOptions));
+    plZusDraPdf(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__plZusDraPdf(request, requestOptions));
     }
-    async __postV1DeclarationsPlZusDraPdf(request, requestOptions) {
+    async __plZusDraPdf(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({
@@ -5625,12 +6065,16 @@ class DeclarationsClient {
                     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:
@@ -5650,27 +6094,29 @@ class DeclarationsClient {
     /**
      * Build the RO e-Transport declaration for an issued waybill: goods with their tariff codes and masses, the commercial partner, the route and the vehicle. The XML follows the ANAF eTransport v2 schema and is kept as a file on the waybill. Anything listed in blockers has to be filled in before /etransport/send will accept it.
      *
-     * @param {NordletApi.PostV1DeclarationsRoEtransportBuildRequest} request
+     * @param {NordletApi.RoEtransportBuildDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsRoEtransportBuild({
+     *     await client.declarations.roEtransportBuild({
      *         waybillId: "waybillId"
      *     })
      */
-    postV1DeclarationsRoEtransportBuild(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsRoEtransportBuild(request, requestOptions));
+    roEtransportBuild(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__roEtransportBuild(request, requestOptions));
     }
-    async __postV1DeclarationsRoEtransportBuild(request, requestOptions) {
+    async __roEtransportBuild(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({
@@ -5701,12 +6147,16 @@ class DeclarationsClient {
                     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:
@@ -5726,27 +6176,29 @@ class DeclarationsClient {
     /**
      * Hand the RO e-Transport declaration for an issued waybill to ANAF under the SPV OAuth token in compliance settings, and return the upload index the UIT is read back with. Answers 422 while any field the ANAF validator requires is still missing.
      *
-     * @param {NordletApi.PostV1DeclarationsRoEtransportSubmitRequest} request
+     * @param {NordletApi.RoEtransportSubmitDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsRoEtransportSubmit({
+     *     await client.declarations.roEtransportSubmit({
      *         waybillId: "waybillId"
      *     })
      */
-    postV1DeclarationsRoEtransportSubmit(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsRoEtransportSubmit(request, requestOptions));
+    roEtransportSubmit(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__roEtransportSubmit(request, requestOptions));
     }
-    async __postV1DeclarationsRoEtransportSubmit(request, requestOptions) {
+    async __roEtransportSubmit(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({
@@ -5777,12 +6229,16 @@ class DeclarationsClient {
                     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:
@@ -5802,27 +6258,29 @@ class DeclarationsClient {
     /**
      * Read the outcome of an e-Transport declaration from ANAF by its upload index, under the SPV OAuth token in compliance settings. Returns the UIT code once the declaration validates.
      *
-     * @param {NordletApi.PostV1DeclarationsRoEtransportStatusRequest} request
+     * @param {NordletApi.RoEtransportStatusDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsRoEtransportStatus({
+     *     await client.declarations.roEtransportStatus({
      *         reference: "reference"
      *     })
      */
-    postV1DeclarationsRoEtransportStatus(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsRoEtransportStatus(request, requestOptions));
+    roEtransportStatus(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__roEtransportStatus(request, requestOptions));
     }
-    async __postV1DeclarationsRoEtransportStatus(request, requestOptions) {
+    async __roEtransportStatus(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({
@@ -5853,12 +6311,16 @@ class DeclarationsClient {
                     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:
@@ -5878,27 +6340,29 @@ class DeclarationsClient {
     /**
      * Build the annual wage declaration (Lohndeklaration) to the AHV-IV-FAK from the approved payroll runs of the year as the CSV that AHVeasy imports under Lohndeklaration → CSV-Import der Lohndaten: one row per employee with the 18 columns of the AHVeasy template, the AHV-liable wage and the ALV wage.
      *
-     * @param {NordletApi.PostV1DeclarationsLiLohndeklarationGenerateRequest} request
+     * @param {NordletApi.LiLohndeklarationGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLiLohndeklarationGenerate({
+     *     await client.declarations.liLohndeklarationGenerate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsLiLohndeklarationGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLiLohndeklarationGenerate(request, requestOptions));
+    liLohndeklarationGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__liLohndeklarationGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsLiLohndeklarationGenerate(request, requestOptions) {
+    async __liLohndeklarationGenerate(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({
@@ -5929,12 +6393,16 @@ class DeclarationsClient {
                     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:
@@ -5954,27 +6422,29 @@ class DeclarationsClient {
     /**
      * Build the annual wage list (Lohnliste) of a Liechtenstein employer from the approved payroll runs of the year as the XLSX file the tax administration's eLohnausweis / eLohnlisten application imports: one row per employee with PEID, name, birth date, address, gross wage, wage tax withheld and the settlement period.
      *
-     * @param {NordletApi.PostV1DeclarationsLiLohnlistenGenerateRequest} request
+     * @param {NordletApi.LiLohnlistenGenerateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsLiLohnlistenGenerate({
+     *     await client.declarations.liLohnlistenGenerate({
      *         year: 1000000
      *     })
      */
-    postV1DeclarationsLiLohnlistenGenerate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsLiLohnlistenGenerate(request, requestOptions));
+    liLohnlistenGenerate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__liLohnlistenGenerate(request, requestOptions));
     }
-    async __postV1DeclarationsLiLohnlistenGenerate(request, requestOptions) {
+    async __liLohnlistenGenerate(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({
@@ -6005,12 +6475,16 @@ class DeclarationsClient {
                     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:
@@ -6028,25 +6502,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/li/lohnlisten/generate");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsConfigsListRequest} request
+     * @param {NordletApi.ConfigsListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsConfigsList()
+     *     await client.declarations.configsList()
      */
-    postV1DeclarationsConfigsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsConfigsList(request, requestOptions));
+    configsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__configsList(request, requestOptions));
     }
-    async __postV1DeclarationsConfigsList(request = {}, requestOptions) {
+    async __configsList(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({
@@ -6077,12 +6553,16 @@ class DeclarationsClient {
                     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:
@@ -6100,30 +6580,32 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/configs/list");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsConfigsUpdateRequest} request
+     * @param {NordletApi.ConfigsUpdateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsConfigsUpdate({
+     *     await client.declarations.configsUpdate({
      *         system: "system",
      *         config: {
      *             "key": "value"
      *         }
      *     })
      */
-    postV1DeclarationsConfigsUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsConfigsUpdate(request, requestOptions));
+    configsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__configsUpdate(request, requestOptions));
     }
-    async __postV1DeclarationsConfigsUpdate(request, requestOptions) {
+    async __configsUpdate(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({
@@ -6154,12 +6636,16 @@ class DeclarationsClient {
                     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:
@@ -6177,29 +6663,31 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/configs/update");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsCertificatesUploadRequest} request
+     * @param {NordletApi.CertificatesUploadDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.storeTheCertificateOrPrivateKeyAFilingSystemAuthenticatesWith({
+     *     await client.declarations.certificatesUpload({
      *         system: "system",
      *         fileName: "fileName",
      *         content: "content"
      *     })
      */
-    storeTheCertificateOrPrivateKeyAFilingSystemAuthenticatesWith(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__storeTheCertificateOrPrivateKeyAFilingSystemAuthenticatesWith(request, requestOptions));
+    certificatesUpload(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__certificatesUpload(request, requestOptions));
     }
-    async __storeTheCertificateOrPrivateKeyAFilingSystemAuthenticatesWith(request, requestOptions) {
+    async __certificatesUpload(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({
@@ -6230,12 +6718,16 @@ class DeclarationsClient {
                     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:
@@ -6253,25 +6745,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/certificates/upload");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsCertificatesListRequest} request
+     * @param {NordletApi.CertificatesListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsCertificatesList()
+     *     await client.declarations.certificatesList()
      */
-    postV1DeclarationsCertificatesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsCertificatesList(request, requestOptions));
+    certificatesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__certificatesList(request, requestOptions));
     }
-    async __postV1DeclarationsCertificatesList(request = {}, requestOptions) {
+    async __certificatesList(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({
@@ -6302,12 +6796,16 @@ class DeclarationsClient {
                     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:
@@ -6325,28 +6823,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/certificates/list");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsCertificatesDeleteRequest} request
+     * @param {NordletApi.CertificatesDeleteDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsCertificatesDelete({
+     *     await client.declarations.certificatesDelete({
      *         system: "system",
      *         fieldKey: "certificate"
      *     })
      */
-    postV1DeclarationsCertificatesDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsCertificatesDelete(request, requestOptions));
+    certificatesDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__certificatesDelete(request, requestOptions));
     }
-    async __postV1DeclarationsCertificatesDelete(request, requestOptions) {
+    async __certificatesDelete(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({
@@ -6377,12 +6877,16 @@ class DeclarationsClient {
                     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:
@@ -6400,25 +6904,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/certificates/delete");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAutomationListRequest} request
+     * @param {NordletApi.AutomationListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.whichDeadlinesNordletCanFileByItselfForThisCompanyAndWhichAreSwitchedOn()
+     *     await client.declarations.automationList()
      */
-    whichDeadlinesNordletCanFileByItselfForThisCompanyAndWhichAreSwitchedOn(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__whichDeadlinesNordletCanFileByItselfForThisCompanyAndWhichAreSwitchedOn(request, requestOptions));
+    automationList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__automationList(request, requestOptions));
     }
-    async __whichDeadlinesNordletCanFileByItselfForThisCompanyAndWhichAreSwitchedOn(request = {}, requestOptions) {
+    async __automationList(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({
@@ -6449,12 +6955,16 @@ class DeclarationsClient {
                     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:
@@ -6472,28 +6982,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/automation/list");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsAutomationUpdateRequest} request
+     * @param {NordletApi.AutomationUpdateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsAutomationUpdate({
+     *     await client.declarations.automationUpdate({
      *         ruleKey: "ruleKey",
      *         enabled: true
      *     })
      */
-    postV1DeclarationsAutomationUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsAutomationUpdate(request, requestOptions));
+    automationUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__automationUpdate(request, requestOptions));
     }
-    async __postV1DeclarationsAutomationUpdate(request, requestOptions) {
+    async __automationUpdate(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({
@@ -6524,12 +7036,16 @@ class DeclarationsClient {
                     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:
@@ -6547,27 +7063,29 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/automation/update");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsSubmissionsRetryRequest} request
+     * @param {NordletApi.SubmissionsRetryDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.sendAFilingWhoseDeliveryFailedOnceMoreWithTheBytesThatWereGenerated({
+     *     await client.declarations.submissionsRetry({
      *         id: "id"
      *     })
      */
-    sendAFilingWhoseDeliveryFailedOnceMoreWithTheBytesThatWereGenerated(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__sendAFilingWhoseDeliveryFailedOnceMoreWithTheBytesThatWereGenerated(request, requestOptions));
+    submissionsRetry(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__submissionsRetry(request, requestOptions));
     }
-    async __sendAFilingWhoseDeliveryFailedOnceMoreWithTheBytesThatWereGenerated(request, requestOptions) {
+    async __submissionsRetry(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({
@@ -6598,12 +7116,16 @@ class DeclarationsClient {
                     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:
@@ -6621,29 +7143,31 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/submissions/retry");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsSubmissionsCreateRequest} request
+     * @param {NordletApi.SubmissionsCreateDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsSubmissionsCreate({
+     *     await client.declarations.submissionsCreate({
      *         obligation: "lt-isaf",
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1DeclarationsSubmissionsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsSubmissionsCreate(request, requestOptions));
+    submissionsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__submissionsCreate(request, requestOptions));
     }
-    async __postV1DeclarationsSubmissionsCreate(request, requestOptions) {
+    async __submissionsCreate(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({
@@ -6674,12 +7198,16 @@ class DeclarationsClient {
                     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:
@@ -6697,28 +7225,30 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/submissions/create");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsSubmissionsMarkRequest} request
+     * @param {NordletApi.SubmissionsMarkDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsSubmissionsMark({
+     *     await client.declarations.submissionsMark({
      *         id: "id",
      *         status: "submitted"
      *     })
      */
-    postV1DeclarationsSubmissionsMark(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsSubmissionsMark(request, requestOptions));
+    submissionsMark(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__submissionsMark(request, requestOptions));
     }
-    async __postV1DeclarationsSubmissionsMark(request, requestOptions) {
+    async __submissionsMark(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({
@@ -6749,12 +7279,16 @@ class DeclarationsClient {
                     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:
@@ -6772,25 +7306,27 @@ class DeclarationsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/submissions/mark");
     }
     /**
-     * @param {NordletApi.PostV1DeclarationsSubmissionsListRequest} request
+     * @param {NordletApi.SubmissionsListDeclarationsRequest} request
      * @param {DeclarationsClient.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.declarations.postV1DeclarationsSubmissionsList()
+     *     await client.declarations.submissionsList()
      */
-    postV1DeclarationsSubmissionsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsSubmissionsList(request, requestOptions));
+    submissionsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__submissionsList(request, requestOptions));
     }
-    async __postV1DeclarationsSubmissionsList(request = {}, requestOptions) {
+    async __submissionsList(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({
@@ -6821,12 +7357,16 @@ class DeclarationsClient {
                     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: