@planqk/planqk-service-sdk 2.1.2 → 2.2.0

package/dist/sdk/api/resources/serviceApi/client/Client.js

@@ -35,54 +35,49 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceApi = void 0;
-const environments = __importStar(require("../../../../environments"));
-const core = __importStar(require("../../../../core"));
-const PlanqkServiceApi = __importStar(require("../../../index"));
-const errors = __importStar(require("../../../../errors/index"));
-const url_join_1 = __importDefault(require("url-join"));
+const environments = __importStar(require("../../../../environments.js"));
+const core = __importStar(require("../../../../core/index.js"));
+const headers_js_1 = require("../../../../core/headers.js");
+const errors = __importStar(require("../../../../errors/index.js"));
 class ServiceApi {
     _options;
     constructor(_options) {
         this._options = _options;
     }
     /**
-     * This method checks the health of the service.
+     * Retrieves a list of all service executions.
+     * The response includes links to each service execution, allowing for further queries on their status and results.
      *
      * @param {ServiceApi.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @example
-     *     await client.serviceApi.healthCheck()
+     *     await client.serviceApi.getServiceExecutions()
      */
-    async healthCheck(requestOptions) {
+    getServiceExecutions(requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getServiceExecutions(requestOptions));
+    }
+    async __getServiceExecutions(requestOptions) {
         const _response = await core.fetcher({
-            url: (await core.Supplier.get(this._options.environment)) ??
+            url: (await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
                 environments.PlanqkServiceApiEnvironment.Default,
             method: "GET",
-            headers: {
-                Authorization: await this._getAuthorizationHeader(),
-                "X-Fern-Language": "JavaScript",
-                "X-Fern-Runtime": core.RUNTIME.type,
-                "X-Fern-Runtime-Version": core.RUNTIME.version,
-            },
-            contentType: "application/json",
-            requestType: "json",
+            headers: (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: await this._getAuthorizationHeader() }), requestOptions?.headers),
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
             withCredentials: true,
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body;
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
             throw new errors.PlanqkServiceApiError({
                 statusCode: _response.error.statusCode,
                 body: _response.error.body,
+                rawResponse: _response.rawResponse,
             });
         }
         switch (_response.error.reason) {
@@ -90,46 +85,39 @@ class ServiceApi {
                 throw new errors.PlanqkServiceApiError({
                     statusCode: _response.error.statusCode,
                     body: _response.error.rawBody,
+                    rawResponse: _response.rawResponse,
                 });
             case "timeout":
-                throw new errors.PlanqkServiceApiTimeoutError();
+                throw new errors.PlanqkServiceApiTimeoutError("Timeout exceeded when calling GET /.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }
     /**
-     * This method starts a service execution, which in turn is processed asynchronously by PLANQK.
+     * Starts a service execution, which in turn is processed asynchronously.
      * The location header of the response contains the URL which can be used to query the status and the result of the service execution.
      *
-     * @param {Record<string, Record<string, any>>} request
+     * @param {Record<string, any>} request
      * @param {ServiceApi.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @throws {@link PlanqkServiceApi.BadRequestError}
-     * @throws {@link PlanqkServiceApi.UnauthorizedError}
-     * @throws {@link PlanqkServiceApi.ForbiddenError}
-     * @throws {@link PlanqkServiceApi.NotFoundError}
-     * @throws {@link PlanqkServiceApi.InternalServerError}
-     *
      * @example
-     *     await client.serviceApi.execute({
-     *         "key": {
-     *             "key": "value"
-     *         }
+     *     await client.serviceApi.startExecution({
+     *         "key": "value"
      *     })
      */
-    async execute(request, requestOptions) {
+    startExecution(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__startExecution(request, requestOptions));
+    }
+    async __startExecution(request, requestOptions) {
         const _response = await core.fetcher({
-            url: (await core.Supplier.get(this._options.environment)) ??
+            url: (await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
                 environments.PlanqkServiceApiEnvironment.Default,
             method: "POST",
-            headers: {
-                Authorization: await this._getAuthorizationHeader(),
-                "X-Fern-Language": "JavaScript",
-                "X-Fern-Runtime": core.RUNTIME.type,
-                "X-Fern-Runtime-Version": core.RUNTIME.version,
-            },
+            headers: (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: await this._getAuthorizationHeader() }), requestOptions?.headers),
             contentType: "application/json",
             requestType: "json",
             body: request,
@@ -139,362 +127,278 @@ class ServiceApi {
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body;
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new PlanqkServiceApi.BadRequestError(_response.error.body);
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body);
-                default:
-                    throw new errors.PlanqkServiceApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                    });
-            }
+            throw new errors.PlanqkServiceApiError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse,
+            });
         }
         switch (_response.error.reason) {
             case "non-json":
                 throw new errors.PlanqkServiceApiError({
                     statusCode: _response.error.statusCode,
                     body: _response.error.rawBody,
+                    rawResponse: _response.rawResponse,
                 });
             case "timeout":
-                throw new errors.PlanqkServiceApiTimeoutError();
+                throw new errors.PlanqkServiceApiTimeoutError("Timeout exceeded when calling POST /.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }
     /**
-     * This method checks the status of a service execution.
+     * Retrieves the status of a service execution.
+     * The status can be one of the following: UNKNOWN, PENDING, RUNNING, SUCCEEDED, CANCELLED, FAILED.
      *
      * @param {string} id - The id of a service execution
      * @param {ServiceApi.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @throws {@link PlanqkServiceApi.UnauthorizedError}
-     * @throws {@link PlanqkServiceApi.ForbiddenError}
-     * @throws {@link PlanqkServiceApi.NotFoundError}
-     * @throws {@link PlanqkServiceApi.InternalServerError}
-     *
      * @example
      *     await client.serviceApi.getStatus("id")
      */
-    async getStatus(id, requestOptions) {
+    getStatus(id, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getStatus(id, requestOptions));
+    }
+    async __getStatus(id, requestOptions) {
         const _response = await core.fetcher({
-            url: (0, url_join_1.default)((await core.Supplier.get(this._options.environment)) ??
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
                 environments.PlanqkServiceApiEnvironment.Default, `${encodeURIComponent(id)}`),
             method: "GET",
-            headers: {
-                Authorization: await this._getAuthorizationHeader(),
-                "X-Fern-Language": "JavaScript",
-                "X-Fern-Runtime": core.RUNTIME.type,
-                "X-Fern-Runtime-Version": core.RUNTIME.version,
-            },
-            contentType: "application/json",
-            requestType: "json",
+            headers: (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: await this._getAuthorizationHeader() }), requestOptions?.headers),
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
             withCredentials: true,
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body;
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body);
-                default:
-                    throw new errors.PlanqkServiceApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                    });
-            }
+            throw new errors.PlanqkServiceApiError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse,
+            });
         }
         switch (_response.error.reason) {
             case "non-json":
                 throw new errors.PlanqkServiceApiError({
                     statusCode: _response.error.statusCode,
                     body: _response.error.rawBody,
+                    rawResponse: _response.rawResponse,
                 });
             case "timeout":
-                throw new errors.PlanqkServiceApiTimeoutError();
+                throw new errors.PlanqkServiceApiTimeoutError("Timeout exceeded when calling GET /{id}.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }
     /**
-     * This method retrieves the result of a service execution.
+     * Retrieves the result of a service execution.
+     * The result is returned as a JSON object containing the status and any additional data.
+     * The result may include links to download specific result files.
      *
      * @param {string} id - The id of a service execution
      * @param {ServiceApi.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @throws {@link PlanqkServiceApi.UnauthorizedError}
-     * @throws {@link PlanqkServiceApi.ForbiddenError}
-     * @throws {@link PlanqkServiceApi.NotFoundError}
-     * @throws {@link PlanqkServiceApi.InternalServerError}
-     *
      * @example
      *     await client.serviceApi.getResult("id")
      */
-    async getResult(id, requestOptions) {
+    getResult(id, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getResult(id, requestOptions));
+    }
+    async __getResult(id, requestOptions) {
         const _response = await core.fetcher({
-            url: (0, url_join_1.default)((await core.Supplier.get(this._options.environment)) ??
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
                 environments.PlanqkServiceApiEnvironment.Default, `${encodeURIComponent(id)}/result`),
             method: "GET",
-            headers: {
-                Authorization: await this._getAuthorizationHeader(),
-                "X-Fern-Language": "JavaScript",
-                "X-Fern-Runtime": core.RUNTIME.type,
-                "X-Fern-Runtime-Version": core.RUNTIME.version,
-            },
-            contentType: "application/json",
-            requestType: "json",
+            headers: (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: await this._getAuthorizationHeader() }), requestOptions?.headers),
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
             withCredentials: true,
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body;
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body);
-                default:
-                    throw new errors.PlanqkServiceApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                    });
-            }
+            throw new errors.PlanqkServiceApiError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse,
+            });
         }
         switch (_response.error.reason) {
             case "non-json":
                 throw new errors.PlanqkServiceApiError({
                     statusCode: _response.error.statusCode,
                     body: _response.error.rawBody,
+                    rawResponse: _response.rawResponse,
                 });
             case "timeout":
-                throw new errors.PlanqkServiceApiTimeoutError();
+                throw new errors.PlanqkServiceApiTimeoutError("Timeout exceeded when calling GET /{id}/result.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }
     /**
-     * This method downloads a result file of a service execution.
-     * @throws {@link PlanqkServiceApi.UnauthorizedError}
-     * @throws {@link PlanqkServiceApi.ForbiddenError}
-     * @throws {@link PlanqkServiceApi.NotFoundError}
-     * @throws {@link PlanqkServiceApi.InternalServerError}
+     * Retrieves a specific result file of a service execution.
+     * The file name is provided in the path parameter.
+     * The result file is returned as a binary stream.
      */
-    async getResultFile(id, file, requestOptions) {
+    getResultFile(id, file, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getResultFile(id, file, requestOptions));
+    }
+    async __getResultFile(id, file, requestOptions) {
         const _response = await core.fetcher({
-            url: (0, url_join_1.default)((await core.Supplier.get(this._options.environment)) ??
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
                 environments.PlanqkServiceApiEnvironment.Default, `${encodeURIComponent(id)}/result/${encodeURIComponent(file)}`),
             method: "GET",
-            headers: {
-                Authorization: await this._getAuthorizationHeader(),
-                "X-Fern-Language": "JavaScript",
-                "X-Fern-Runtime": core.RUNTIME.type,
-                "X-Fern-Runtime-Version": core.RUNTIME.version,
-            },
-            contentType: "application/json",
-            requestType: "json",
-            responseType: "streaming",
+            headers: (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: await this._getAuthorizationHeader() }), requestOptions?.headers),
+            responseType: "binary-response",
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
             withCredentials: true,
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body;
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body);
-                default:
-                    throw new errors.PlanqkServiceApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                    });
-            }
+            throw new errors.PlanqkServiceApiError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse,
+            });
         }
         switch (_response.error.reason) {
             case "non-json":
                 throw new errors.PlanqkServiceApiError({
                     statusCode: _response.error.statusCode,
                     body: _response.error.rawBody,
+                    rawResponse: _response.rawResponse,
                 });
             case "timeout":
-                throw new errors.PlanqkServiceApiTimeoutError();
+                throw new errors.PlanqkServiceApiTimeoutError("Timeout exceeded when calling GET /{id}/result/{file}.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }
     /**
-     * This method retrieves the log output of a service execution.
+     * Returns a list of log entries for a service execution in chronological order, where the first entry is the oldest.
      *
      * @param {string} id - The id of a service execution
      * @param {ServiceApi.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @throws {@link PlanqkServiceApi.UnauthorizedError}
-     * @throws {@link PlanqkServiceApi.ForbiddenError}
-     * @throws {@link PlanqkServiceApi.NotFoundError}
-     * @throws {@link PlanqkServiceApi.InternalServerError}
-     *
      * @example
      *     await client.serviceApi.getLogs("id")
      */
-    async getLogs(id, requestOptions) {
+    getLogs(id, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getLogs(id, requestOptions));
+    }
+    async __getLogs(id, requestOptions) {
         const _response = await core.fetcher({
-            url: (0, url_join_1.default)((await core.Supplier.get(this._options.environment)) ??
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
                 environments.PlanqkServiceApiEnvironment.Default, `${encodeURIComponent(id)}/log`),
             method: "GET",
-            headers: {
-                Authorization: await this._getAuthorizationHeader(),
-                "X-Fern-Language": "JavaScript",
-                "X-Fern-Runtime": core.RUNTIME.type,
-                "X-Fern-Runtime-Version": core.RUNTIME.version,
-            },
-            contentType: "application/json",
-            requestType: "json",
+            headers: (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: await this._getAuthorizationHeader() }), requestOptions?.headers),
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
             withCredentials: true,
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body;
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body);
-                default:
-                    throw new errors.PlanqkServiceApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                    });
-            }
+            throw new errors.PlanqkServiceApiError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse,
+            });
         }
         switch (_response.error.reason) {
             case "non-json":
                 throw new errors.PlanqkServiceApiError({
                     statusCode: _response.error.statusCode,
                     body: _response.error.rawBody,
+                    rawResponse: _response.rawResponse,
                 });
             case "timeout":
-                throw new errors.PlanqkServiceApiTimeoutError();
+                throw new errors.PlanqkServiceApiTimeoutError("Timeout exceeded when calling GET /{id}/log.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }
     /**
-     * This method cancels a service execution.
+     * Cancel a pending or running service execution.
      *
      * @param {string} id - The id of a service execution
      * @param {ServiceApi.RequestOptions} requestOptions - Request-specific configuration.
      *
-     * @throws {@link PlanqkServiceApi.UnauthorizedError}
-     * @throws {@link PlanqkServiceApi.ForbiddenError}
-     * @throws {@link PlanqkServiceApi.NotFoundError}
-     * @throws {@link PlanqkServiceApi.InternalServerError}
-     *
      * @example
-     *     await client.serviceApi.cancel("id")
+     *     await client.serviceApi.cancelExecution("id")
      */
-    async cancel(id, requestOptions) {
+    cancelExecution(id, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__cancelExecution(id, requestOptions));
+    }
+    async __cancelExecution(id, requestOptions) {
         const _response = await core.fetcher({
-            url: (0, url_join_1.default)((await core.Supplier.get(this._options.environment)) ??
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
                 environments.PlanqkServiceApiEnvironment.Default, `${encodeURIComponent(id)}/cancel`),
             method: "PUT",
-            headers: {
-                Authorization: await this._getAuthorizationHeader(),
-                "X-Fern-Language": "JavaScript",
-                "X-Fern-Runtime": core.RUNTIME.type,
-                "X-Fern-Runtime-Version": core.RUNTIME.version,
-            },
-            contentType: "application/json",
-            requestType: "json",
+            headers: (0, headers_js_1.mergeHeaders)(this._options?.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ Authorization: await this._getAuthorizationHeader() }), requestOptions?.headers),
             timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
             maxRetries: requestOptions?.maxRetries,
             withCredentials: true,
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body;
+            return { data: _response.body, rawResponse: _response.rawResponse };
         }
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body);
-                default:
-                    throw new errors.PlanqkServiceApiError({
-                        statusCode: _response.error.statusCode,
-                        body: _response.error.body,
-                    });
-            }
+            throw new errors.PlanqkServiceApiError({
+                statusCode: _response.error.statusCode,
+                body: _response.error.body,
+                rawResponse: _response.rawResponse,
+            });
         }
         switch (_response.error.reason) {
             case "non-json":
                 throw new errors.PlanqkServiceApiError({
                     statusCode: _response.error.statusCode,
                     body: _response.error.rawBody,
+                    rawResponse: _response.rawResponse,
                 });
             case "timeout":
-                throw new errors.PlanqkServiceApiTimeoutError();
+                throw new errors.PlanqkServiceApiTimeoutError("Timeout exceeded when calling PUT /{id}/cancel.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }

package/dist/sdk/api/resources/serviceApi/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./types";
-export * from "./client";
+export * from "./types/index.js";
+export * from "./client/index.js";

package/dist/sdk/api/resources/serviceApi/index.js

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./client"), exports);
+__exportStar(require("./types/index.js"), exports);
+__exportStar(require("./client/index.js"), exports);

package/dist/sdk/api/resources/serviceApi/types/GetResultResponse.d.ts

@@ -1,8 +1,18 @@
 /**
  * This file was auto-generated by Fern from our API Definition.
  */
-import * as PlanqkServiceApi from "../../../index";
+import * as PlanqkServiceApi from "../../../index.js";
 export interface GetResultResponse {
-    _links?: PlanqkServiceApi.GetResultResponseLinks;
-    _embedded?: PlanqkServiceApi.GetResultResponseEmbedded;
+    _links?: GetResultResponse.Links;
+    _embedded?: GetResultResponse.Embedded;
+    /** Accepts any additional properties */
+    [key: string]: any;
+}
+export declare namespace GetResultResponse {
+    interface Links {
+        status?: PlanqkServiceApi.HalLink;
+    }
+    interface Embedded {
+        status?: PlanqkServiceApi.ServiceExecution;
+    }
 }

package/dist/sdk/api/resources/serviceApi/types/index.d.ts

@@ -1,4 +1 @@
-export * from "./HealthCheckResponse";
-export * from "./GetResultResponseLinks";
-export * from "./GetResultResponseEmbedded";
-export * from "./GetResultResponse";
+export * from "./GetResultResponse.js";

package/dist/sdk/api/resources/serviceApi/types/index.js

@@ -14,7 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./HealthCheckResponse"), exports);
-__exportStar(require("./GetResultResponseLinks"), exports);
-__exportStar(require("./GetResultResponseEmbedded"), exports);
-__exportStar(require("./GetResultResponse"), exports);
+__exportStar(require("./GetResultResponse.js"), exports);