nordlet 0.3.4 → 0.3.7

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

@@ -48,25 +48,27 @@ class LedgerClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {NordletApi.PostV1LedgerAccountsListRequest} request
+     * @param {NordletApi.AccountsListLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerAccountsList()
+     *     await client.ledger.accountsList()
      */
-    postV1LedgerAccountsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerAccountsList(request, requestOptions));
+    accountsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsList(request, requestOptions));
     }
-    async __postV1LedgerAccountsList(request = {}, requestOptions) {
+    async __accountsList(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({
@@ -97,12 +99,16 @@ class LedgerClient {
                     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:
@@ -120,29 +126,31 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/accounts/list");
     }
     /**
-     * @param {NordletApi.PostV1LedgerAccountsCreateRequest} request
+     * @param {NordletApi.AccountsCreateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerAccountsCreate({
+     *     await client.ledger.accountsCreate({
      *         code: "code",
      *         name: "name",
      *         type: "asset"
      *     })
      */
-    postV1LedgerAccountsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerAccountsCreate(request, requestOptions));
+    accountsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsCreate(request, requestOptions));
     }
-    async __postV1LedgerAccountsCreate(request, requestOptions) {
+    async __accountsCreate(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({
@@ -173,12 +181,16 @@ class LedgerClient {
                     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:
@@ -196,27 +208,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/accounts/create");
     }
     /**
-     * @param {NordletApi.PostV1LedgerAccountsUpdateRequest} request
+     * @param {NordletApi.AccountsUpdateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerAccountsUpdate({
+     *     await client.ledger.accountsUpdate({
      *         id: "id"
      *     })
      */
-    postV1LedgerAccountsUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerAccountsUpdate(request, requestOptions));
+    accountsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsUpdate(request, requestOptions));
     }
-    async __postV1LedgerAccountsUpdate(request, requestOptions) {
+    async __accountsUpdate(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({
@@ -247,12 +261,16 @@ class LedgerClient {
                     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:
@@ -270,25 +288,27 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/accounts/update");
     }
     /**
-     * @param {NordletApi.PostV1LedgerAccountsApplyTemplateRequest} request
+     * @param {NordletApi.AccountsApplyTemplateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerAccountsApplyTemplate()
+     *     await client.ledger.accountsApplyTemplate()
      */
-    postV1LedgerAccountsApplyTemplate(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerAccountsApplyTemplate(request, requestOptions));
+    accountsApplyTemplate(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsApplyTemplate(request, requestOptions));
     }
-    async __postV1LedgerAccountsApplyTemplate(request = {}, requestOptions) {
+    async __accountsApplyTemplate(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({
@@ -319,12 +339,16 @@ class LedgerClient {
                     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:
@@ -344,25 +368,27 @@ class LedgerClient {
     /**
      * Replaces the seeded chart with the chart template of the company country (the Romanian general chart for a company registered in Romania, the Lithuanian standard chart otherwise) and switches the posting defaults with it. Answers 409 when the company already uses that chart, has journal entries, holds accounts created by hand, or has settings that name an account the new chart does not have.
      *
-     * @param {NordletApi.PostV1LedgerAccountsSwitchChartRequest} request
+     * @param {NordletApi.AccountsSwitchChartLedgerRequest} request
      * @param {LedgerClient.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.ledger.moveACompanyThatHasPostedNothingYetToTheChartOfAccountsOfItsCountry()
+     *     await client.ledger.accountsSwitchChart()
      */
-    moveACompanyThatHasPostedNothingYetToTheChartOfAccountsOfItsCountry(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__moveACompanyThatHasPostedNothingYetToTheChartOfAccountsOfItsCountry(request, requestOptions));
+    accountsSwitchChart(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsSwitchChart(request, requestOptions));
     }
-    async __moveACompanyThatHasPostedNothingYetToTheChartOfAccountsOfItsCountry(request = {}, requestOptions) {
+    async __accountsSwitchChart(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({
@@ -393,12 +419,16 @@ class LedgerClient {
                     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:
@@ -416,25 +446,27 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/accounts/switch-chart");
     }
     /**
-     * @param {NordletApi.PostV1LedgerPeriodsListRequest} request
+     * @param {NordletApi.PeriodsListLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerPeriodsList()
+     *     await client.ledger.periodsList()
      */
-    postV1LedgerPeriodsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerPeriodsList(request, requestOptions));
+    periodsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__periodsList(request, requestOptions));
     }
-    async __postV1LedgerPeriodsList(request = {}, requestOptions) {
+    async __periodsList(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({
@@ -454,10 +486,7 @@ class LedgerClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -465,12 +494,16 @@ class LedgerClient {
                     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:
@@ -488,28 +521,30 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/periods/list");
     }
     /**
-     * @param {NordletApi.PostV1LedgerPeriodsLockRequest} request
+     * @param {NordletApi.PeriodsLockLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerPeriodsLock({
+     *     await client.ledger.periodsLock({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1LedgerPeriodsLock(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerPeriodsLock(request, requestOptions));
+    periodsLock(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__periodsLock(request, requestOptions));
     }
-    async __postV1LedgerPeriodsLock(request, requestOptions) {
+    async __periodsLock(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({
@@ -529,10 +564,7 @@ class LedgerClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -540,12 +572,16 @@ class LedgerClient {
                     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:
@@ -563,28 +599,30 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/periods/lock");
     }
     /**
-     * @param {NordletApi.PostV1LedgerPeriodsUnlockRequest} request
+     * @param {NordletApi.PeriodsUnlockLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerPeriodsUnlock({
+     *     await client.ledger.periodsUnlock({
      *         year: 1000000,
      *         month: 1000000
      *     })
      */
-    postV1LedgerPeriodsUnlock(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerPeriodsUnlock(request, requestOptions));
+    periodsUnlock(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__periodsUnlock(request, requestOptions));
     }
-    async __postV1LedgerPeriodsUnlock(request, requestOptions) {
+    async __periodsUnlock(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({
@@ -615,12 +653,16 @@ class LedgerClient {
                     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:
@@ -638,25 +680,27 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/periods/unlock");
     }
     /**
-     * @param {NordletApi.PostV1LedgerJournalTransactionsListRequest} request
+     * @param {NordletApi.JournalTransactionsListLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerJournalTransactionsList()
+     *     await client.ledger.journalTransactionsList()
      */
-    postV1LedgerJournalTransactionsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerJournalTransactionsList(request, requestOptions));
+    journalTransactionsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__journalTransactionsList(request, requestOptions));
     }
-    async __postV1LedgerJournalTransactionsList(request = {}, requestOptions) {
+    async __journalTransactionsList(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({
@@ -687,12 +731,16 @@ class LedgerClient {
                     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:
@@ -710,28 +758,30 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/journal/transactions/list");
     }
     /**
-     * @param {NordletApi.PostV1LedgerCostCentersCreateRequest} request
+     * @param {NordletApi.CostCentersCreateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerCostCentersCreate({
+     *     await client.ledger.costCentersCreate({
      *         code: "code",
      *         name: "name"
      *     })
      */
-    postV1LedgerCostCentersCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerCostCentersCreate(request, requestOptions));
+    costCentersCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCentersCreate(request, requestOptions));
     }
-    async __postV1LedgerCostCentersCreate(request, requestOptions) {
+    async __costCentersCreate(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({
@@ -762,12 +812,16 @@ class LedgerClient {
                     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:
@@ -785,27 +839,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/cost-centers/create");
     }
     /**
-     * @param {NordletApi.PostV1LedgerCostCentersUpdateRequest} request
+     * @param {NordletApi.CostCentersUpdateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerCostCentersUpdate({
+     *     await client.ledger.costCentersUpdate({
      *         id: "id"
      *     })
      */
-    postV1LedgerCostCentersUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerCostCentersUpdate(request, requestOptions));
+    costCentersUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCentersUpdate(request, requestOptions));
     }
-    async __postV1LedgerCostCentersUpdate(request, requestOptions) {
+    async __costCentersUpdate(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({
@@ -836,12 +892,16 @@ class LedgerClient {
                     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:
@@ -859,25 +919,27 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/cost-centers/update");
     }
     /**
-     * @param {NordletApi.PostV1LedgerCostCentersListRequest} request
+     * @param {NordletApi.CostCentersListLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerCostCentersList()
+     *     await client.ledger.costCentersList()
      */
-    postV1LedgerCostCentersList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerCostCentersList(request, requestOptions));
+    costCentersList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCentersList(request, requestOptions));
     }
-    async __postV1LedgerCostCentersList(request = {}, requestOptions) {
+    async __costCentersList(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({
@@ -908,12 +970,16 @@ class LedgerClient {
                     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:
@@ -931,28 +997,30 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/cost-centers/list");
     }
     /**
-     * @param {NordletApi.PostV1LedgerCostCenterGroupsCreateRequest} request
+     * @param {NordletApi.CostCenterGroupsCreateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerCostCenterGroupsCreate({
+     *     await client.ledger.costCenterGroupsCreate({
      *         code: "code",
      *         name: "name"
      *     })
      */
-    postV1LedgerCostCenterGroupsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerCostCenterGroupsCreate(request, requestOptions));
+    costCenterGroupsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCenterGroupsCreate(request, requestOptions));
     }
-    async __postV1LedgerCostCenterGroupsCreate(request, requestOptions) {
+    async __costCenterGroupsCreate(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -983,12 +1051,16 @@ class LedgerClient {
                     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:
@@ -1006,27 +1078,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/cost-center-groups/create");
     }
     /**
-     * @param {NordletApi.PostV1LedgerCostCenterGroupsUpdateRequest} request
+     * @param {NordletApi.CostCenterGroupsUpdateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerCostCenterGroupsUpdate({
+     *     await client.ledger.costCenterGroupsUpdate({
      *         id: "id"
      *     })
      */
-    postV1LedgerCostCenterGroupsUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerCostCenterGroupsUpdate(request, requestOptions));
+    costCenterGroupsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCenterGroupsUpdate(request, requestOptions));
     }
-    async __postV1LedgerCostCenterGroupsUpdate(request, requestOptions) {
+    async __costCenterGroupsUpdate(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({
@@ -1057,12 +1131,16 @@ class LedgerClient {
                     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:
@@ -1080,27 +1158,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/cost-center-groups/update");
     }
     /**
-     * @param {NordletApi.PostV1LedgerCostCenterGroupsDeleteRequest} request
+     * @param {NordletApi.CostCenterGroupsDeleteLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerCostCenterGroupsDelete({
+     *     await client.ledger.costCenterGroupsDelete({
      *         id: "id"
      *     })
      */
-    postV1LedgerCostCenterGroupsDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerCostCenterGroupsDelete(request, requestOptions));
+    costCenterGroupsDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCenterGroupsDelete(request, requestOptions));
     }
-    async __postV1LedgerCostCenterGroupsDelete(request, requestOptions) {
+    async __costCenterGroupsDelete(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({
@@ -1131,12 +1211,16 @@ class LedgerClient {
                     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:
@@ -1154,25 +1238,27 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/cost-center-groups/delete");
     }
     /**
-     * @param {NordletApi.PostV1LedgerCostCenterGroupsListRequest} request
+     * @param {NordletApi.CostCenterGroupsListLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerCostCenterGroupsList()
+     *     await client.ledger.costCenterGroupsList()
      */
-    postV1LedgerCostCenterGroupsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerCostCenterGroupsList(request, requestOptions));
+    costCenterGroupsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCenterGroupsList(request, requestOptions));
     }
-    async __postV1LedgerCostCenterGroupsList(request = {}, requestOptions) {
+    async __costCenterGroupsList(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({
@@ -1203,12 +1289,16 @@ class LedgerClient {
                     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:
@@ -1226,25 +1316,27 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/cost-center-groups/list");
     }
     /**
-     * @param {NordletApi.PostV1LedgerPostingRulesListRequest} request
+     * @param {NordletApi.PostingRulesListLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerPostingRulesList()
+     *     await client.ledger.postingRulesList()
      */
-    postV1LedgerPostingRulesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerPostingRulesList(request, requestOptions));
+    postingRulesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postingRulesList(request, requestOptions));
     }
-    async __postV1LedgerPostingRulesList(request = {}, requestOptions) {
+    async __postingRulesList(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({
@@ -1275,12 +1367,16 @@ class LedgerClient {
                     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:
@@ -1298,29 +1394,31 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/posting-rules/list");
     }
     /**
-     * @param {NordletApi.PostV1LedgerPostingRulesUpdateRequest} request
+     * @param {NordletApi.PostingRulesUpdateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerPostingRulesUpdate({
+     *     await client.ledger.postingRulesUpdate({
      *         rules: [{
      *                 key: "sales.receivable"
      *             }]
      *     })
      */
-    postV1LedgerPostingRulesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerPostingRulesUpdate(request, requestOptions));
+    postingRulesUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postingRulesUpdate(request, requestOptions));
     }
-    async __postV1LedgerPostingRulesUpdate(request, requestOptions) {
+    async __postingRulesUpdate(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({
@@ -1351,12 +1449,16 @@ class LedgerClient {
                     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:
@@ -1374,27 +1476,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/posting-rules/update");
     }
     /**
-     * @param {NordletApi.PostV1LedgerOwnersCreateRequest} request
+     * @param {NordletApi.OwnersCreateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerOwnersCreate({
+     *     await client.ledger.ownersCreate({
      *         name: "name"
      *     })
      */
-    postV1LedgerOwnersCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerOwnersCreate(request, requestOptions));
+    ownersCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ownersCreate(request, requestOptions));
     }
-    async __postV1LedgerOwnersCreate(request, requestOptions) {
+    async __ownersCreate(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({
@@ -1425,12 +1529,16 @@ class LedgerClient {
                     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:
@@ -1448,27 +1556,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/owners/create");
     }
     /**
-     * @param {NordletApi.PostV1LedgerOwnersUpdateRequest} request
+     * @param {NordletApi.OwnersUpdateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerOwnersUpdate({
+     *     await client.ledger.ownersUpdate({
      *         id: "id"
      *     })
      */
-    postV1LedgerOwnersUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerOwnersUpdate(request, requestOptions));
+    ownersUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ownersUpdate(request, requestOptions));
     }
-    async __postV1LedgerOwnersUpdate(request, requestOptions) {
+    async __ownersUpdate(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({
@@ -1499,12 +1609,16 @@ class LedgerClient {
                     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:
@@ -1522,27 +1636,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/owners/update");
     }
     /**
-     * @param {NordletApi.PostV1LedgerOwnersDeleteRequest} request
+     * @param {NordletApi.OwnersDeleteLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerOwnersDelete({
+     *     await client.ledger.ownersDelete({
      *         id: "id"
      *     })
      */
-    postV1LedgerOwnersDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerOwnersDelete(request, requestOptions));
+    ownersDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ownersDelete(request, requestOptions));
     }
-    async __postV1LedgerOwnersDelete(request, requestOptions) {
+    async __ownersDelete(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({
@@ -1573,12 +1689,16 @@ class LedgerClient {
                     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:
@@ -1596,25 +1716,27 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/owners/delete");
     }
     /**
-     * @param {NordletApi.PostV1LedgerOwnersListRequest} request
+     * @param {NordletApi.OwnersListLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerOwnersList()
+     *     await client.ledger.ownersList()
      */
-    postV1LedgerOwnersList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerOwnersList(request, requestOptions));
+    ownersList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__ownersList(request, requestOptions));
     }
-    async __postV1LedgerOwnersList(request = {}, requestOptions) {
+    async __ownersList(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({
@@ -1634,10 +1756,7 @@ class LedgerClient {
             logging: this._options.logging,
         });
         if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             switch (_response.error.statusCode) {
@@ -1645,12 +1764,16 @@ class LedgerClient {
                     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:
@@ -1668,27 +1791,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/owners/list");
     }
     /**
-     * @param {NordletApi.PostV1LedgerJournalTransactionsGetRequest} request
+     * @param {NordletApi.JournalTransactionsGetLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerJournalTransactionsGet({
+     *     await client.ledger.journalTransactionsGet({
      *         id: "id"
      *     })
      */
-    postV1LedgerJournalTransactionsGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerJournalTransactionsGet(request, requestOptions));
+    journalTransactionsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__journalTransactionsGet(request, requestOptions));
     }
-    async __postV1LedgerJournalTransactionsGet(request, requestOptions) {
+    async __journalTransactionsGet(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({
@@ -1719,12 +1844,16 @@ class LedgerClient {
                     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:
@@ -1742,30 +1871,32 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/journal/transactions/get");
     }
     /**
-     * @param {NordletApi.PostV1LedgerJournalTransactionsCreateRequest} request
+     * @param {NordletApi.JournalTransactionsCreateLedgerRequest} request
      * @param {LedgerClient.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.ledger.postV1LedgerJournalTransactionsCreate({
-     *         date: "date",
+     *     await client.ledger.journalTransactionsCreate({
+     *         date: "2026-07-01",
      *         entries: [{
      *                 accountCode: "accountCode"
      *             }]
      *     })
      */
-    postV1LedgerJournalTransactionsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1LedgerJournalTransactionsCreate(request, requestOptions));
+    journalTransactionsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__journalTransactionsCreate(request, requestOptions));
     }
-    async __postV1LedgerJournalTransactionsCreate(request, requestOptions) {
+    async __journalTransactionsCreate(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({
@@ -1796,12 +1927,16 @@ class LedgerClient {
                     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:
@@ -1821,25 +1956,27 @@ class LedgerClient {
     /**
      * The rows or codes of each return or registry deposit of the company country that are filled from account balances. Accounts fall into a row by the layout defaults for the standard chart of accounts unless mapped under Settings → Statement rows.
      *
-     * @param {NordletApi.PostV1LedgerStatementRowsSchemesRequest} request
+     * @param {NordletApi.StatementRowsSchemesLedgerRequest} request
      * @param {LedgerClient.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.ledger.nationalStatementLayoutsAvailableToTheCompany()
+     *     await client.ledger.statementRowsSchemes()
      */
-    nationalStatementLayoutsAvailableToTheCompany(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__nationalStatementLayoutsAvailableToTheCompany(request, requestOptions));
+    statementRowsSchemes(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__statementRowsSchemes(request, requestOptions));
     }
-    async __nationalStatementLayoutsAvailableToTheCompany(request = {}, requestOptions) {
+    async __statementRowsSchemes(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({
@@ -1870,12 +2007,16 @@ class LedgerClient {
                     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:
@@ -1893,27 +2034,29 @@ class LedgerClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/statement-rows/schemes");
     }
     /**
-     * @param {NordletApi.PostV1LedgerStatementRowsListRequest} request
+     * @param {NordletApi.StatementRowsListLedgerRequest} request
      * @param {LedgerClient.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.ledger.accountsPlacedOnTheRowsOfAStatementLayoutWithTheRowTotalsOfAPeriod({
+     *     await client.ledger.statementRowsList({
      *         scheme: "scheme"
      *     })
      */
-    accountsPlacedOnTheRowsOfAStatementLayoutWithTheRowTotalsOfAPeriod(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__accountsPlacedOnTheRowsOfAStatementLayoutWithTheRowTotalsOfAPeriod(request, requestOptions));
+    statementRowsList(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__statementRowsList(request, requestOptions));
     }
-    async __accountsPlacedOnTheRowsOfAStatementLayoutWithTheRowTotalsOfAPeriod(request, requestOptions) {
+    async __statementRowsList(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({
@@ -1944,12 +2087,16 @@ class LedgerClient {
                     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:
@@ -1969,28 +2116,30 @@ class LedgerClient {
     /**
      * A mapping on a code prefix covers every account whose code starts with it; the longest matching prefix wins. An empty rowCode removes the mapping so the layout default applies again.
      *
-     * @param {NordletApi.PostV1LedgerStatementRowsSetRequest} request
+     * @param {NordletApi.StatementRowsSetLedgerRequest} request
      * @param {LedgerClient.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.ledger.mapAnAccountOrAnAccountCodePrefixToARowOfAStatementLayout({
+     *     await client.ledger.statementRowsSet({
      *         scheme: "scheme",
      *         accountCode: "accountCode"
      *     })
      */
-    mapAnAccountOrAnAccountCodePrefixToARowOfAStatementLayout(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__mapAnAccountOrAnAccountCodePrefixToARowOfAStatementLayout(request, requestOptions));
+    statementRowsSet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__statementRowsSet(request, requestOptions));
     }
-    async __mapAnAccountOrAnAccountCodePrefixToARowOfAStatementLayout(request, requestOptions) {
+    async __statementRowsSet(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({
@@ -2021,12 +2170,16 @@ class LedgerClient {
                     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:
@@ -2043,304 +2196,5 @@ class LedgerClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/ledger/statement-rows/set");
     }
-    /**
-     * Directors, board members, the company secretary, representatives and liquidators, with their personal identifier, appointment and resignation dates and whether they sign the annual accounts. Annual returns and registry deposits are built from this register.
-     *
-     * @param {NordletApi.PostV1OfficersListRequest} request
-     * @param {LedgerClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.ledger.officersOfTheCompany()
-     */
-    officersOfTheCompany(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__officersOfTheCompany(request, requestOptions));
-    }
-    async __officersOfTheCompany(request = {}, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/officers/list"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/officers/list");
-    }
-    /**
-     * @param {NordletApi.PostV1OfficersCreateRequest} request
-     * @param {LedgerClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.ledger.recordAnOfficerOfTheCompany({
-     *         name: "name",
-     *         role: "director"
-     *     })
-     */
-    recordAnOfficerOfTheCompany(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__recordAnOfficerOfTheCompany(request, requestOptions));
-    }
-    async __recordAnOfficerOfTheCompany(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/officers/create"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/officers/create");
-    }
-    /**
-     * @param {NordletApi.PostV1OfficersUpdateRequest} request
-     * @param {LedgerClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.ledger.changeARecordedOfficer({
-     *         id: "id",
-     *         name: "name",
-     *         role: "director"
-     *     })
-     */
-    changeARecordedOfficer(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__changeARecordedOfficer(request, requestOptions));
-    }
-    async __changeARecordedOfficer(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/officers/update"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/officers/update");
-    }
-    /**
-     * @param {NordletApi.PostV1OfficersDeleteRequest} request
-     * @param {LedgerClient.RequestOptions} requestOptions - Request-specific configuration.
-     *
-     * @throws {@link NordletApi.BadRequestError}
-     * @throws {@link NordletApi.UnauthorizedError}
-     * @throws {@link NordletApi.ForbiddenError}
-     * @throws {@link NordletApi.NotFoundError}
-     * @throws {@link NordletApi.ConflictError}
-     * @throws {@link NordletApi.UnprocessableEntityError}
-     * @throws {@link NordletApi.TooManyRequestsError}
-     * @throws {@link NordletApi.InternalServerError}
-     *
-     * @example
-     *     await client.ledger.removeARecordedOfficer({
-     *         id: "id"
-     *     })
-     */
-    removeARecordedOfficer(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__removeARecordedOfficer(request, requestOptions));
-    }
-    async __removeARecordedOfficer(request, requestOptions) {
-        const _authRequest = await this._options.authProvider.getAuthRequest();
-        const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
-        const _response = await core.fetcher({
-            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
-                (await core.Supplier.get(this._options.environment)) ??
-                environments.NordletApiEnvironment.Production, "v1/officers/delete"),
-            method: "POST",
-            headers: _headers,
-            contentType: "application/json",
-            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
-            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
-            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
-            abortSignal: requestOptions?.abortSignal,
-            fetchFn: this._options?.fetch,
-            logging: this._options.logging,
-        });
-        if (_response.ok) {
-            return {
-                data: _response.body,
-                rawResponse: _response.rawResponse,
-            };
-        }
-        if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
-                case 401:
-                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
-                case 409:
-                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
-                case 422:
-                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
-                case 429:
-                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
-                case 500:
-                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
-                default:
-                    throw new errors.NordletApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                        rawResponse: _response.rawResponse,
-                    });
-            }
-        }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/officers/delete");
-    }
 }
 exports.LedgerClient = LedgerClient;