@planqk/planqk-service-sdk 2.1.1 → 2.2.0

package/src/sdk/api/resources/serviceApi/client/Client.ts

@@ -2,69 +2,84 @@
  * This file was auto-generated by Fern from our API Definition.
  */
 
-import * as environments from "../../../../environments";
-import * as core from "../../../../core";
-import * as PlanqkServiceApi from "../../../index";
-import * as errors from "../../../../errors/index";
-import urlJoin from "url-join";
-import * as stream from "stream";
+import * as environments from "../../../../environments.js";
+import * as core from "../../../../core/index.js";
+import * as PlanqkServiceApi from "../../../index.js";
+import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js";
+import * as errors from "../../../../errors/index.js";
 
 export declare namespace ServiceApi {
-    interface Options {
+    export interface Options {
         environment?: core.Supplier<environments.PlanqkServiceApiEnvironment | string>;
+        /** Specify a custom URL to connect the client to. */
+        baseUrl?: core.Supplier<string>;
         token: core.Supplier<core.BearerToken>;
+        /** Additional headers to include in requests. */
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
     }
 
-    interface RequestOptions {
+    export interface RequestOptions {
         /** The maximum time to wait for a response in seconds. */
         timeoutInSeconds?: number;
         /** The number of times to retry the request. Defaults to 2. */
         maxRetries?: number;
         /** A hook to abort the request. */
         abortSignal?: AbortSignal;
+        /** Additional headers to include in the request. */
+        headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
     }
 }
 
 export class ServiceApi {
-    constructor(protected readonly _options: ServiceApi.Options) {}
+    protected readonly _options: ServiceApi.Options;
+
+    constructor(_options: ServiceApi.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()
      */
-    public async healthCheck(
-        requestOptions?: ServiceApi.RequestOptions
-    ): Promise<PlanqkServiceApi.HealthCheckResponse> {
+    public getServiceExecutions(
+        requestOptions?: ServiceApi.RequestOptions,
+    ): core.HttpResponsePromise<PlanqkServiceApi.ServiceExecution[]> {
+        return core.HttpResponsePromise.fromPromise(this.__getServiceExecutions(requestOptions));
+    }
+
+    private async __getServiceExecutions(
+        requestOptions?: ServiceApi.RequestOptions,
+    ): Promise<core.WithRawResponse<PlanqkServiceApi.ServiceExecution[]>> {
         const _response = await core.fetcher({
             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: mergeHeaders(
+                this._options?.headers,
+                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 as PlanqkServiceApi.HealthCheckResponse;
+            return { data: _response.body as PlanqkServiceApi.ServiceExecution[], rawResponse: _response.rawResponse };
         }
 
         if (_response.error.reason === "status-code") {
             throw new errors.PlanqkServiceApiError({
                 statusCode: _response.error.statusCode,
                 body: _response.error.body,
+                rawResponse: _response.rawResponse,
             });
         }
 
@@ -73,51 +88,52 @@ export 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"
      *     })
      */
-    public async execute(
-        request: Record<string, Record<string, any>>,
-        requestOptions?: ServiceApi.RequestOptions
-    ): Promise<PlanqkServiceApi.ServiceExecution> {
+    public startExecution(
+        request: Record<string, any>,
+        requestOptions?: ServiceApi.RequestOptions,
+    ): core.HttpResponsePromise<PlanqkServiceApi.ServiceExecution> {
+        return core.HttpResponsePromise.fromPromise(this.__startExecution(request, requestOptions));
+    }
+
+    private async __startExecution(
+        request: Record<string, any>,
+        requestOptions?: ServiceApi.RequestOptions,
+    ): Promise<core.WithRawResponse<PlanqkServiceApi.ServiceExecution>> {
         const _response = await core.fetcher({
             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: mergeHeaders(
+                this._options?.headers,
+                mergeOnlyDefinedHeaders({ Authorization: await this._getAuthorizationHeader() }),
+                requestOptions?.headers,
+            ),
             contentType: "application/json",
             requestType: "json",
             body: request,
@@ -127,27 +143,15 @@ export class ServiceApi {
             abortSignal: requestOptions?.abortSignal,
         });
         if (_response.ok) {
-            return _response.body as PlanqkServiceApi.ServiceExecution;
+            return { data: _response.body as PlanqkServiceApi.ServiceExecution, rawResponse: _response.rawResponse };
         }
 
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 400:
-                    throw new PlanqkServiceApi.BadRequestError(_response.error.body as any);
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body as any);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body as any);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body as any);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body as any);
-                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) {
@@ -155,74 +159,67 @@ export 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 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")
      */
-    public async getStatus(
+    public getStatus(
+        id: string,
+        requestOptions?: ServiceApi.RequestOptions,
+    ): core.HttpResponsePromise<PlanqkServiceApi.ServiceExecution> {
+        return core.HttpResponsePromise.fromPromise(this.__getStatus(id, requestOptions));
+    }
+
+    private async __getStatus(
         id: string,
-        requestOptions?: ServiceApi.RequestOptions
-    ): Promise<PlanqkServiceApi.ServiceExecution> {
+        requestOptions?: ServiceApi.RequestOptions,
+    ): Promise<core.WithRawResponse<PlanqkServiceApi.ServiceExecution>> {
         const _response = await core.fetcher({
-            url: urlJoin(
-                (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)}`
+                `${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: mergeHeaders(
+                this._options?.headers,
+                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 as PlanqkServiceApi.ServiceExecution;
+            return { data: _response.body as PlanqkServiceApi.ServiceExecution, rawResponse: _response.rawResponse };
         }
 
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body as any);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body as any);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body as any);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body as any);
-                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) {
@@ -230,74 +227,68 @@ export 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 /{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")
      */
-    public async getResult(
+    public getResult(
         id: string,
-        requestOptions?: ServiceApi.RequestOptions
-    ): Promise<PlanqkServiceApi.GetResultResponse> {
+        requestOptions?: ServiceApi.RequestOptions,
+    ): core.HttpResponsePromise<PlanqkServiceApi.GetResultResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__getResult(id, requestOptions));
+    }
+
+    private async __getResult(
+        id: string,
+        requestOptions?: ServiceApi.RequestOptions,
+    ): Promise<core.WithRawResponse<PlanqkServiceApi.GetResultResponse>> {
         const _response = await core.fetcher({
-            url: urlJoin(
-                (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(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: mergeHeaders(
+                this._options?.headers,
+                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 as PlanqkServiceApi.GetResultResponse;
+            return { data: _response.body as PlanqkServiceApi.GetResultResponse, rawResponse: _response.rawResponse };
         }
 
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body as any);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body as any);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body as any);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body as any);
-                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) {
@@ -305,69 +296,65 @@ export 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 /{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.
      */
-    public async getResultFile(
+    public getResultFile(
         id: string,
         file: string,
-        requestOptions?: ServiceApi.RequestOptions
-    ): Promise<stream.Readable> {
-        const _response = await core.fetcher<stream.Readable>({
-            url: urlJoin(
-                (await core.Supplier.get(this._options.environment)) ??
+        requestOptions?: ServiceApi.RequestOptions,
+    ): core.HttpResponsePromise<core.BinaryResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__getResultFile(id, file, requestOptions));
+    }
+
+    private async __getResultFile(
+        id: string,
+        file: string,
+        requestOptions?: ServiceApi.RequestOptions,
+    ): Promise<core.WithRawResponse<core.BinaryResponse>> {
+        const _response = await core.fetcher<core.BinaryResponse>({
+            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)}`
+                `${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: mergeHeaders(
+                this._options?.headers,
+                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 as any);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body as any);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body as any);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body as any);
-                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) {
@@ -375,71 +362,63 @@ export 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 /{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")
      */
-    public async getLogs(id: string, requestOptions?: ServiceApi.RequestOptions): Promise<string[]> {
+    public getLogs(id: string, requestOptions?: ServiceApi.RequestOptions): core.HttpResponsePromise<string[]> {
+        return core.HttpResponsePromise.fromPromise(this.__getLogs(id, requestOptions));
+    }
+
+    private async __getLogs(
+        id: string,
+        requestOptions?: ServiceApi.RequestOptions,
+    ): Promise<core.WithRawResponse<string[]>> {
         const _response = await core.fetcher({
-            url: urlJoin(
-                (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`
+                `${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: mergeHeaders(
+                this._options?.headers,
+                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 as string[];
+            return { data: _response.body as string[], rawResponse: _response.rawResponse };
         }
 
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body as any);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body as any);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body as any);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body as any);
-                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) {
@@ -447,74 +426,66 @@ export 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 /{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")
      */
-    public async cancel(
+    public cancelExecution(
+        id: string,
+        requestOptions?: ServiceApi.RequestOptions,
+    ): core.HttpResponsePromise<PlanqkServiceApi.ServiceExecution> {
+        return core.HttpResponsePromise.fromPromise(this.__cancelExecution(id, requestOptions));
+    }
+
+    private async __cancelExecution(
         id: string,
-        requestOptions?: ServiceApi.RequestOptions
-    ): Promise<PlanqkServiceApi.ServiceExecution> {
+        requestOptions?: ServiceApi.RequestOptions,
+    ): Promise<core.WithRawResponse<PlanqkServiceApi.ServiceExecution>> {
         const _response = await core.fetcher({
-            url: urlJoin(
-                (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`
+                `${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: mergeHeaders(
+                this._options?.headers,
+                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 as PlanqkServiceApi.ServiceExecution;
+            return { data: _response.body as PlanqkServiceApi.ServiceExecution, rawResponse: _response.rawResponse };
         }
 
         if (_response.error.reason === "status-code") {
-            switch (_response.error.statusCode) {
-                case 401:
-                    throw new PlanqkServiceApi.UnauthorizedError(_response.error.body as any);
-                case 403:
-                    throw new PlanqkServiceApi.ForbiddenError(_response.error.body as any);
-                case 404:
-                    throw new PlanqkServiceApi.NotFoundError(_response.error.body as any);
-                case 500:
-                    throw new PlanqkServiceApi.InternalServerError(_response.error.body as any);
-                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) {
@@ -522,12 +493,14 @@ export 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 PUT /{id}/cancel.");
             case "unknown":
                 throw new errors.PlanqkServiceApiError({
                     message: _response.error.errorMessage,
+                    rawResponse: _response.rawResponse,
                 });
         }
     }