nordlet 0.3.4 → 0.3.8

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

@@ -48,27 +48,29 @@ class BankClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {NordletApi.PostV1BankAccountsCreateRequest} request
+     * @param {NordletApi.AccountsCreateBankRequest} request
      * @param {BankClient.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.bank.postV1BankAccountsCreate({
+     *     await client.bank.accountsCreate({
      *         name: "name"
      *     })
      */
-    postV1BankAccountsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankAccountsCreate(request, requestOptions));
+    accountsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsCreate(request, requestOptions));
     }
-    async __postV1BankAccountsCreate(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({
@@ -99,12 +101,16 @@ class BankClient {
                     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:
@@ -122,25 +128,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/accounts/create");
     }
     /**
-     * @param {NordletApi.PostV1BankAccountsListRequest} request
+     * @param {NordletApi.AccountsListBankRequest} request
      * @param {BankClient.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.bank.postV1BankAccountsList()
+     *     await client.bank.accountsList()
      */
-    postV1BankAccountsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankAccountsList(request, requestOptions));
+    accountsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsList(request, requestOptions));
     }
-    async __postV1BankAccountsList(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({
@@ -160,10 +168,7 @@ class BankClient {
             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) {
@@ -171,12 +176,16 @@ class BankClient {
                     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:
@@ -194,27 +203,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/accounts/list");
     }
     /**
-     * @param {NordletApi.PostV1BankAccountsUpdateRequest} request
+     * @param {NordletApi.AccountsUpdateBankRequest} request
      * @param {BankClient.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.bank.postV1BankAccountsUpdate({
+     *     await client.bank.accountsUpdate({
      *         id: "id"
      *     })
      */
-    postV1BankAccountsUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankAccountsUpdate(request, requestOptions));
+    accountsUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__accountsUpdate(request, requestOptions));
     }
-    async __postV1BankAccountsUpdate(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({
@@ -245,12 +256,16 @@ class BankClient {
                     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:
@@ -268,31 +283,33 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/accounts/update");
     }
     /**
-     * @param {NordletApi.PostV1BankTransactionsImportRequest} request
+     * @param {NordletApi.TransactionsImportBankRequest} request
      * @param {BankClient.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.bank.postV1BankTransactionsImport({
+     *     await client.bank.transactionsImport({
      *         bankAccountId: "bankAccountId",
      *         transactions: [{
-     *                 date: "date",
-     *                 amount: "amount"
+     *                 date: "2026-07-01",
+     *                 amount: "-121.0000"
      *             }]
      *     })
      */
-    postV1BankTransactionsImport(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankTransactionsImport(request, requestOptions));
+    transactionsImport(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__transactionsImport(request, requestOptions));
     }
-    async __postV1BankTransactionsImport(request, requestOptions) {
+    async __transactionsImport(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({
@@ -323,12 +340,16 @@ class BankClient {
                     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:
@@ -346,28 +367,30 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/transactions/import");
     }
     /**
-     * @param {NordletApi.PostV1BankStatementsImportRequest} request
+     * @param {NordletApi.StatementsImportBankRequest} request
      * @param {BankClient.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.bank.postV1BankStatementsImport({
+     *     await client.bank.statementsImport({
      *         bankAccountId: "bankAccountId",
      *         content: "content"
      *     })
      */
-    postV1BankStatementsImport(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankStatementsImport(request, requestOptions));
+    statementsImport(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__statementsImport(request, requestOptions));
     }
-    async __postV1BankStatementsImport(request, requestOptions) {
+    async __statementsImport(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -398,12 +421,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -421,25 +448,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/statements/import");
     }
     /**
-     * @param {NordletApi.PostV1BankTransactionsListRequest} request
+     * @param {NordletApi.TransactionsListBankRequest} request
      * @param {BankClient.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.bank.postV1BankTransactionsList()
+     *     await client.bank.transactionsList()
      */
-    postV1BankTransactionsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankTransactionsList(request, requestOptions));
+    transactionsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__transactionsList(request, requestOptions));
     }
-    async __postV1BankTransactionsList(request = {}, requestOptions) {
+    async __transactionsList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -470,12 +499,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -493,29 +526,31 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/transactions/list");
     }
     /**
-     * @param {NordletApi.PostV1BankTransactionsMatchRequest} request
+     * @param {NordletApi.TransactionsMatchBankRequest} request
      * @param {BankClient.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.bank.postV1BankTransactionsMatch({
+     *     await client.bank.transactionsMatch({
      *         transactionId: "transactionId",
      *         documentType: "sale_invoice",
      *         documentId: "documentId"
      *     })
      */
-    postV1BankTransactionsMatch(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankTransactionsMatch(request, requestOptions));
+    transactionsMatch(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__transactionsMatch(request, requestOptions));
     }
-    async __postV1BankTransactionsMatch(request, requestOptions) {
+    async __transactionsMatch(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -546,12 +581,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -569,31 +608,115 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/transactions/match");
     }
     /**
-     * @param {NordletApi.PostV1BankTransactionsRecordRequest} request
+     * Undo a match. A payment matched to an invoice, or a line posted by an import template, gets a reversing journal transaction dated date (default: today) and the invoice paid amount and payment status are restored; a line linked to a payment-provider settlement is only unlinked. The line returns to status new.
+     *
+     * @param {NordletApi.TransactionsUnmatchBankRequest} request
+     * @param {BankClient.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.bank.transactionsUnmatch({
+     *         transactionId: "transactionId"
+     *     })
+     */
+    transactionsUnmatch(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__transactionsUnmatch(request, requestOptions));
+    }
+    async __transactionsUnmatch(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/bank/transactions/unmatch"),
+            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 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:
+                    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/bank/transactions/unmatch");
+    }
+    /**
+     * @param {NordletApi.TransactionsRecordBankRequest} request
      * @param {BankClient.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.bank.postV1BankTransactionsRecord({
+     *     await client.bank.transactionsRecord({
      *         bankAccountId: "bankAccountId",
-     *         date: "date",
-     *         amount: "amount",
+     *         date: "2026-07-01",
+     *         amount: "121.0000",
      *         documentType: "sale_invoice",
      *         documentId: "documentId"
      *     })
      */
-    postV1BankTransactionsRecord(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankTransactionsRecord(request, requestOptions));
+    transactionsRecord(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__transactionsRecord(request, requestOptions));
     }
-    async __postV1BankTransactionsRecord(request, requestOptions) {
+    async __transactionsRecord(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({
@@ -624,12 +747,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -647,28 +774,30 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/transactions/record");
     }
     /**
-     * @param {NordletApi.PostV1BankPaymentsExportRequest} request
+     * @param {NordletApi.PaymentsExportBankRequest} request
      * @param {BankClient.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.bank.postV1BankPaymentsExport({
+     *     await client.bank.paymentsExport({
      *         bankAccountId: "bankAccountId",
      *         purchaseInvoiceIds: ["purchaseInvoiceIds"]
      *     })
      */
-    postV1BankPaymentsExport(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankPaymentsExport(request, requestOptions));
+    paymentsExport(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__paymentsExport(request, requestOptions));
     }
-    async __postV1BankPaymentsExport(request, requestOptions) {
+    async __paymentsExport(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({
@@ -699,12 +828,16 @@ class BankClient {
                     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:
@@ -722,28 +855,30 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/payments/export");
     }
     /**
-     * @param {NordletApi.PostV1BankImportTemplatesCreateRequest} request
+     * @param {NordletApi.ImportTemplatesCreateBankRequest} request
      * @param {BankClient.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.bank.createABankImportTemplateFieldsDefaultToTheTypesStandardFieldList({
+     *     await client.bank.importTemplatesCreate({
      *         name: "name",
      *         type: "stripe"
      *     })
      */
-    createABankImportTemplateFieldsDefaultToTheTypesStandardFieldList(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__createABankImportTemplateFieldsDefaultToTheTypesStandardFieldList(request, requestOptions));
+    importTemplatesCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__importTemplatesCreate(request, requestOptions));
     }
-    async __createABankImportTemplateFieldsDefaultToTheTypesStandardFieldList(request, requestOptions) {
+    async __importTemplatesCreate(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -774,12 +909,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -797,27 +936,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/import-templates/create");
     }
     /**
-     * @param {NordletApi.PostV1BankImportTemplatesUpdateRequest} request
+     * @param {NordletApi.ImportTemplatesUpdateBankRequest} request
      * @param {BankClient.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.bank.postV1BankImportTemplatesUpdate({
+     *     await client.bank.importTemplatesUpdate({
      *         id: "id"
      *     })
      */
-    postV1BankImportTemplatesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankImportTemplatesUpdate(request, requestOptions));
+    importTemplatesUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__importTemplatesUpdate(request, requestOptions));
     }
-    async __postV1BankImportTemplatesUpdate(request, requestOptions) {
+    async __importTemplatesUpdate(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({
@@ -848,12 +989,16 @@ class BankClient {
                     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:
@@ -871,27 +1016,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/import-templates/update");
     }
     /**
-     * @param {NordletApi.PostV1BankImportTemplatesDeleteRequest} request
+     * @param {NordletApi.ImportTemplatesDeleteBankRequest} request
      * @param {BankClient.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.bank.postV1BankImportTemplatesDelete({
+     *     await client.bank.importTemplatesDelete({
      *         id: "id"
      *     })
      */
-    postV1BankImportTemplatesDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankImportTemplatesDelete(request, requestOptions));
+    importTemplatesDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__importTemplatesDelete(request, requestOptions));
     }
-    async __postV1BankImportTemplatesDelete(request, requestOptions) {
+    async __importTemplatesDelete(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({
@@ -922,12 +1069,16 @@ class BankClient {
                     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:
@@ -945,27 +1096,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/import-templates/delete");
     }
     /**
-     * @param {NordletApi.PostV1BankImportTemplatesGetRequest} request
+     * @param {NordletApi.ImportTemplatesGetBankRequest} request
      * @param {BankClient.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.bank.postV1BankImportTemplatesGet({
+     *     await client.bank.importTemplatesGet({
      *         id: "id"
      *     })
      */
-    postV1BankImportTemplatesGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankImportTemplatesGet(request, requestOptions));
+    importTemplatesGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__importTemplatesGet(request, requestOptions));
     }
-    async __postV1BankImportTemplatesGet(request, requestOptions) {
+    async __importTemplatesGet(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({
@@ -996,12 +1149,16 @@ class BankClient {
                     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:
@@ -1019,25 +1176,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/import-templates/get");
     }
     /**
-     * @param {NordletApi.PostV1BankImportTemplatesListRequest} request
+     * @param {NordletApi.ImportTemplatesListBankRequest} request
      * @param {BankClient.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.bank.postV1BankImportTemplatesList()
+     *     await client.bank.importTemplatesList()
      */
-    postV1BankImportTemplatesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankImportTemplatesList(request, requestOptions));
+    importTemplatesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__importTemplatesList(request, requestOptions));
     }
-    async __postV1BankImportTemplatesList(request = {}, requestOptions) {
+    async __importTemplatesList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1068,12 +1227,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1091,28 +1254,30 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/import-templates/list");
     }
     /**
-     * @param {NordletApi.PostV1BankMatchRulesCreateRequest} request
+     * @param {NordletApi.MatchRulesCreateBankRequest} request
      * @param {BankClient.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.bank.postV1BankMatchRulesCreate({
+     *     await client.bank.matchRulesCreate({
      *         name: "name",
      *         pattern: "pattern"
      *     })
      */
-    postV1BankMatchRulesCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMatchRulesCreate(request, requestOptions));
+    matchRulesCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__matchRulesCreate(request, requestOptions));
     }
-    async __postV1BankMatchRulesCreate(request, requestOptions) {
+    async __matchRulesCreate(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({
@@ -1143,12 +1308,16 @@ class BankClient {
                     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:
@@ -1166,27 +1335,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/match-rules/create");
     }
     /**
-     * @param {NordletApi.PostV1BankMatchRulesUpdateRequest} request
+     * @param {NordletApi.MatchRulesUpdateBankRequest} request
      * @param {BankClient.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.bank.postV1BankMatchRulesUpdate({
+     *     await client.bank.matchRulesUpdate({
      *         id: "id"
      *     })
      */
-    postV1BankMatchRulesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMatchRulesUpdate(request, requestOptions));
+    matchRulesUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__matchRulesUpdate(request, requestOptions));
     }
-    async __postV1BankMatchRulesUpdate(request, requestOptions) {
+    async __matchRulesUpdate(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({
@@ -1217,12 +1388,16 @@ class BankClient {
                     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:
@@ -1240,27 +1415,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/match-rules/update");
     }
     /**
-     * @param {NordletApi.PostV1BankMatchRulesDeleteRequest} request
+     * @param {NordletApi.MatchRulesDeleteBankRequest} request
      * @param {BankClient.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.bank.postV1BankMatchRulesDelete({
+     *     await client.bank.matchRulesDelete({
      *         id: "id"
      *     })
      */
-    postV1BankMatchRulesDelete(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMatchRulesDelete(request, requestOptions));
+    matchRulesDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__matchRulesDelete(request, requestOptions));
     }
-    async __postV1BankMatchRulesDelete(request, requestOptions) {
+    async __matchRulesDelete(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({
@@ -1291,12 +1468,16 @@ class BankClient {
                     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:
@@ -1314,25 +1495,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/match-rules/delete");
     }
     /**
-     * @param {NordletApi.PostV1BankMatchRulesListRequest} request
+     * @param {NordletApi.MatchRulesListBankRequest} request
      * @param {BankClient.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.bank.postV1BankMatchRulesList()
+     *     await client.bank.matchRulesList()
      */
-    postV1BankMatchRulesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMatchRulesList(request, requestOptions));
+    matchRulesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__matchRulesList(request, requestOptions));
     }
-    async __postV1BankMatchRulesList(request = {}, requestOptions) {
+    async __matchRulesList(request = {}, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1363,12 +1546,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1386,29 +1573,31 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/match-rules/list");
     }
     /**
-     * @param {NordletApi.PostV1BankMandatesCreateRequest} request
+     * @param {NordletApi.MandatesCreateBankRequest} request
      * @param {BankClient.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.bank.postV1BankMandatesCreate({
+     *     await client.bank.mandatesCreate({
      *         partnerId: "partnerId",
      *         iban: "iban",
-     *         signatureDate: "signatureDate"
+     *         signatureDate: "2026-07-01"
      *     })
      */
-    postV1BankMandatesCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMandatesCreate(request, requestOptions));
+    mandatesCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__mandatesCreate(request, requestOptions));
     }
-    async __postV1BankMandatesCreate(request, requestOptions) {
+    async __mandatesCreate(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({
@@ -1439,12 +1628,16 @@ class BankClient {
                     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:
@@ -1462,27 +1655,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/mandates/create");
     }
     /**
-     * @param {NordletApi.PostV1BankMandatesUpdateRequest} request
+     * @param {NordletApi.MandatesUpdateBankRequest} request
      * @param {BankClient.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.bank.postV1BankMandatesUpdate({
+     *     await client.bank.mandatesUpdate({
      *         id: "id"
      *     })
      */
-    postV1BankMandatesUpdate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMandatesUpdate(request, requestOptions));
+    mandatesUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__mandatesUpdate(request, requestOptions));
     }
-    async __postV1BankMandatesUpdate(request, requestOptions) {
+    async __mandatesUpdate(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({
@@ -1513,12 +1708,16 @@ class BankClient {
                     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:
@@ -1536,27 +1735,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/mandates/update");
     }
     /**
-     * @param {NordletApi.PostV1BankMandatesCancelRequest} request
+     * @param {NordletApi.MandatesCancelBankRequest} request
      * @param {BankClient.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.bank.postV1BankMandatesCancel({
+     *     await client.bank.mandatesCancel({
      *         id: "id"
      *     })
      */
-    postV1BankMandatesCancel(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMandatesCancel(request, requestOptions));
+    mandatesCancel(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__mandatesCancel(request, requestOptions));
     }
-    async __postV1BankMandatesCancel(request, requestOptions) {
+    async __mandatesCancel(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1587,12 +1788,16 @@ class BankClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1610,27 +1815,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/mandates/cancel");
     }
     /**
-     * @param {NordletApi.PostV1BankMandatesGetRequest} request
+     * @param {NordletApi.MandatesGetBankRequest} request
      * @param {BankClient.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.bank.postV1BankMandatesGet({
+     *     await client.bank.mandatesGet({
      *         id: "id"
      *     })
      */
-    postV1BankMandatesGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMandatesGet(request, requestOptions));
+    mandatesGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__mandatesGet(request, requestOptions));
     }
-    async __postV1BankMandatesGet(request, requestOptions) {
+    async __mandatesGet(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({
@@ -1650,10 +1857,7 @@ class BankClient {
             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) {
@@ -1661,12 +1865,16 @@ class BankClient {
                     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:
@@ -1684,25 +1892,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/mandates/get");
     }
     /**
-     * @param {NordletApi.PostV1BankMandatesListRequest} request
+     * @param {NordletApi.MandatesListBankRequest} request
      * @param {BankClient.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.bank.postV1BankMandatesList()
+     *     await client.bank.mandatesList()
      */
-    postV1BankMandatesList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankMandatesList(request, requestOptions));
+    mandatesList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__mandatesList(request, requestOptions));
     }
-    async __postV1BankMandatesList(request = {}, requestOptions) {
+    async __mandatesList(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({
@@ -1721,6 +1931,81 @@ class BankClient {
             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 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:
+                    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/bank/mandates/list");
+    }
+    /**
+     * @param {NordletApi.DirectDebitsCandidatesBankRequest} request
+     * @param {BankClient.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.bank.directDebitsCandidates()
+     */
+    directDebitsCandidates(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__directDebitsCandidates(request, requestOptions));
+    }
+    async __directDebitsCandidates(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/bank/direct-debits/candidates"),
+            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,
@@ -1733,12 +2018,16 @@ class BankClient {
                     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:
@@ -1753,31 +2042,33 @@ class BankClient {
                     });
             }
         }
-        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/mandates/list");
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/direct-debits/candidates");
     }
     /**
-     * @param {NordletApi.PostV1BankDirectDebitsExportRequest} request
+     * @param {NordletApi.DirectDebitsExportBankRequest} request
      * @param {BankClient.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.bank.postV1BankDirectDebitsExport({
+     *     await client.bank.directDebitsExport({
      *         bankAccountId: "bankAccountId",
      *         saleInvoiceIds: ["saleInvoiceIds"]
      *     })
      */
-    postV1BankDirectDebitsExport(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankDirectDebitsExport(request, requestOptions));
+    directDebitsExport(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__directDebitsExport(request, requestOptions));
     }
-    async __postV1BankDirectDebitsExport(request, requestOptions) {
+    async __directDebitsExport(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({
@@ -1808,12 +2099,16 @@ class BankClient {
                     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:
@@ -1831,27 +2126,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/direct-debits/export");
     }
     /**
-     * @param {NordletApi.PostV1BankTransactionsSuggestMatchesRequest} request
+     * @param {NordletApi.TransactionsSuggestMatchesBankRequest} request
      * @param {BankClient.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.bank.postV1BankTransactionsSuggestMatches({
+     *     await client.bank.transactionsSuggestMatches({
      *         transactionId: "transactionId"
      *     })
      */
-    postV1BankTransactionsSuggestMatches(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankTransactionsSuggestMatches(request, requestOptions));
+    transactionsSuggestMatches(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__transactionsSuggestMatches(request, requestOptions));
     }
-    async __postV1BankTransactionsSuggestMatches(request, requestOptions) {
+    async __transactionsSuggestMatches(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({
@@ -1882,12 +2179,16 @@ class BankClient {
                     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:
@@ -1905,28 +2206,30 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/transactions/suggest-matches");
     }
     /**
-     * @param {NordletApi.PostV1BankSettlementsImportRequest} request
+     * @param {NordletApi.SettlementsImportBankRequest} request
      * @param {BankClient.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.bank.postV1BankSettlementsImport({
+     *     await client.bank.settlementsImport({
      *         bankAccountId: "bankAccountId",
      *         content: "content"
      *     })
      */
-    postV1BankSettlementsImport(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankSettlementsImport(request, requestOptions));
+    settlementsImport(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsImport(request, requestOptions));
     }
-    async __postV1BankSettlementsImport(request, requestOptions) {
+    async __settlementsImport(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({
@@ -1957,12 +2260,16 @@ class BankClient {
                     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:
@@ -1980,25 +2287,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/settlements/import");
     }
     /**
-     * @param {NordletApi.PostV1BankSettlementsListRequest} request
+     * @param {NordletApi.SettlementsListBankRequest} request
      * @param {BankClient.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.bank.postV1BankSettlementsList()
+     *     await client.bank.settlementsList()
      */
-    postV1BankSettlementsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankSettlementsList(request, requestOptions));
+    settlementsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsList(request, requestOptions));
     }
-    async __postV1BankSettlementsList(request = {}, requestOptions) {
+    async __settlementsList(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({
@@ -2029,12 +2338,16 @@ class BankClient {
                     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:
@@ -2052,27 +2365,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/settlements/list");
     }
     /**
-     * @param {NordletApi.PostV1BankSettlementsGetRequest} request
+     * @param {NordletApi.SettlementsGetBankRequest} request
      * @param {BankClient.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.bank.postV1BankSettlementsGet({
+     *     await client.bank.settlementsGet({
      *         id: "id"
      *     })
      */
-    postV1BankSettlementsGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankSettlementsGet(request, requestOptions));
+    settlementsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsGet(request, requestOptions));
     }
-    async __postV1BankSettlementsGet(request, requestOptions) {
+    async __settlementsGet(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({
@@ -2103,12 +2418,16 @@ class BankClient {
                     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:
@@ -2126,27 +2445,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/settlements/get");
     }
     /**
-     * @param {NordletApi.PostV1BankSettlementsMatchRequest} request
+     * @param {NordletApi.SettlementsMatchBankRequest} request
      * @param {BankClient.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.bank.postV1BankSettlementsMatch({
+     *     await client.bank.settlementsMatch({
      *         lineId: "lineId"
      *     })
      */
-    postV1BankSettlementsMatch(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankSettlementsMatch(request, requestOptions));
+    settlementsMatch(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsMatch(request, requestOptions));
     }
-    async __postV1BankSettlementsMatch(request, requestOptions) {
+    async __settlementsMatch(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({
@@ -2177,12 +2498,16 @@ class BankClient {
                     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:
@@ -2202,27 +2527,29 @@ class BankClient {
     /**
      * A line with its own rate or amount is split with that value when the batch is posted. A line without one falls back to the commissionPercent given to the posting call, and without that the amount goes to the suspense account. Send both fields as null to clear the line back to the fallback.
      *
-     * @param {NordletApi.PostV1BankSettlementsCommissionRequest} request
+     * @param {NordletApi.SettlementsCommissionBankRequest} request
      * @param {BankClient.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.bank.setWhatTheMarketplaceKeepsFromOneSettlementLineAsARateOrAsAnAmount({
+     *     await client.bank.settlementsCommission({
      *         lineId: "lineId"
      *     })
      */
-    setWhatTheMarketplaceKeepsFromOneSettlementLineAsARateOrAsAnAmount(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__setWhatTheMarketplaceKeepsFromOneSettlementLineAsARateOrAsAnAmount(request, requestOptions));
+    settlementsCommission(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsCommission(request, requestOptions));
     }
-    async __setWhatTheMarketplaceKeepsFromOneSettlementLineAsARateOrAsAnAmount(request, requestOptions) {
+    async __settlementsCommission(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({
@@ -2253,12 +2580,16 @@ class BankClient {
                     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:
@@ -2278,28 +2609,30 @@ class BankClient {
     /**
      * Attach the incoming bank-statement line that carries this payout to the settlement batch.
      *
-     * @param {NordletApi.PostV1BankSettlementsLinkRequest} request
+     * @param {NordletApi.SettlementsLinkBankRequest} request
      * @param {BankClient.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.bank.postV1BankSettlementsLink({
+     *     await client.bank.settlementsLink({
      *         id: "id",
      *         bankTransactionId: "bankTransactionId"
      *     })
      */
-    postV1BankSettlementsLink(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankSettlementsLink(request, requestOptions));
+    settlementsLink(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsLink(request, requestOptions));
     }
-    async __postV1BankSettlementsLink(request, requestOptions) {
+    async __settlementsLink(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({
@@ -2330,12 +2663,16 @@ class BankClient {
                     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:
@@ -2355,27 +2692,29 @@ class BankClient {
     /**
      * Detach the bank-statement line from the settlement batch and return the line to unmatched.
      *
-     * @param {NordletApi.PostV1BankSettlementsUnlinkRequest} request
+     * @param {NordletApi.SettlementsUnlinkBankRequest} request
      * @param {BankClient.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.bank.postV1BankSettlementsUnlink({
+     *     await client.bank.settlementsUnlink({
      *         id: "id"
      *     })
      */
-    postV1BankSettlementsUnlink(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankSettlementsUnlink(request, requestOptions));
+    settlementsUnlink(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsUnlink(request, requestOptions));
     }
-    async __postV1BankSettlementsUnlink(request, requestOptions) {
+    async __settlementsUnlink(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({
@@ -2406,12 +2745,16 @@ class BankClient {
                     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:
@@ -2429,27 +2772,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/settlements/unlink");
     }
     /**
-     * @param {NordletApi.PostV1BankSettlementsPostRequest} request
+     * @param {NordletApi.SettlementsPostBankRequest} request
      * @param {BankClient.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.bank.postV1BankSettlementsPost({
+     *     await client.bank.settlementsPost({
      *         id: "id"
      *     })
      */
-    postV1BankSettlementsPost(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankSettlementsPost(request, requestOptions));
+    settlementsPost(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__settlementsPost(request, requestOptions));
     }
-    async __postV1BankSettlementsPost(request, requestOptions) {
+    async __settlementsPost(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({
@@ -2480,12 +2825,16 @@ class BankClient {
                     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:
@@ -2503,25 +2852,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/settlements/post");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsBanksListRequest} request
+     * @param {NordletApi.FeedsBanksListBankRequest} request
      * @param {BankClient.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.bank.listThePsd2BanksAspsPsAvailableToConnect()
+     *     await client.bank.feedsBanksList()
      */
-    listThePsd2BanksAspsPsAvailableToConnect(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__listThePsd2BanksAspsPsAvailableToConnect(request, requestOptions));
+    feedsBanksList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsBanksList(request, requestOptions));
     }
-    async __listThePsd2BanksAspsPsAvailableToConnect(request = {}, requestOptions) {
+    async __feedsBanksList(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({
@@ -2552,12 +2903,16 @@ class BankClient {
                     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:
@@ -2575,28 +2930,30 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/banks/list");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsConnectionsStartRequest} request
+     * @param {NordletApi.FeedsConnectionsStartBankRequest} request
      * @param {BankClient.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.bank.beginBankAuthorizationRedirectTheUserToTheReturnedUrl({
+     *     await client.bank.feedsConnectionsStart({
      *         aspspName: "aspspName",
      *         aspspCountry: "aspspCountry"
      *     })
      */
-    beginBankAuthorizationRedirectTheUserToTheReturnedUrl(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__beginBankAuthorizationRedirectTheUserToTheReturnedUrl(request, requestOptions));
+    feedsConnectionsStart(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsConnectionsStart(request, requestOptions));
     }
-    async __beginBankAuthorizationRedirectTheUserToTheReturnedUrl(request, requestOptions) {
+    async __feedsConnectionsStart(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({
@@ -2627,12 +2984,16 @@ class BankClient {
                     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:
@@ -2650,28 +3011,30 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/connections/start");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsConnectionsCompleteRequest} request
+     * @param {NordletApi.FeedsConnectionsCompleteBankRequest} request
      * @param {BankClient.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.bank.exchangeTheRedirectCodeForASessionAndStoreTheBankAccountsItExposes({
+     *     await client.bank.feedsConnectionsComplete({
      *         reference: "reference",
      *         code: "code"
      *     })
      */
-    exchangeTheRedirectCodeForASessionAndStoreTheBankAccountsItExposes(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__exchangeTheRedirectCodeForASessionAndStoreTheBankAccountsItExposes(request, requestOptions));
+    feedsConnectionsComplete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsConnectionsComplete(request, requestOptions));
     }
-    async __exchangeTheRedirectCodeForASessionAndStoreTheBankAccountsItExposes(request, requestOptions) {
+    async __feedsConnectionsComplete(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({
@@ -2702,12 +3065,16 @@ class BankClient {
                     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:
@@ -2725,27 +3092,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/connections/complete");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsConnectionsGetRequest} request
+     * @param {NordletApi.FeedsConnectionsGetBankRequest} request
      * @param {BankClient.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.bank.postV1BankFeedsConnectionsGet({
+     *     await client.bank.feedsConnectionsGet({
      *         id: "id"
      *     })
      */
-    postV1BankFeedsConnectionsGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankFeedsConnectionsGet(request, requestOptions));
+    feedsConnectionsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsConnectionsGet(request, requestOptions));
     }
-    async __postV1BankFeedsConnectionsGet(request, requestOptions) {
+    async __feedsConnectionsGet(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({
@@ -2776,12 +3145,16 @@ class BankClient {
                     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:
@@ -2799,25 +3172,27 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/connections/get");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsConnectionsListRequest} request
+     * @param {NordletApi.FeedsConnectionsListBankRequest} request
      * @param {BankClient.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.bank.postV1BankFeedsConnectionsList()
+     *     await client.bank.feedsConnectionsList()
      */
-    postV1BankFeedsConnectionsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1BankFeedsConnectionsList(request, requestOptions));
+    feedsConnectionsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsConnectionsList(request, requestOptions));
     }
-    async __postV1BankFeedsConnectionsList(request = {}, requestOptions) {
+    async __feedsConnectionsList(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({
@@ -2848,12 +3223,16 @@ class BankClient {
                     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:
@@ -2871,27 +3250,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/connections/list");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsConnectionsDeleteRequest} request
+     * @param {NordletApi.FeedsConnectionsDeleteBankRequest} request
      * @param {BankClient.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.bank.revokeTheConsentAtTheBankAndDropTheStoredConnection({
+     *     await client.bank.feedsConnectionsDelete({
      *         id: "id"
      *     })
      */
-    revokeTheConsentAtTheBankAndDropTheStoredConnection(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__revokeTheConsentAtTheBankAndDropTheStoredConnection(request, requestOptions));
+    feedsConnectionsDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsConnectionsDelete(request, requestOptions));
     }
-    async __revokeTheConsentAtTheBankAndDropTheStoredConnection(request, requestOptions) {
+    async __feedsConnectionsDelete(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({
@@ -2922,12 +3303,16 @@ class BankClient {
                     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:
@@ -2945,27 +3330,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/connections/delete");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsAccountsLinkRequest} request
+     * @param {NordletApi.FeedsAccountsLinkBankRequest} request
      * @param {BankClient.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.bank.pointABankFeedAccountAtALedgerBankAccountSoItsTransactionsCanBeSynced({
+     *     await client.bank.feedsAccountsLink({
      *         id: "id"
      *     })
      */
-    pointABankFeedAccountAtALedgerBankAccountSoItsTransactionsCanBeSynced(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__pointABankFeedAccountAtALedgerBankAccountSoItsTransactionsCanBeSynced(request, requestOptions));
+    feedsAccountsLink(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsAccountsLink(request, requestOptions));
     }
-    async __pointABankFeedAccountAtALedgerBankAccountSoItsTransactionsCanBeSynced(request, requestOptions) {
+    async __feedsAccountsLink(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({
@@ -2996,12 +3383,16 @@ class BankClient {
                     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:
@@ -3019,27 +3410,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/accounts/link");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsAccountsConfigureRequest} request
+     * @param {NordletApi.FeedsAccountsConfigureBankRequest} request
      * @param {BankClient.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.bank.chooseTheImportTemplateAppliedOnSyncAndHowOftenTheAccountIsSyncedAutomatically({
+     *     await client.bank.feedsAccountsConfigure({
      *         id: "id"
      *     })
      */
-    chooseTheImportTemplateAppliedOnSyncAndHowOftenTheAccountIsSyncedAutomatically(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__chooseTheImportTemplateAppliedOnSyncAndHowOftenTheAccountIsSyncedAutomatically(request, requestOptions));
+    feedsAccountsConfigure(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsAccountsConfigure(request, requestOptions));
     }
-    async __chooseTheImportTemplateAppliedOnSyncAndHowOftenTheAccountIsSyncedAutomatically(request, requestOptions) {
+    async __feedsAccountsConfigure(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({
@@ -3070,12 +3463,16 @@ class BankClient {
                     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:
@@ -3093,27 +3490,29 @@ class BankClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/bank/feeds/accounts/configure");
     }
     /**
-     * @param {NordletApi.PostV1BankFeedsSyncRequest} request
+     * @param {NordletApi.FeedsSyncBankRequest} request
      * @param {BankClient.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.bank.pullNewTransactionsFromTheBankIntoTheLedgerEmitsBankFeedSynced({
+     *     await client.bank.feedsSync({
      *         connectionId: "connectionId"
      *     })
      */
-    pullNewTransactionsFromTheBankIntoTheLedgerEmitsBankFeedSynced(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__pullNewTransactionsFromTheBankIntoTheLedgerEmitsBankFeedSynced(request, requestOptions));
+    feedsSync(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__feedsSync(request, requestOptions));
     }
-    async __pullNewTransactionsFromTheBankIntoTheLedgerEmitsBankFeedSynced(request, requestOptions) {
+    async __feedsSync(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({
@@ -3133,10 +3532,7 @@ class BankClient {
             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) {
@@ -3144,12 +3540,16 @@ class BankClient {
                     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: