nordlet 0.2.0 → 0.2.2

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

@@ -492,5 +492,1044 @@ class PurchasesClient {
         }
         return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/invoices/list");
     }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersCreateRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersCreate({
+     *         partnerId: "partnerId",
+     *         orderDate: "orderDate",
+     *         lines: [{}]
+     *     })
+     */
+    postV1PurchasesOrdersCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersCreate(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersCreate(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/purchases/orders/create"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/create");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersUpdateRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersUpdate({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersUpdate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersUpdate(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersUpdate(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/purchases/orders/update"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/update");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersGetRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersGet({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersGet(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersGet(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/purchases/orders/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/purchases/orders/get");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersListRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersList()
+     */
+    postV1PurchasesOrdersList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersList(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersList(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/purchases/orders/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/purchases/orders/list");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersSubmitRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersSubmit({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersSubmit(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersSubmit(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersSubmit(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/purchases/orders/submit"),
+            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/purchases/orders/submit");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersApproveRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersApprove({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersApprove(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersApprove(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersApprove(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/purchases/orders/approve"),
+            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/purchases/orders/approve");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersRejectRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersReject({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersReject(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersReject(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersReject(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/purchases/orders/reject"),
+            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/purchases/orders/reject");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersCancelRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersCancel({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersCancel(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersCancel(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersCancel(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/purchases/orders/cancel"),
+            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/purchases/orders/cancel");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersCloseRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersClose({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersClose(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersClose(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersClose(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/purchases/orders/close"),
+            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/purchases/orders/close");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesOrdersDeleteRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesOrdersDelete({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesOrdersDelete(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesOrdersDelete(request, requestOptions));
+    }
+    async __postV1PurchasesOrdersDelete(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/purchases/orders/delete"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/orders/delete");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesReceiptsCreateRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesReceiptsCreate({
+     *         orderId: "orderId",
+     *         receiptDate: "receiptDate",
+     *         lines: [{
+     *                 orderLineId: "orderLineId",
+     *                 quantity: "quantity"
+     *             }]
+     *     })
+     */
+    postV1PurchasesReceiptsCreate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesReceiptsCreate(request, requestOptions));
+    }
+    async __postV1PurchasesReceiptsCreate(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/purchases/receipts/create"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: (0, requestBody_js_1.mergeAdditionalBodyParameters)(request, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: _response.body,
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new NordletApi.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new NordletApi.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new NordletApi.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new NordletApi.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new NordletApi.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new NordletApi.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new NordletApi.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new NordletApi.InternalServerError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.NordletApiError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return (0, handleNonStatusCodeError_js_1.handleNonStatusCodeError)(_response.error, _response.rawResponse, "POST", "/v1/purchases/receipts/create");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesReceiptsGetRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesReceiptsGet({
+     *         id: "id"
+     *     })
+     */
+    postV1PurchasesReceiptsGet(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesReceiptsGet(request, requestOptions));
+    }
+    async __postV1PurchasesReceiptsGet(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/purchases/receipts/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/purchases/receipts/get");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesReceiptsListRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesReceiptsList()
+     */
+    postV1PurchasesReceiptsList(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesReceiptsList(request, requestOptions));
+    }
+    async __postV1PurchasesReceiptsList(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/purchases/receipts/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/purchases/receipts/list");
+    }
+    /**
+     * @param {NordletApi.PostV1PurchasesInvoicesMatchRequest} request
+     * @param {PurchasesClient.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.purchases.postV1PurchasesInvoicesMatch({
+     *         invoiceId: "invoiceId"
+     *     })
+     */
+    postV1PurchasesInvoicesMatch(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__postV1PurchasesInvoicesMatch(request, requestOptions));
+    }
+    async __postV1PurchasesInvoicesMatch(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/purchases/invoices/match"),
+            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/purchases/invoices/match");
+    }
 }
 exports.PurchasesClient = PurchasesClient;