nordlet 0.1.2 → 0.2.0

package/dist/api/resources/declarations/client/Client.d.ts

@@ -241,6 +241,139 @@ export declare class DeclarationsClient {
      */
     postV1DeclarationsEuIossCompute(request: NordletApi.PostV1DeclarationsEuIossComputeRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuIossComputeResponse>;
     private __postV1DeclarationsEuIossCompute;
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuDistanceSalesThresholdGetRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuDistanceSalesThresholdGet()
+     */
+    postV1DeclarationsEuDistanceSalesThresholdGet(request?: NordletApi.PostV1DeclarationsEuDistanceSalesThresholdGetRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuDistanceSalesThresholdGetResponse>;
+    private __postV1DeclarationsEuDistanceSalesThresholdGet;
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuUnionTurnoverGetRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuUnionTurnoverGet()
+     */
+    postV1DeclarationsEuUnionTurnoverGet(request?: NordletApi.PostV1DeclarationsEuUnionTurnoverGetRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuUnionTurnoverGetResponse>;
+    private __postV1DeclarationsEuUnionTurnoverGet;
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuSmeCrossBorderReportComputeRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuSmeCrossBorderReportCompute({
+     *         year: 1000000,
+     *         quarter: 1000000
+     *     })
+     */
+    postV1DeclarationsEuSmeCrossBorderReportCompute(request: NordletApi.PostV1DeclarationsEuSmeCrossBorderReportComputeRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuSmeCrossBorderReportComputeResponse>;
+    private __postV1DeclarationsEuSmeCrossBorderReportCompute;
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuSmeThresholdsListRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuSmeThresholdsList()
+     */
+    postV1DeclarationsEuSmeThresholdsList(request?: NordletApi.PostV1DeclarationsEuSmeThresholdsListRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuSmeThresholdsListResponse>;
+    private __postV1DeclarationsEuSmeThresholdsList;
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuSmeThresholdGetRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuSmeThresholdGet()
+     */
+    postV1DeclarationsEuSmeThresholdGet(request?: NordletApi.PostV1DeclarationsEuSmeThresholdGetRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuSmeThresholdGetResponse>;
+    private __postV1DeclarationsEuSmeThresholdGet;
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuVatReturnPacksListRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuVatReturnPacksList()
+     */
+    postV1DeclarationsEuVatReturnPacksList(request?: NordletApi.PostV1DeclarationsEuVatReturnPacksListRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuVatReturnPacksListResponse>;
+    private __postV1DeclarationsEuVatReturnPacksList;
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuVatReturnComputeRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuVatReturnCompute({
+     *         countryCode: "countryCode",
+     *         year: 1000000,
+     *         month: 1000000
+     *     })
+     */
+    postV1DeclarationsEuVatReturnCompute(request: NordletApi.PostV1DeclarationsEuVatReturnComputeRequest, requestOptions?: DeclarationsClient.RequestOptions): core.HttpResponsePromise<NordletApi.PostV1DeclarationsEuVatReturnComputeResponse>;
+    private __postV1DeclarationsEuVatReturnCompute;
     /**
      * @param {NordletApi.PostV1DeclarationsConfigsListRequest} request
      * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.

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

@@ -872,6 +872,517 @@ class DeclarationsClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/ioss/compute");
     }
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuDistanceSalesThresholdGetRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuDistanceSalesThresholdGet()
+     */
+    postV1DeclarationsEuDistanceSalesThresholdGet(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuDistanceSalesThresholdGet(request, requestOptions));
+    }
+    async __postV1DeclarationsEuDistanceSalesThresholdGet(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/declarations/eu/distance-sales-threshold/get"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/distance-sales-threshold/get");
+    }
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuUnionTurnoverGetRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuUnionTurnoverGet()
+     */
+    postV1DeclarationsEuUnionTurnoverGet(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuUnionTurnoverGet(request, requestOptions));
+    }
+    async __postV1DeclarationsEuUnionTurnoverGet(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/declarations/eu/union-turnover/get"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/union-turnover/get");
+    }
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuSmeCrossBorderReportComputeRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuSmeCrossBorderReportCompute({
+     *         year: 1000000,
+     *         quarter: 1000000
+     *     })
+     */
+    postV1DeclarationsEuSmeCrossBorderReportCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuSmeCrossBorderReportCompute(request, requestOptions));
+    }
+    async __postV1DeclarationsEuSmeCrossBorderReportCompute(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/declarations/eu/sme-cross-border-report/compute"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/sme-cross-border-report/compute");
+    }
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuSmeThresholdsListRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuSmeThresholdsList()
+     */
+    postV1DeclarationsEuSmeThresholdsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuSmeThresholdsList(request, requestOptions));
+    }
+    async __postV1DeclarationsEuSmeThresholdsList(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/declarations/eu/sme-thresholds/list"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/sme-thresholds/list");
+    }
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuSmeThresholdGetRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuSmeThresholdGet()
+     */
+    postV1DeclarationsEuSmeThresholdGet(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuSmeThresholdGet(request, requestOptions));
+    }
+    async __postV1DeclarationsEuSmeThresholdGet(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/declarations/eu/sme-threshold/get"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/sme-threshold/get");
+    }
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuVatReturnPacksListRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuVatReturnPacksList()
+     */
+    postV1DeclarationsEuVatReturnPacksList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuVatReturnPacksList(request, requestOptions));
+    }
+    async __postV1DeclarationsEuVatReturnPacksList(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/declarations/eu/vat-return/packs/list"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/vat-return/packs/list");
+    }
+    /**
+     * @param {NordletApi.PostV1DeclarationsEuVatReturnComputeRequest} request
+     * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link NordletApi.BadRequestError}
+     * @throws {@link NordletApi.UnauthorizedError}
+     * @throws {@link NordletApi.ForbiddenError}
+     * @throws {@link NordletApi.NotFoundError}
+     * @throws {@link NordletApi.ConflictError}
+     * @throws {@link NordletApi.UnprocessableEntityError}
+     * @throws {@link NordletApi.TooManyRequestsError}
+     * @throws {@link NordletApi.InternalServerError}
+     *
+     * @example
+     *     await client.declarations.postV1DeclarationsEuVatReturnCompute({
+     *         countryCode: "countryCode",
+     *         year: 1000000,
+     *         month: 1000000
+     *     })
+     */
+    postV1DeclarationsEuVatReturnCompute(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1DeclarationsEuVatReturnCompute(request, requestOptions));
+    }
+    async __postV1DeclarationsEuVatReturnCompute(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/declarations/eu/vat-return/compute"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/declarations/eu/vat-return/compute");
+    }
     /**
      * @param {NordletApi.PostV1DeclarationsConfigsListRequest} request
      * @param {DeclarationsClient.RequestOptions} requestOptions - Request-specific configuration.

package/dist/api/resources/declarations/client/requests/PostV1DeclarationsEuDistanceSalesThresholdGetRequest.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @example
+ *     {}
+ */
+export interface PostV1DeclarationsEuDistanceSalesThresholdGetRequest {
+    date?: string;
+}

package/dist/api/resources/declarations/client/requests/PostV1DeclarationsEuDistanceSalesThresholdGetRequest.js

@@ -0,0 +1,3 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+Object.defineProperty(exports, "__esModule", { value: true });