nordlet 0.2.8 → 0.3.7

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

@@ -48,28 +48,30 @@ class ReportsClient {
         this._options = (0, BaseClient_js_1.normalizeClientOptionsWithAuth)(options);
     }
     /**
-     * @param {NordletApi.PostV1ReportsTrialBalanceRequest} request
+     * @param {NordletApi.TrialBalanceReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsTrialBalance({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.trialBalance({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsTrialBalance(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsTrialBalance(request, requestOptions));
+    trialBalance(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__trialBalance(request, requestOptions));
     }
-    async __postV1ReportsTrialBalance(request, requestOptions) {
+    async __trialBalance(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -100,12 +102,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -123,27 +129,29 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/trial-balance");
     }
     /**
-     * @param {NordletApi.PostV1ReportsSizeCategoryRequest} request
+     * @param {NordletApi.SizeCategoryReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsSizeCategory({
+     *     await client.reports.sizeCategory({
      *         year: 1000000
      *     })
      */
-    postV1ReportsSizeCategory(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsSizeCategory(request, requestOptions));
+    sizeCategory(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__sizeCategory(request, requestOptions));
     }
-    async __postV1ReportsSizeCategory(request, requestOptions) {
+    async __sizeCategory(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({
@@ -174,12 +182,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -197,28 +209,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/size-category");
     }
     /**
-     * @param {NordletApi.PostV1ReportsFinancialStatementsRequest} request
+     * @param {NordletApi.FinancialStatementsReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsFinancialStatements({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.financialStatements({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsFinancialStatements(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsFinancialStatements(request, requestOptions));
+    financialStatements(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__financialStatements(request, requestOptions));
     }
-    async __postV1ReportsFinancialStatements(request, requestOptions) {
+    async __financialStatements(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -249,12 +263,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -272,28 +290,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/financial-statements");
     }
     /**
-     * @param {NordletApi.PostV1ReportsGeneralJournalRequest} request
+     * @param {NordletApi.GeneralJournalReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsGeneralJournal({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.generalJournal({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsGeneralJournal(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsGeneralJournal(request, requestOptions));
+    generalJournal(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__generalJournal(request, requestOptions));
     }
-    async __postV1ReportsGeneralJournal(request, requestOptions) {
+    async __generalJournal(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -324,12 +344,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -347,29 +371,31 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/general-journal");
     }
     /**
-     * @param {NordletApi.PostV1ReportsGlDetailRequest} request
+     * @param {NordletApi.GlDetailReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsGlDetail({
+     *     await client.reports.glDetail({
      *         accountCode: "accountCode",
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsGlDetail(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsGlDetail(request, requestOptions));
+    glDetail(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__glDetail(request, requestOptions));
     }
-    async __postV1ReportsGlDetail(request, requestOptions) {
+    async __glDetail(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({
@@ -389,10 +415,7 @@ class ReportsClient {
             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) {
@@ -400,12 +423,16 @@ class ReportsClient {
                     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:
@@ -423,25 +450,27 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/gl-detail");
     }
     /**
-     * @param {NordletApi.PostV1ReportsPartnerBalancesRequest} request
+     * @param {NordletApi.PartnerBalancesReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsPartnerBalances()
+     *     await client.reports.partnerBalances()
      */
-    postV1ReportsPartnerBalances(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsPartnerBalances(request, requestOptions));
+    partnerBalances(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__partnerBalances(request, requestOptions));
     }
-    async __postV1ReportsPartnerBalances(request = {}, requestOptions) {
+    async __partnerBalances(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({
@@ -472,12 +501,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -495,25 +528,27 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/partner-balances");
     }
     /**
-     * @param {NordletApi.PostV1ReportsDebtAgingRequest} request
+     * @param {NordletApi.DebtAgingReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsDebtAging()
+     *     await client.reports.debtAging()
      */
-    postV1ReportsDebtAging(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsDebtAging(request, requestOptions));
+    debtAging(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__debtAging(request, requestOptions));
     }
-    async __postV1ReportsDebtAging(request = {}, requestOptions) {
+    async __debtAging(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({
@@ -533,10 +568,7 @@ class ReportsClient {
             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) {
@@ -544,12 +576,16 @@ class ReportsClient {
                     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:
@@ -567,25 +603,27 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/debt-aging");
     }
     /**
-     * @param {NordletApi.PostV1ReportsMonthlySummaryRequest} request
+     * @param {NordletApi.MonthlySummaryReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsMonthlySummary()
+     *     await client.reports.monthlySummary()
      */
-    postV1ReportsMonthlySummary(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsMonthlySummary(request, requestOptions));
+    monthlySummary(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__monthlySummary(request, requestOptions));
     }
-    async __postV1ReportsMonthlySummary(request = {}, requestOptions) {
+    async __monthlySummary(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({
@@ -616,12 +654,16 @@ class ReportsClient {
                     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:
@@ -639,27 +681,29 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/monthly-summary");
     }
     /**
-     * @param {NordletApi.PostV1ReportsStockBalanceRequest} request
+     * @param {NordletApi.StockBalanceReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsStockBalance({
-     *         asOf: "asOf"
+     *     await client.reports.stockBalance({
+     *         asOf: "2026-07-01"
      *     })
      */
-    postV1ReportsStockBalance(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsStockBalance(request, requestOptions));
+    stockBalance(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__stockBalance(request, requestOptions));
     }
-    async __postV1ReportsStockBalance(request, requestOptions) {
+    async __stockBalance(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({
@@ -690,12 +734,16 @@ class ReportsClient {
                     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:
@@ -713,28 +761,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/stock-balance");
     }
     /**
-     * @param {NordletApi.PostV1ReportsStockMovementRequest} request
+     * @param {NordletApi.StockMovementReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsStockMovement({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.stockMovement({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsStockMovement(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsStockMovement(request, requestOptions));
+    stockMovement(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__stockMovement(request, requestOptions));
     }
-    async __postV1ReportsStockMovement(request, requestOptions) {
+    async __stockMovement(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({
@@ -765,12 +815,16 @@ class ReportsClient {
                     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:
@@ -788,28 +842,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/stock-movement");
     }
     /**
-     * @param {NordletApi.PostV1ReportsVatSummaryRequest} request
+     * @param {NordletApi.VatSummaryReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsVatSummary({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.vatSummary({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsVatSummary(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsVatSummary(request, requestOptions));
+    vatSummary(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__vatSummary(request, requestOptions));
     }
-    async __postV1ReportsVatSummary(request, requestOptions) {
+    async __vatSummary(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({
@@ -829,10 +885,7 @@ class ReportsClient {
             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) {
@@ -840,12 +893,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -863,28 +920,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/vat-summary");
     }
     /**
-     * @param {NordletApi.PostV1ReportsCashFlowRequest} request
+     * @param {NordletApi.CashFlowReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsCashFlow({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.cashFlow({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsCashFlow(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsCashFlow(request, requestOptions));
+    cashFlow(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__cashFlow(request, requestOptions));
     }
-    async __postV1ReportsCashFlow(request, requestOptions) {
+    async __cashFlow(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({
@@ -904,10 +963,7 @@ class ReportsClient {
             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) {
@@ -915,12 +971,16 @@ class ReportsClient {
                     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:
@@ -938,27 +998,29 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/cash-flow");
     }
     /**
-     * @param {NordletApi.PostV1ReportsStockAgingRequest} request
+     * @param {NordletApi.StockAgingReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsStockAging({
-     *         asOf: "asOf"
+     *     await client.reports.stockAging({
+     *         asOf: "2026-07-01"
      *     })
      */
-    postV1ReportsStockAging(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsStockAging(request, requestOptions));
+    stockAging(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__stockAging(request, requestOptions));
     }
-    async __postV1ReportsStockAging(request, requestOptions) {
+    async __stockAging(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({
@@ -978,10 +1040,7 @@ class ReportsClient {
             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) {
@@ -989,12 +1048,16 @@ class ReportsClient {
                     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:
@@ -1012,25 +1075,27 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/stock-aging");
     }
     /**
-     * @param {NordletApi.PostV1ReportsStockShortageRequest} request
+     * @param {NordletApi.StockShortageReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsStockShortage()
+     *     await client.reports.stockShortage()
      */
-    postV1ReportsStockShortage(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsStockShortage(request, requestOptions));
+    stockShortage(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__stockShortage(request, requestOptions));
     }
-    async __postV1ReportsStockShortage(request = {}, requestOptions) {
+    async __stockShortage(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({
@@ -1061,12 +1126,16 @@ class ReportsClient {
                     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:
@@ -1084,28 +1153,270 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/stock-shortage");
     }
     /**
-     * @param {NordletApi.PostV1ReportsEuPurchasesRequest} request
+     * Export the ledger of one financial year as an SIE file (the Swedish standard accounting interchange format, specification 4B). The file carries the chart of accounts, the opening and closing balance of every balance sheet account and the turnover of every result account for the year and the year before it, and, when asked for, every posted voucher of the year with its lines. Cost centres travel as dimension 1 and projects as dimension 6. Services that build a Swedish annual report read this file.
+     *
+     * @param {NordletApi.SieReportsRequest} request
+     * @param {ReportsClient.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.reports.sie({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
+     *     })
+     */
+    sie(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__sie(request, requestOptions));
+    }
+    async __sie(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/reports/sie"),
+            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/reports/sie");
+    }
+    /**
+     * Export the posted ledger of a period as a DATEV Buchungsstapel file (DATEV format, category 21, version 700). Every transaction becomes one or more bookings of an amount between an account and a contra account; a transaction with more than two lines is split into pairs whose totals match it. The file is semicolon separated and written in the Windows-1252 character set DATEV expects.
+     *
+     * @param {NordletApi.DatevReportsRequest} request
+     * @param {ReportsClient.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.reports.datev({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
+     *     })
+     */
+    datev(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__datev(request, requestOptions));
+    }
+    async __datev(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/reports/datev"),
+            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/reports/datev");
+    }
+    /**
+     * Export the posted ledger of a period as a French FEC file (fichier des écritures comptables, order of 29 July 2013). One line per journal entry line, with the eighteen fields the order names, in their order, after a header line. Tab separated, UTF-8, comma as the decimal separator.
+     *
+     * @param {NordletApi.FecReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsEuPurchases({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.fec({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsEuPurchases(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsEuPurchases(request, requestOptions));
+    fec(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__fec(request, requestOptions));
     }
-    async __postV1ReportsEuPurchases(request, requestOptions) {
+    async __fec(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/reports/fec"),
+            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/reports/fec");
+    }
+    /**
+     * @param {NordletApi.EuPurchasesReportsRequest} request
+     * @param {ReportsClient.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.reports.euPurchases({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
+     *     })
+     */
+    euPurchases(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__euPurchases(request, requestOptions));
+    }
+    async __euPurchases(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1136,12 +1447,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1159,28 +1474,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/eu-purchases");
     }
     /**
-     * @param {NordletApi.PostV1ReportsVatDetailRequest} request
+     * @param {NordletApi.VatDetailReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsVatDetail({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.vatDetail({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsVatDetail(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsVatDetail(request, requestOptions));
+    vatDetail(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__vatDetail(request, requestOptions));
     }
-    async __postV1ReportsVatDetail(request, requestOptions) {
+    async __vatDetail(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({
@@ -1200,10 +1517,7 @@ class ReportsClient {
             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) {
@@ -1211,12 +1525,16 @@ class ReportsClient {
                     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:
@@ -1234,28 +1552,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/vat-detail");
     }
     /**
-     * @param {NordletApi.PostV1ReportsPosSalesRequest} request
+     * @param {NordletApi.PosSalesReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsPosSales({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.posSales({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsPosSales(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsPosSales(request, requestOptions));
+    posSales(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__posSales(request, requestOptions));
     }
-    async __postV1ReportsPosSales(request, requestOptions) {
+    async __posSales(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1275,10 +1595,7 @@ class ReportsClient {
             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) {
@@ -1286,12 +1603,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1309,28 +1630,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/pos-sales");
     }
     /**
-     * @param {NordletApi.PostV1ReportsOnlineSalesRequest} request
+     * @param {NordletApi.OnlineSalesReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsOnlineSales({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.onlineSales({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsOnlineSales(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsOnlineSales(request, requestOptions));
+    onlineSales(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__onlineSales(request, requestOptions));
     }
-    async __postV1ReportsOnlineSales(request, requestOptions) {
+    async __onlineSales(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({
@@ -1361,12 +1684,16 @@ class ReportsClient {
                     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:
@@ -1384,28 +1711,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/online-sales");
     }
     /**
-     * @param {NordletApi.PostV1ReportsOssRequest} request
+     * @param {NordletApi.OssReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsOss({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.oss({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsOss(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsOss(request, requestOptions));
+    oss(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__oss(request, requestOptions));
     }
-    async __postV1ReportsOss(request, requestOptions) {
+    async __oss(request, requestOptions) {
         const _authRequest = await this._options.authProvider.getAuthRequest();
         const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, this._options?.headers, requestOptions?.headers);
         const _response = await core.fetcher({
@@ -1433,12 +1762,16 @@ class ReportsClient {
                     throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
                 case 401:
                     throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new NordletApi.PaymentRequiredError(_response.error.body, _response.rawResponse);
                 case 403:
                     throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
                 case 409:
                     throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 413:
+                    throw new NordletApi.ContentTooLargeError(_response.error.body, _response.rawResponse);
                 case 422:
                     throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 429:
@@ -1456,28 +1789,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/oss");
     }
     /**
-     * @param {NordletApi.PostV1ReportsAdvanceReconciliationRequest} request
+     * @param {NordletApi.AdvanceReconciliationReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsAdvanceReconciliation({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.advanceReconciliation({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsAdvanceReconciliation(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsAdvanceReconciliation(request, requestOptions));
+    advanceReconciliation(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__advanceReconciliation(request, requestOptions));
     }
-    async __postV1ReportsAdvanceReconciliation(request, requestOptions) {
+    async __advanceReconciliation(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({
@@ -1508,12 +1843,16 @@ class ReportsClient {
                     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:
@@ -1531,28 +1870,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/advance-reconciliation");
     }
     /**
-     * @param {NordletApi.PostV1ReportsWriteOffActsRequest} request
+     * @param {NordletApi.WriteOffActsReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsWriteOffActs({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.writeOffActs({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsWriteOffActs(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsWriteOffActs(request, requestOptions));
+    writeOffActs(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__writeOffActs(request, requestOptions));
     }
-    async __postV1ReportsWriteOffActs(request, requestOptions) {
+    async __writeOffActs(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({
@@ -1583,12 +1924,16 @@ class ReportsClient {
                     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:
@@ -1606,28 +1951,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/write-off-acts");
     }
     /**
-     * @param {NordletApi.PostV1ReportsCostCentersRequest} request
+     * @param {NordletApi.CostCentersReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsCostCenters({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.costCenters({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsCostCenters(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsCostCenters(request, requestOptions));
+    costCenters(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCenters(request, requestOptions));
     }
-    async __postV1ReportsCostCenters(request, requestOptions) {
+    async __costCenters(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({
@@ -1658,12 +2005,16 @@ class ReportsClient {
                     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:
@@ -1681,29 +2032,31 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/cost-centers");
     }
     /**
-     * @param {NordletApi.PostV1ReportsCostCenterActivityRequest} request
+     * @param {NordletApi.CostCenterActivityReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsCostCenterActivity({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate",
+     *     await client.reports.costCenterActivity({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01",
      *         costCenterId: "costCenterId"
      *     })
      */
-    postV1ReportsCostCenterActivity(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsCostCenterActivity(request, requestOptions));
+    costCenterActivity(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCenterActivity(request, requestOptions));
     }
-    async __postV1ReportsCostCenterActivity(request, requestOptions) {
+    async __costCenterActivity(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({
@@ -1734,12 +2087,16 @@ class ReportsClient {
                     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:
@@ -1757,28 +2114,30 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/cost-center-activity");
     }
     /**
-     * @param {NordletApi.PostV1ReportsCostCenterItemsRequest} request
+     * @param {NordletApi.CostCenterItemsReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsCostCenterItems({
-     *         fromDate: "fromDate",
-     *         toDate: "toDate"
+     *     await client.reports.costCenterItems({
+     *         fromDate: "2026-07-01",
+     *         toDate: "2026-07-01"
      *     })
      */
-    postV1ReportsCostCenterItems(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsCostCenterItems(request, requestOptions));
+    costCenterItems(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__costCenterItems(request, requestOptions));
     }
-    async __postV1ReportsCostCenterItems(request, requestOptions) {
+    async __costCenterItems(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({
@@ -1809,12 +2168,16 @@ class ReportsClient {
                     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:
@@ -1832,27 +2195,29 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/cost-center-items");
     }
     /**
-     * @param {NordletApi.PostV1ReportsJobsCreateRequest} request
+     * @param {NordletApi.JobsCreateReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsJobsCreate({
+     *     await client.reports.jobsCreate({
      *         reportType: "reportType"
      *     })
      */
-    postV1ReportsJobsCreate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsJobsCreate(request, requestOptions));
+    jobsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__jobsCreate(request, requestOptions));
     }
-    async __postV1ReportsJobsCreate(request, requestOptions) {
+    async __jobsCreate(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({
@@ -1872,10 +2237,7 @@ class ReportsClient {
             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) {
@@ -1883,12 +2245,16 @@ class ReportsClient {
                     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:
@@ -1906,27 +2272,29 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/jobs/create");
     }
     /**
-     * @param {NordletApi.PostV1ReportsJobsGetRequest} request
+     * @param {NordletApi.JobsGetReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsJobsGet({
+     *     await client.reports.jobsGet({
      *         id: "id"
      *     })
      */
-    postV1ReportsJobsGet(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsJobsGet(request, requestOptions));
+    jobsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__jobsGet(request, requestOptions));
     }
-    async __postV1ReportsJobsGet(request, requestOptions) {
+    async __jobsGet(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({
@@ -1946,10 +2314,7 @@ class ReportsClient {
             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) {
@@ -1957,12 +2322,16 @@ class ReportsClient {
                     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 +2349,27 @@ class ReportsClient {
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/reports/jobs/get");
     }
     /**
-     * @param {NordletApi.PostV1ReportsJobsListRequest} request
+     * @param {NordletApi.JobsListReportsRequest} request
      * @param {ReportsClient.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.reports.postV1ReportsJobsList()
+     *     await client.reports.jobsList()
      */
-    postV1ReportsJobsList(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__postV1ReportsJobsList(request, requestOptions));
+    jobsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__jobsList(request, requestOptions));
     }
-    async __postV1ReportsJobsList(request = {}, requestOptions) {
+    async __jobsList(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({
@@ -2018,10 +2389,7 @@ class ReportsClient {
             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) {
@@ -2029,12 +2397,16 @@ class ReportsClient {
                     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: