Skip to content

Automate browser based workflows with AI

269 KB
Raw Blame
// This file was auto-generated by Fern from our API Definition.

import * as Skyvern from "./api/index.js";
import { Agents } from "./api/resources/agents/client/Client.js";
import { Artifacts } from "./api/resources/artifacts/client/Client.js";
import { Schedules } from "./api/resources/schedules/client/Client.js";
import { Scripts } from "./api/resources/scripts/client/Client.js";
import type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.js";
import { mergeHeaders, mergeOnlyDefinedHeaders } from "./core/headers.js";
import * as core from "./core/index.js";
import * as environments from "./environments.js";
import * as errors from "./errors/index.js";

export declare namespace SkyvernClient {
    export interface Options extends BaseClientOptions {}

    export interface RequestOptions extends BaseRequestOptions {}
}

export class SkyvernClient {
    protected readonly _options: SkyvernClient.Options;
    protected _artifacts: Artifacts | undefined;
    protected _scripts: Scripts | undefined;
    protected _schedules: Schedules | undefined;
    protected _agents: Agents | undefined;

    constructor(_options: SkyvernClient.Options = {}) {
        this._options = {
            ..._options,
            headers: mergeHeaders(
                {
                    "x-api-key": _options?.apiKey,
                    "X-Fern-Language": "JavaScript",
                    "X-Fern-SDK-Name": "@skyvern/client",
                    "X-Fern-SDK-Version": "1.0.55",
                    "User-Agent": "@skyvern/client/1.0.55",
                    "X-Fern-Runtime": core.RUNTIME.type,
                    "X-Fern-Runtime-Version": core.RUNTIME.version,
                },
                _options?.headers,
            ),
        };
    }

    public get artifacts(): Artifacts {
        return (this._artifacts ??= new Artifacts(this._options));
    }

    public get scripts(): Scripts {
        return (this._scripts ??= new Scripts(this._options));
    }

    public get schedules(): Schedules {
        return (this._schedules ??= new Schedules(this._options));
    }

    public get agents(): Agents {
        return (this._agents ??= new Agents(this._options));
    }

    /**
     * Run a task
     *
     * @param {Skyvern.TaskRunRequestInput} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.runTask({
     *         "x-user-agent": "x-user-agent",
     *         prompt: "Find the top 3 posts on Hacker News."
     *     })
     */
    public runTask(
        request: Skyvern.TaskRunRequestInput,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TaskRunResponse> {
        return core.HttpResponsePromise.fromPromise(this.__runTask(request, requestOptions));
    }

    private async __runTask(
        request: Skyvern.TaskRunRequestInput,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TaskRunResponse>> {
        const { "x-user-agent": userAgent, ..._body } = request;
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({
                "x-user-agent": userAgent != null ? userAgent : undefined,
                "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey,
            }),
            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.SkyvernEnvironment.Cloud,
                "v1/run/tasks",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: _body,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TaskRunResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/run/tasks.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Run an agent
     *
     * @param {Skyvern.WorkflowRunRequestInput} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.runWorkflow({
     *         "x-max-steps-override": 1,
     *         "x-user-agent": "x-user-agent",
     *         template: true,
     *         agent_id: "wpid_123"
     *     })
     */
    public runWorkflow(
        request: Skyvern.WorkflowRunRequestInput,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowRunResponse> {
        return core.HttpResponsePromise.fromPromise(this.__runWorkflow(request, requestOptions));
    }

    private async __runWorkflow(
        request: Skyvern.WorkflowRunRequestInput,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowRunResponse>> {
        const { template, "x-max-steps-override": maxStepsOverride, "x-user-agent": userAgent, ..._body } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (template != null) {
            _queryParams.template = template.toString();
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({
                "x-max-steps-override": maxStepsOverride != null ? maxStepsOverride.toString() : undefined,
                "x-user-agent": userAgent != null ? userAgent : undefined,
                "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey,
            }),
            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.SkyvernEnvironment.Cloud,
                "v1/run/agents",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            requestType: "json",
            body: _body,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowRunResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/run/agents.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get run information (task run, workflow run)
     *
     * @param {string} runId - The id of the task run or the workflow run.
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getRun("tsk_123")
     */
    public getRun(
        runId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.GetRunResponse> {
        return core.HttpResponsePromise.fromPromise(this.__getRun(runId, requestOptions));
    }

    private async __getRun(
        runId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.GetRunResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(runId)}`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.GetRunResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/runs/{run_id}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Cancel a run (task or workflow)
     *
     * @param {string} runId - The id of the task run or the workflow run to cancel.
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.cancelRun("run_id")
     */
    public cancelRun(runId: string, requestOptions?: SkyvernClient.RequestOptions): core.HttpResponsePromise<unknown> {
        return core.HttpResponsePromise.fromPromise(this.__cancelRun(runId, requestOptions));
    }

    private async __cancelRun(
        runId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<unknown>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(runId)}/cancel`,
            ),
            method: "POST",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/runs/{run_id}/cancel.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Cancel multiple runs (tasks or workflows) in a single request
     *
     * @param {Skyvern.BulkCancelRunsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.bulkCancelRuns({
     *         run_ids: ["run_ids"]
     *     })
     */
    public bulkCancelRuns(
        request: Skyvern.BulkCancelRunsRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BulkCancelRunsResponse> {
        return core.HttpResponsePromise.fromPromise(this.__bulkCancelRuns(request, requestOptions));
    }

    private async __bulkCancelRuns(
        request: Skyvern.BulkCancelRunsRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BulkCancelRunsResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/runs/cancel",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BulkCancelRunsResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/runs/cancel.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get all workflows with the latest version for the organization.
     *
     * Search semantics:
     * - If `search_key` is provided, its value is used as a unified search term for
     *   `workflows.title`, `folders.title`, and workflow parameter metadata (key, description, and default_value for
     *   `WorkflowParameterModel`).
     * - Falls back to deprecated `title` (title-only search) if `search_key` is not provided.
     * - Parameter metadata search excludes soft-deleted parameter rows across all parameter tables.
     *
     * @param {Skyvern.GetWorkflowsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getWorkflows({
     *         page: 1,
     *         page_size: 1,
     *         only_saved_tasks: true,
     *         only_workflows: true,
     *         only_templates: true,
     *         search_key: "search_key",
     *         title: "title",
     *         folder_id: "folder_id",
     *         template: true
     *     })
     */
    public getWorkflows(
        request: Skyvern.GetWorkflowsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Workflow[]> {
        return core.HttpResponsePromise.fromPromise(this.__getWorkflows(request, requestOptions));
    }

    private async __getWorkflows(
        request: Skyvern.GetWorkflowsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Workflow[]>> {
        const {
            page,
            page_size: pageSize,
            only_saved_tasks: onlySavedTasks,
            only_workflows: onlyWorkflows,
            only_templates: onlyTemplates,
            search_key: searchKey,
            title,
            folder_id: folderId,
            status,
            tags,
            template,
        } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        if (onlySavedTasks != null) {
            _queryParams.only_saved_tasks = onlySavedTasks.toString();
        }

        if (onlyWorkflows != null) {
            _queryParams.only_workflows = onlyWorkflows.toString();
        }

        if (onlyTemplates != null) {
            _queryParams.only_templates = onlyTemplates.toString();
        }

        if (searchKey != null) {
            _queryParams.search_key = searchKey;
        }

        if (title != null) {
            _queryParams.title = title;
        }

        if (folderId != null) {
            _queryParams.folder_id = folderId;
        }

        if (status != null) {
            if (Array.isArray(status)) {
                _queryParams.status = status.map((item) => item);
            } else {
                _queryParams.status = status;
            }
        }

        if (tags != null) {
            if (Array.isArray(tags)) {
                _queryParams.tags = tags.map((item) => item);
            } else {
                _queryParams.tags = tags;
            }
        }

        if (template != null) {
            _queryParams.template = template.toString();
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/agents",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Workflow[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/agents.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Create a new agent
     *
     * @param {Skyvern.CreateWorkflowRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.createWorkflow({
     *         folder_id: "folder_id",
     *         body: {}
     *     })
     */
    public createWorkflow(
        request: Skyvern.CreateWorkflowRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Workflow> {
        return core.HttpResponsePromise.fromPromise(this.__createWorkflow(request, requestOptions));
    }

    private async __createWorkflow(
        request: Skyvern.CreateWorkflowRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Workflow>> {
        const { folder_id: folderId, body: _body } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (folderId != null) {
            _queryParams.folder_id = folderId;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/agents",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            requestType: "json",
            body: _body,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Workflow, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/agents.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Update an agent
     *
     * @param {string} workflowId - The ID of the agent to update. Starts with `wpid_`.
     * @param {Skyvern.WorkflowRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateWorkflow("wpid_123", {})
     */
    public updateWorkflow(
        workflowId: string,
        request: Skyvern.WorkflowRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Workflow> {
        return core.HttpResponsePromise.fromPromise(this.__updateWorkflow(workflowId, request, requestOptions));
    }

    private async __updateWorkflow(
        workflowId: string,
        request: Skyvern.WorkflowRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Workflow>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowId)}`,
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Workflow, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/agents/{workflow_id}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Delete an agent
     *
     * @param {string} workflowId - The ID of the agent to delete. Starts with `wpid_`.
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteWorkflow("wpid_123")
     */
    public deleteWorkflow(
        workflowId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<unknown> {
        return core.HttpResponsePromise.fromPromise(this.__deleteWorkflow(workflowId, requestOptions));
    }

    private async __deleteWorkflow(
        workflowId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<unknown>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowId)}/delete`,
            ),
            method: "POST",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/agents/{workflow_id}/delete.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get all folders for the organization
     *
     * @param {Skyvern.GetFoldersRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getFolders({
     *         page: 1,
     *         page_size: 1,
     *         search: "search"
     *     })
     */
    public getFolders(
        request: Skyvern.GetFoldersRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Folder[]> {
        return core.HttpResponsePromise.fromPromise(this.__getFolders(request, requestOptions));
    }

    private async __getFolders(
        request: Skyvern.GetFoldersRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Folder[]>> {
        const { page, page_size: pageSize, search } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        if (search != null) {
            _queryParams.search = search;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/folders",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Folder[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/folders.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Create a new folder to organize workflows
     *
     * @param {Skyvern.FolderCreate} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.createFolder({
     *         title: "title"
     *     })
     */
    public createFolder(
        request: Skyvern.FolderCreate,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Folder> {
        return core.HttpResponsePromise.fromPromise(this.__createFolder(request, requestOptions));
    }

    private async __createFolder(
        request: Skyvern.FolderCreate,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Folder>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/folders",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Folder, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/folders.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get a specific folder by ID
     *
     * @param {string} folderId - Folder ID
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getFolder("fld_123")
     */
    public getFolder(
        folderId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Folder> {
        return core.HttpResponsePromise.fromPromise(this.__getFolder(folderId, requestOptions));
    }

    private async __getFolder(
        folderId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Folder>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/folders/${core.url.encodePathParam(folderId)}`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Folder, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/folders/{folder_id}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Update a folder's title or description
     *
     * @param {string} folderId - Folder ID
     * @param {Skyvern.FolderUpdate} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateFolder("fld_123")
     */
    public updateFolder(
        folderId: string,
        request: Skyvern.FolderUpdate = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Folder> {
        return core.HttpResponsePromise.fromPromise(this.__updateFolder(folderId, request, requestOptions));
    }

    private async __updateFolder(
        folderId: string,
        request: Skyvern.FolderUpdate = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Folder>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/folders/${core.url.encodePathParam(folderId)}`,
            ),
            method: "PUT",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Folder, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling PUT /v1/folders/{folder_id}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Delete a folder. Optionally delete all workflows in the folder.
     *
     * @param {string} folderId - Folder ID
     * @param {Skyvern.DeleteFolderRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteFolder("fld_123", {
     *         delete_workflows: true
     *     })
     */
    public deleteFolder(
        folderId: string,
        request: Skyvern.DeleteFolderRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Record<string, unknown>> {
        return core.HttpResponsePromise.fromPromise(this.__deleteFolder(folderId, request, requestOptions));
    }

    private async __deleteFolder(
        folderId: string,
        request: Skyvern.DeleteFolderRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Record<string, unknown>>> {
        const { delete_workflows: deleteWorkflows } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (deleteWorkflows != null) {
            _queryParams.delete_workflows = deleteWorkflows.toString();
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/folders/${core.url.encodePathParam(folderId)}`,
            ),
            method: "DELETE",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Record<string, unknown>, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling DELETE /v1/folders/{folder_id}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get the current tag state for a workflow run.
     *
     * @param {string} workflowRunId - Workflow run ID
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getRunTags("wr_123")
     */
    public getRunTags(
        workflowRunId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunTagsResponse> {
        return core.HttpResponsePromise.fromPromise(this.__getRunTags(workflowRunId, requestOptions));
    }

    private async __getRunTags(
        workflowRunId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunTagsResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(workflowRunId)}/tags`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunTagsResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/runs/{workflow_run_id}/tags.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Atomically apply tag changes to a workflow run. Sets and deletes happen in one transaction; same-key collisions resolve set-wins.
     *
     * @param {string} workflowRunId - Workflow run ID
     * @param {Skyvern.TagApplyRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.applyRunTags("wr_123", {})
     */
    public applyRunTags(
        workflowRunId: string,
        request: Skyvern.TagApplyRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunTagsResponse> {
        return core.HttpResponsePromise.fromPromise(this.__applyRunTags(workflowRunId, request, requestOptions));
    }

    private async __applyRunTags(
        workflowRunId: string,
        request: Skyvern.TagApplyRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunTagsResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(workflowRunId)}/tags`,
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunTagsResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/runs/{workflow_run_id}/tags.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Soft-delete a single grouped tag from a workflow run. Writes a DELETE event row.
     *
     * @param {string} workflowRunId - Workflow run ID
     * @param {string} key - Tag key to delete
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteRunTag("wr_123", "env")
     */
    public deleteRunTag(
        workflowRunId: string,
        key: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunTagsResponse> {
        return core.HttpResponsePromise.fromPromise(this.__deleteRunTag(workflowRunId, key, requestOptions));
    }

    private async __deleteRunTag(
        workflowRunId: string,
        key: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunTagsResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(workflowRunId)}/tags/${core.url.encodePathParam(key)}`,
            ),
            method: "DELETE",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunTagsResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling DELETE /v1/runs/{workflow_run_id}/tags/{key}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Chronological tag-event log for a workflow run (newest first). Includes SET and DELETE events.
     *
     * @param {string} workflowRunId - Workflow run ID
     * @param {Skyvern.GetRunTagHistoryRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getRunTagHistory("wr_123", {
     *         limit: 1,
     *         since: "2024-01-15T09:30:00Z",
     *         key: "key"
     *     })
     */
    public getRunTagHistory(
        workflowRunId: string,
        request: Skyvern.GetRunTagHistoryRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunTagHistoryResponse> {
        return core.HttpResponsePromise.fromPromise(this.__getRunTagHistory(workflowRunId, request, requestOptions));
    }

    private async __getRunTagHistory(
        workflowRunId: string,
        request: Skyvern.GetRunTagHistoryRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunTagHistoryResponse>> {
        const { limit, since, key } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (limit != null) {
            _queryParams.limit = limit.toString();
        }

        if (since != null) {
            _queryParams.since = since;
        }

        if (key != null) {
            _queryParams.key = key;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(workflowRunId)}/tags/history`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunTagHistoryResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/runs/{workflow_run_id}/tags/history.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * List all tag keys registered for the organization with their descriptions.
     *
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.listTagKeys()
     */
    public listTagKeys(requestOptions?: SkyvernClient.RequestOptions): core.HttpResponsePromise<Skyvern.TagKey[]> {
        return core.HttpResponsePromise.fromPromise(this.__listTagKeys(requestOptions));
    }

    private async __listTagKeys(
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagKey[]>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/tag-keys",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagKey[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/tag-keys.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Delete a tag key from the organization registry and remove that tag from every workflow that currently has it (cascade). Returns how many workflows the tag was removed from.
     *
     * @param {string} key - Tag key to delete
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteTagKey("env")
     */
    public deleteTagKey(
        key: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagKeyDeleteResponse> {
        return core.HttpResponsePromise.fromPromise(this.__deleteTagKey(key, requestOptions));
    }

    private async __deleteTagKey(
        key: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagKeyDeleteResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/tag-keys/${core.url.encodePathParam(key)}`,
            ),
            method: "DELETE",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagKeyDeleteResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling DELETE /v1/tag-keys/{key}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Update the description for a tag key.
     *
     * @param {string} key - Tag key to update
     * @param {Skyvern.TagKeyUpdate} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateTagKey("key")
     */
    public updateTagKey(
        key: string,
        request: Skyvern.TagKeyUpdate = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagKey> {
        return core.HttpResponsePromise.fromPromise(this.__updateTagKey(key, request, requestOptions));
    }

    private async __updateTagKey(
        key: string,
        request: Skyvern.TagKeyUpdate = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagKey>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/tag-keys/${core.url.encodePathParam(key)}`,
            ),
            method: "PATCH",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagKey, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling PATCH /v1/tag-keys/{key}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * List the palette color and current workflow usage count for each grouped tag (key, value) for the organization. The frontend joins these onto tags by (key, value); workflow_count is the number of non-deleted workflows carrying the label and powers the per-label usage and delete blast-radius warnings.
     *
     * @param {Skyvern.ListTagValuesRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.listTagValues({
     *         key: "key"
     *     })
     */
    public listTagValues(
        request: Skyvern.ListTagValuesRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagValue[]> {
        return core.HttpResponsePromise.fromPromise(this.__listTagValues(request, requestOptions));
    }

    private async __listTagValues(
        request: Skyvern.ListTagValuesRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagValue[]>> {
        const { key } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (key != null) {
            _queryParams.key = key;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/tag-values",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagValue[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/tag-values.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Soft-delete a grouped tag (key, value) and remove that label from every workflow carrying it (cascade). The value rides in the body so values containing '/' stay addressable. Returns how many workflows the label was removed from.
     *
     * @param {string} key - Tag key (group)
     * @param {Skyvern.TagValueDelete} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteTagValue("env", {
     *         value: "value"
     *     })
     */
    public deleteTagValue(
        key: string,
        request: Skyvern.TagValueDelete,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagValueDeleteResponse> {
        return core.HttpResponsePromise.fromPromise(this.__deleteTagValue(key, request, requestOptions));
    }

    private async __deleteTagValue(
        key: string,
        request: Skyvern.TagValueDelete,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagValueDeleteResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/tag-values/${core.url.encodePathParam(key)}`,
            ),
            method: "DELETE",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagValueDeleteResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling DELETE /v1/tag-values/{key}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Recolor a grouped tag (key, value). The value is supplied in the body so values containing '/' stay addressable. The new color must be a palette name.
     *
     * @param {string} key - Tag key (group)
     * @param {Skyvern.TagValueUpdate} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateTagValue("env", {
     *         value: "value",
     *         color: "color"
     *     })
     */
    public updateTagValue(
        key: string,
        request: Skyvern.TagValueUpdate,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagValue> {
        return core.HttpResponsePromise.fromPromise(this.__updateTagValue(key, request, requestOptions));
    }

    private async __updateTagValue(
        key: string,
        request: Skyvern.TagValueUpdate,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagValue>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/tag-values/${core.url.encodePathParam(key)}`,
            ),
            method: "PATCH",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagValue, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling PATCH /v1/tag-values/{key}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Rename a grouped tag (key, value) to (key, new_value). The cascade re-tags every workflow carrying the old label; the new label inherits the old color. Both values ride in the body so values containing '/' stay addressable. Rejects with 409 when the new value already exists for the key.
     *
     * @param {string} key - Tag key (group)
     * @param {Skyvern.TagValueRename} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.ConflictError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.renameTagValue("env", {
     *         value: "value",
     *         new_value: "new_value"
     *     })
     */
    public renameTagValue(
        key: string,
        request: Skyvern.TagValueRename,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagValueRenameResponse> {
        return core.HttpResponsePromise.fromPromise(this.__renameTagValue(key, request, requestOptions));
    }

    private async __renameTagValue(
        key: string,
        request: Skyvern.TagValueRename,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagValueRenameResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/tag-values/${core.url.encodePathParam(key)}/rename`,
            ),
            method: "PATCH",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagValueRenameResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 409:
                    throw new Skyvern.ConflictError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling PATCH /v1/tag-values/{key}/rename.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Batch fetch current tags for many workflows. Avoids N+1 on the workflows-list page.
     *
     * @param {Skyvern.BatchGetWorkflowTagsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.batchGetWorkflowTags({
     *         workflow_permanent_ids: "workflow_permanent_ids"
     *     })
     */
    public batchGetWorkflowTags(
        request: Skyvern.BatchGetWorkflowTagsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowTagsBatchResponse> {
        return core.HttpResponsePromise.fromPromise(this.__batchGetWorkflowTags(request, requestOptions));
    }

    private async __batchGetWorkflowTags(
        request: Skyvern.BatchGetWorkflowTagsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowTagsBatchResponse>> {
        const { workflow_permanent_ids: workflowPermanentIds } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (workflowPermanentIds != null) {
            _queryParams.workflow_permanent_ids = workflowPermanentIds;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/workflow-tags",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowTagsBatchResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/workflow-tags.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Batch fetch current tags for many workflows (POST variant for id lists exceeding URL length).
     *
     * @param {Skyvern.WorkflowTagsBatchRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.batchGetWorkflowTagsPost()
     */
    public batchGetWorkflowTagsPost(
        request: Skyvern.WorkflowTagsBatchRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowTagsBatchResponse> {
        return core.HttpResponsePromise.fromPromise(this.__batchGetWorkflowTagsPost(request, requestOptions));
    }

    private async __batchGetWorkflowTagsPost(
        request: Skyvern.WorkflowTagsBatchRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowTagsBatchResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/workflow-tags",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowTagsBatchResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/workflow-tags.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Batch fetch current tags for many workflow runs. Avoids N+1 on run-list pages.
     *
     * @param {Skyvern.BatchGetRunTagsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.batchGetRunTags({
     *         workflow_run_ids: "workflow_run_ids"
     *     })
     */
    public batchGetRunTags(
        request: Skyvern.BatchGetRunTagsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunTagsBatchResponse> {
        return core.HttpResponsePromise.fromPromise(this.__batchGetRunTags(request, requestOptions));
    }

    private async __batchGetRunTags(
        request: Skyvern.BatchGetRunTagsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunTagsBatchResponse>> {
        const { workflow_run_ids: workflowRunIds } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (workflowRunIds != null) {
            _queryParams.workflow_run_ids = workflowRunIds;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/run-tags",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunTagsBatchResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/run-tags.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Batch fetch current tags for many workflow runs (POST variant for id lists exceeding URL length).
     *
     * @param {Skyvern.RunTagsBatchRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.batchGetRunTagsPost()
     */
    public batchGetRunTagsPost(
        request: Skyvern.RunTagsBatchRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunTagsBatchResponse> {
        return core.HttpResponsePromise.fromPromise(this.__batchGetRunTagsPost(request, requestOptions));
    }

    private async __batchGetRunTagsPost(
        request: Skyvern.RunTagsBatchRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunTagsBatchResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/run-tags",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunTagsBatchResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/run-tags.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get artifacts for a run
     *
     * @param {string} runId - The id of the task run or the workflow run.
     * @param {Skyvern.GetRunArtifactsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getRunArtifacts("run_id")
     */
    public getRunArtifacts(
        runId: string,
        request: Skyvern.GetRunArtifactsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Artifact[]> {
        return core.HttpResponsePromise.fromPromise(this.__getRunArtifacts(runId, request, requestOptions));
    }

    private async __getRunArtifacts(
        runId: string,
        request: Skyvern.GetRunArtifactsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Artifact[]>> {
        const { artifact_type: artifactType } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (artifactType != null) {
            if (Array.isArray(artifactType)) {
                _queryParams.artifact_type = artifactType.map((item) => item);
            } else {
                _queryParams.artifact_type = artifactType;
            }
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(runId)}/artifacts`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Artifact[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/runs/{run_id}/artifacts.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Retry sending the webhook for a run
     *
     * @param {string} runId - The id of the task run or the workflow run.
     * @param {Skyvern.RetryRunWebhookRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.retryRunWebhook("tsk_123")
     */
    public retryRunWebhook(
        runId: string,
        request?: Skyvern.RetryRunWebhookRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunWebhookReplayResponse> {
        return core.HttpResponsePromise.fromPromise(this.__retryRunWebhook(runId, request, requestOptions));
    }

    private async __retryRunWebhook(
        runId: string,
        request?: Skyvern.RetryRunWebhookRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunWebhookReplayResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(runId)}/retry_webhook`,
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request != null ? request : undefined,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunWebhookReplayResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/runs/{run_id}/retry_webhook.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get timeline for a run (workflow run or task_v2 run)
     *
     * @param {string} runId - The id of the workflow run or task_v2 run.
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getRunTimeline("wr_123")
     */
    public getRunTimeline(
        runId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowRunTimeline[]> {
        return core.HttpResponsePromise.fromPromise(this.__getRunTimeline(runId, requestOptions));
    }

    private async __getRunTimeline(
        runId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowRunTimeline[]>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/runs/${core.url.encodePathParam(runId)}/timeline`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowRunTimeline[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/runs/{run_id}/timeline.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Returns the current Skyvern server version (git SHA for official builds).
     *
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @example
     *     await client.getVersion()
     */
    public getVersion(requestOptions?: SkyvernClient.RequestOptions): core.HttpResponsePromise<Record<string, string>> {
        return core.HttpResponsePromise.fromPromise(this.__getVersion(requestOptions));
    }

    private async __getVersion(
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Record<string, string>>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/version",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Record<string, string>, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            throw new errors.SkyvernError({
                statusCode: _response.error.statusCode,
                body: _response.error.body,
                rawResponse: _response.rawResponse,
            });
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/version.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * @param {Skyvern.GetRunsV2Request} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getRunsV2({
     *         page: 1,
     *         page_size: 1,
     *         search_key: "search_key"
     *     })
     */
    public getRunsV2(
        request: Skyvern.GetRunsV2Request = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TaskRunListItem[]> {
        return core.HttpResponsePromise.fromPromise(this.__getRunsV2(request, requestOptions));
    }

    private async __getRunsV2(
        request: Skyvern.GetRunsV2Request = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TaskRunListItem[]>> {
        const { page, page_size: pageSize, status, search_key: searchKey, run_type: runType } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        if (status != null) {
            if (Array.isArray(status)) {
                _queryParams.status = status.map((item) => item);
            } else {
                _queryParams.status = status;
            }
        }

        if (searchKey != null) {
            _queryParams.search_key = searchKey;
        }

        if (runType != null) {
            if (Array.isArray(runType)) {
                _queryParams.run_type = runType.map((item) => item);
            } else {
                _queryParams.run_type = runType;
            }
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/runs",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TaskRunListItem[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/runs.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * @param {Skyvern.BodyUploadFileV1UploadFilePost} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     import { createReadStream } from "fs";
     *     await client.uploadFile({
     *         file: "file"
     *     })
     */
    public uploadFile(
        request: Skyvern.BodyUploadFileV1UploadFilePost,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.UploadFileResponse> {
        return core.HttpResponsePromise.fromPromise(this.__uploadFile(request, requestOptions));
    }

    private async __uploadFile(
        request: Skyvern.BodyUploadFileV1UploadFilePost,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.UploadFileResponse>> {
        const _request = await core.newFormData();
        _request.append("file", request.file);
        const _maybeEncodedRequest = await _request.getRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({
                "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey,
                ..._maybeEncodedRequest.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.SkyvernEnvironment.Cloud,
                "v1/upload_file",
            ),
            method: "POST",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            requestType: "file",
            duplex: _maybeEncodedRequest.duplex,
            body: _maybeEncodedRequest.body,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.UploadFileResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/upload_file.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get all browser profiles for the organization
     *
     * @param {Skyvern.ListBrowserProfilesRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.listBrowserProfiles({
     *         page: 1,
     *         page_size: 1,
     *         include_deleted: true,
     *         search_key: "search_key",
     *         managed: true
     *     })
     */
    public listBrowserProfiles(
        request: Skyvern.ListBrowserProfilesRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserProfile[]> {
        return core.HttpResponsePromise.fromPromise(this.__listBrowserProfiles(request, requestOptions));
    }

    private async __listBrowserProfiles(
        request: Skyvern.ListBrowserProfilesRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserProfile[]>> {
        const { page, page_size: pageSize, include_deleted: includeDeleted, search_key: searchKey, managed } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        if (includeDeleted != null) {
            _queryParams.include_deleted = includeDeleted.toString();
        }

        if (searchKey != null) {
            _queryParams.search_key = searchKey;
        }

        if (managed != null) {
            _queryParams.managed = managed.toString();
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/browser_profiles",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserProfile[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/browser_profiles.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Create a blank browser profile, or create one from a persistent browser session or workflow run.
     *
     * @param {Skyvern.CreateBrowserProfileRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.ConflictError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.createBrowserProfile({
     *         name: "name"
     *     })
     */
    public createBrowserProfile(
        request: Skyvern.CreateBrowserProfileRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserProfile> {
        return core.HttpResponsePromise.fromPromise(this.__createBrowserProfile(request, requestOptions));
    }

    private async __createBrowserProfile(
        request: Skyvern.CreateBrowserProfileRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserProfile>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/browser_profiles",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserProfile, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 409:
                    throw new Skyvern.ConflictError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/browser_profiles.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get a specific browser profile by ID
     *
     * @param {string} profileId - The ID of the browser profile. browser_profile_id starts with `bp_`
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getBrowserProfile("bp_123456")
     */
    public getBrowserProfile(
        profileId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserProfile> {
        return core.HttpResponsePromise.fromPromise(this.__getBrowserProfile(profileId, requestOptions));
    }

    private async __getBrowserProfile(
        profileId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserProfile>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/browser_profiles/${core.url.encodePathParam(profileId)}`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserProfile, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/browser_profiles/{profile_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Delete a browser profile (soft delete)
     *
     * @param {string} profileId - The ID of the browser profile to delete. browser_profile_id starts with `bp_`
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteBrowserProfile("bp_123456")
     */
    public deleteBrowserProfile(
        profileId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__deleteBrowserProfile(profileId, requestOptions));
    }

    private async __deleteBrowserProfile(
        profileId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/browser_profiles/${core.url.encodePathParam(profileId)}`,
            ),
            method: "DELETE",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling DELETE /v1/browser_profiles/{profile_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Update a browser profile's name and/or description
     *
     * @param {string} profileId - The ID of the browser profile to update. browser_profile_id starts with `bp_`
     * @param {Skyvern.UpdateBrowserProfileRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.ConflictError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateBrowserProfile("bp_123456")
     */
    public updateBrowserProfile(
        profileId: string,
        request: Skyvern.UpdateBrowserProfileRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserProfile> {
        return core.HttpResponsePromise.fromPromise(this.__updateBrowserProfile(profileId, request, requestOptions));
    }

    private async __updateBrowserProfile(
        profileId: string,
        request: Skyvern.UpdateBrowserProfileRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserProfile>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/browser_profiles/${core.url.encodePathParam(profileId)}`,
            ),
            method: "PATCH",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserProfile, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 409:
                    throw new Skyvern.ConflictError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling PATCH /v1/browser_profiles/{profile_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get all active browser sessions for the organization
     *
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.ForbiddenError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getBrowserSessions()
     */
    public getBrowserSessions(
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserSessionResponse[]> {
        return core.HttpResponsePromise.fromPromise(this.__getBrowserSessions(requestOptions));
    }

    private async __getBrowserSessions(
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserSessionResponse[]>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/browser_sessions",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserSessionResponse[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 403:
                    throw new Skyvern.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/browser_sessions.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Create a browser session that persists across multiple runs
     *
     * @param {Skyvern.CreateBrowserSessionRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.ForbiddenError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.createBrowserSession()
     */
    public createBrowserSession(
        request: Skyvern.CreateBrowserSessionRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserSessionResponse> {
        return core.HttpResponsePromise.fromPromise(this.__createBrowserSession(request, requestOptions));
    }

    private async __createBrowserSession(
        request: Skyvern.CreateBrowserSessionRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserSessionResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/browser_sessions",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserSessionResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 403:
                    throw new Skyvern.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/browser_sessions.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Close a session. Once closed, the session cannot be used again.
     *
     * @param {string} browserSessionId - The ID of the browser session to close. completed_at will be set when the browser session is closed. browser_session_id starts with `pbs_`
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.ForbiddenError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.closeBrowserSession("pbs_123456")
     */
    public closeBrowserSession(
        browserSessionId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<unknown> {
        return core.HttpResponsePromise.fromPromise(this.__closeBrowserSession(browserSessionId, requestOptions));
    }

    private async __closeBrowserSession(
        browserSessionId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<unknown>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/browser_sessions/${core.url.encodePathParam(browserSessionId)}/close`,
            ),
            method: "POST",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 403:
                    throw new Skyvern.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/browser_sessions/{browser_session_id}/close.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Extend a live browser session by a number of minutes. Sessions are created with a timeout of at most 240 minutes and can be extended, one or more times, up to a total lifetime of 360 minutes (6 hours). The minutes are added to the session's current deadline. A request for more than the remaining headroom is granted the remainder, and the response carries a warning. The response's `timeout` is the session's new total budget in minutes, counted from when the session started.
     *
     * @param {string} browserSessionId - The ID of the browser session. browser_session_id starts with `pbs_`
     * @param {Skyvern.ExtendBrowserSessionRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.ForbiddenError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.ConflictError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.extendBrowserSession("pbs_123456", {
     *         additional_minutes: 1
     *     })
     */
    public extendBrowserSession(
        browserSessionId: string,
        request: Skyvern.ExtendBrowserSessionRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserSessionResponse> {
        return core.HttpResponsePromise.fromPromise(
            this.__extendBrowserSession(browserSessionId, request, requestOptions),
        );
    }

    private async __extendBrowserSession(
        browserSessionId: string,
        request: Skyvern.ExtendBrowserSessionRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserSessionResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/browser_sessions/${core.url.encodePathParam(browserSessionId)}/extend`,
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserSessionResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 403:
                    throw new Skyvern.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 409:
                    throw new Skyvern.ConflictError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/browser_sessions/{browser_session_id}/extend.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get details about a specific browser session, including the browser address for cdp connection.
     *
     * @param {string} browserSessionId - The ID of the browser session. browser_session_id starts with `pbs_`
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.ForbiddenError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getBrowserSession("pbs_123456")
     */
    public getBrowserSession(
        browserSessionId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserSessionResponse> {
        return core.HttpResponsePromise.fromPromise(this.__getBrowserSession(browserSessionId, requestOptions));
    }

    private async __getBrowserSession(
        browserSessionId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserSessionResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/browser_sessions/${core.url.encodePathParam(browserSessionId)}`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserSessionResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 403:
                    throw new Skyvern.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/browser_sessions/{browser_session_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Update a live browser session. Currently supports toggling generate_browser_profile, which is read when the session ends to decide whether to save its browser profile.
     *
     * @param {string} browserSessionId - The ID of the browser session. browser_session_id starts with `pbs_`
     * @param {Skyvern.UpdateBrowserSessionRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.ForbiddenError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.ConflictError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateBrowserSession("pbs_123456", {
     *         generate_browser_profile: true
     *     })
     */
    public updateBrowserSession(
        browserSessionId: string,
        request: Skyvern.UpdateBrowserSessionRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.BrowserSessionResponse> {
        return core.HttpResponsePromise.fromPromise(
            this.__updateBrowserSession(browserSessionId, request, requestOptions),
        );
    }

    private async __updateBrowserSession(
        browserSessionId: string,
        request: Skyvern.UpdateBrowserSessionRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.BrowserSessionResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/browser_sessions/${core.url.encodePathParam(browserSessionId)}`,
            ),
            method: "PATCH",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.BrowserSessionResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 403:
                    throw new Skyvern.ForbiddenError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 409:
                    throw new Skyvern.ConflictError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling PATCH /v1/browser_sessions/{browser_session_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Forward a TOTP (2FA, MFA) email or sms message containing the code to Skyvern. This endpoint stores the code in database so that Skyvern can use it while running tasks/workflows.
     *
     * @param {Skyvern.TotpCodeCreate} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.sendTotpCode({
     *         totp_identifier: "[email protected]",
     *         content: "Hello, your verification code is 123456"
     *     })
     */
    public sendTotpCode(
        request: Skyvern.TotpCodeCreate,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TotpCode> {
        return core.HttpResponsePromise.fromPromise(this.__sendTotpCode(request, requestOptions));
    }

    private async __sendTotpCode(
        request: Skyvern.TotpCodeCreate,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TotpCode>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/credentials/totp",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TotpCode, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/credentials/totp.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Retrieves a paginated list of credentials for the current organization
     *
     * @param {Skyvern.GetCredentialsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getCredentials({
     *         page: 1,
     *         page_size: 10,
     *         vault_type: "skyvern",
     *         credential_type: "password",
     *         search: "search"
     *     })
     */
    public getCredentials(
        request: Skyvern.GetCredentialsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CredentialResponse[]> {
        return core.HttpResponsePromise.fromPromise(this.__getCredentials(request, requestOptions));
    }

    private async __getCredentials(
        request: Skyvern.GetCredentialsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CredentialResponse[]>> {
        const { page, page_size: pageSize, vault_type: vaultType, credential_type: credentialType, search } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        if (vaultType != null) {
            _queryParams.vault_type = vaultType;
        }

        if (credentialType != null) {
            _queryParams.credential_type = credentialType;
        }

        if (search != null) {
            _queryParams.search = search;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/credentials",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CredentialResponse[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/credentials.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Creates a new credential for the current organization
     *
     * @param {Skyvern.CreateCredentialRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.createCredential({
     *         name: "Amazon Login",
     *         credential_type: "password",
     *         credential: {
     *             password: "securepassword123",
     *             username: "[email protected]"
     *         }
     *     })
     */
    public createCredential(
        request: Skyvern.CreateCredentialRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CredentialResponse> {
        return core.HttpResponsePromise.fromPromise(this.__createCredential(request, requestOptions));
    }

    private async __createCredential(
        request: Skyvern.CreateCredentialRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CredentialResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/credentials",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CredentialResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/credentials.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Overwrites the stored credential data (e.g. username/password) while keeping the same credential_id.
     *
     * @param {string} credentialId - The unique identifier of the credential to update
     * @param {Skyvern.CreateCredentialRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateCredential("cred_1234567890", {
     *         name: "Amazon Login",
     *         credential_type: "password",
     *         credential: {
     *             password: "securepassword123",
     *             username: "[email protected]"
     *         }
     *     })
     */
    public updateCredential(
        credentialId: string,
        request: Skyvern.CreateCredentialRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CredentialResponse> {
        return core.HttpResponsePromise.fromPromise(this.__updateCredential(credentialId, request, requestOptions));
    }

    private async __updateCredential(
        credentialId: string,
        request: Skyvern.CreateCredentialRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CredentialResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/credentials/${core.url.encodePathParam(credentialId)}/update`,
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CredentialResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/credentials/{credential_id}/update.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Deletes a specific credential by its ID
     *
     * @param {string} credentialId - The unique identifier of the credential to delete
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteCredential("cred_1234567890")
     */
    public deleteCredential(
        credentialId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__deleteCredential(credentialId, requestOptions));
    }

    private async __deleteCredential(
        credentialId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/credentials/${core.url.encodePathParam(credentialId)}/delete`,
            ),
            method: "POST",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/credentials/{credential_id}/delete.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Retrieves a specific credential by its ID
     *
     * @param {string} credentialId - The unique identifier of the credential
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getCredential("cred_1234567890")
     */
    public getCredential(
        credentialId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CredentialResponse> {
        return core.HttpResponsePromise.fromPromise(this.__getCredential(credentialId, requestOptions));
    }

    private async __getCredential(
        credentialId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CredentialResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/credentials/${core.url.encodePathParam(credentialId)}`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CredentialResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/credentials/{credential_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * List the custom LLM configurations available to the current organization.
     *
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.listCustomLlms()
     */
    public listCustomLlms(
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CustomLlmListResponse> {
        return core.HttpResponsePromise.fromPromise(this.__listCustomLlms(requestOptions));
    }

    private async __listCustomLlms(
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CustomLlmListResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/custom-llms",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CustomLlmListResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/custom-llms.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Create a custom LLM configuration for the current organization.
     *
     * @param {Skyvern.CustomLlmCreateRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.createCustomLlm({
     *         config: {
     *             display_name: "display_name",
     *             provider: "openai_compatible",
     *             model_name: "model_name"
     *         }
     *     })
     */
    public createCustomLlm(
        request: Skyvern.CustomLlmCreateRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CustomLlmResponse> {
        return core.HttpResponsePromise.fromPromise(this.__createCustomLlm(request, requestOptions));
    }

    private async __createCustomLlm(
        request: Skyvern.CustomLlmCreateRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CustomLlmResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/custom-llms",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CustomLlmResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/custom-llms.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Update a custom LLM configuration for the current organization.
     *
     * @param {string} customLlmId - The custom LLM id.
     * @param {Skyvern.CustomLlmUpdateRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateCustomLlm("custom_llm_id", {
     *         config: {
     *             display_name: "display_name",
     *             provider: "openai_compatible",
     *             model_name: "model_name"
     *         }
     *     })
     */
    public updateCustomLlm(
        customLlmId: string,
        request: Skyvern.CustomLlmUpdateRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CustomLlmResponse> {
        return core.HttpResponsePromise.fromPromise(this.__updateCustomLlm(customLlmId, request, requestOptions));
    }

    private async __updateCustomLlm(
        customLlmId: string,
        request: Skyvern.CustomLlmUpdateRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CustomLlmResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/custom-llms/${core.url.encodePathParam(customLlmId)}`,
            ),
            method: "PUT",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CustomLlmResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling PUT /v1/custom-llms/{custom_llm_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Delete a custom LLM configuration for the current organization.
     *
     * @param {string} customLlmId - The custom LLM id.
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteCustomLlm("custom_llm_id")
     */
    public deleteCustomLlm(
        customLlmId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.ClearOrganizationAuthTokenResponse> {
        return core.HttpResponsePromise.fromPromise(this.__deleteCustomLlm(customLlmId, requestOptions));
    }

    private async __deleteCustomLlm(
        customLlmId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.ClearOrganizationAuthTokenResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/custom-llms/${core.url.encodePathParam(customLlmId)}`,
            ),
            method: "DELETE",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return {
                data: _response.body as Skyvern.ClearOrganizationAuthTokenResponse,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling DELETE /v1/custom-llms/{custom_llm_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Log in to a website using either credential stored in Skyvern, Bitwarden, 1Password, or Azure Vault
     *
     * @param {Skyvern.LoginRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.login({
     *         "x-user-agent": "x-user-agent",
     *         credential_type: "skyvern"
     *     })
     */
    public login(
        request: Skyvern.LoginRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowRunResponse> {
        return core.HttpResponsePromise.fromPromise(this.__login(request, requestOptions));
    }

    private async __login(
        request: Skyvern.LoginRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowRunResponse>> {
        const { "x-user-agent": userAgent, ..._body } = request;
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({
                "x-user-agent": userAgent != null ? userAgent : undefined,
                "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey,
            }),
            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.SkyvernEnvironment.Cloud,
                "v1/run/tasks/login",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: _body,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowRunResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/run/tasks/login.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Download a file from a website by navigating and clicking download buttons
     *
     * @param {Skyvern.DownloadFilesRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.downloadFiles({
     *         "x-user-agent": "x-user-agent",
     *         navigation_goal: "navigation_goal"
     *     })
     */
    public downloadFiles(
        request: Skyvern.DownloadFilesRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowRunResponse> {
        return core.HttpResponsePromise.fromPromise(this.__downloadFiles(request, requestOptions));
    }

    private async __downloadFiles(
        request: Skyvern.DownloadFilesRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowRunResponse>> {
        const { "x-user-agent": userAgent, ..._body } = request;
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({
                "x-user-agent": userAgent != null ? userAgent : undefined,
                "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey,
            }),
            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.SkyvernEnvironment.Cloud,
                "v1/run/tasks/download_files",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: _body,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowRunResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/run/tasks/download_files.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Retrieves a paginated list of scripts for the current organization
     *
     * @param {Skyvern.GetScriptsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getScripts({
     *         page: 1,
     *         page_size: 10
     *     })
     */
    public getScripts(
        request: Skyvern.GetScriptsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Script[]> {
        return core.HttpResponsePromise.fromPromise(this.__getScripts(request, requestOptions));
    }

    private async __getScripts(
        request: Skyvern.GetScriptsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Script[]>> {
        const { page, page_size: pageSize } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/scripts",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Script[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/scripts.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Create a new script with optional files and metadata
     *
     * @param {Skyvern.CreateScriptRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.createScript()
     */
    public createScript(
        request: Skyvern.CreateScriptRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CreateScriptResponse> {
        return core.HttpResponsePromise.fromPromise(this.__createScript(request, requestOptions));
    }

    private async __createScript(
        request: Skyvern.CreateScriptRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CreateScriptResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/scripts",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CreateScriptResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/scripts.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Retrieves a specific script by its ID
     *
     * @param {string} scriptId - The unique identifier of the script
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getScript("s_abc123")
     */
    public getScript(
        scriptId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Script> {
        return core.HttpResponsePromise.fromPromise(this.__getScript(scriptId, requestOptions));
    }

    private async __getScript(
        scriptId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Script>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/scripts/${core.url.encodePathParam(scriptId)}`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Script, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/scripts/{script_id}.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Deploy a script with updated files, creating a new version
     *
     * @param {string} scriptId - The unique identifier of the script
     * @param {Skyvern.DeployScriptRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deployScript("s_abc123", {
     *         files: [{
     *                 path: "src/main.py",
     *                 content: "content"
     *             }]
     *     })
     */
    public deployScript(
        scriptId: string,
        request: Skyvern.DeployScriptRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.CreateScriptResponse> {
        return core.HttpResponsePromise.fromPromise(this.__deployScript(scriptId, request, requestOptions));
    }

    private async __deployScript(
        scriptId: string,
        request: Skyvern.DeployScriptRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.CreateScriptResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/scripts/${core.url.encodePathParam(scriptId)}/deploy`,
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.CreateScriptResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/scripts/{script_id}/deploy.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Execute a single SDK action with the specified parameters
     *
     * @param {Skyvern.RunSdkActionRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.runSdkAction({
     *         url: "url",
     *         action: {
     *             type: "ai_act"
     *         }
     *     })
     */
    public runSdkAction(
        request: Skyvern.RunSdkActionRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.RunSdkActionResponse> {
        return core.HttpResponsePromise.fromPromise(this.__runSdkAction(request, requestOptions));
    }

    private async __runSdkAction(
        request: Skyvern.RunSdkActionRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.RunSdkActionResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/sdk/run_action",
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.RunSdkActionResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling POST /v1/sdk/run_action.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Update a workflow's folder assignment for the latest version
     *
     * @param {string} workflowPermanentId - Workflow permanent ID
     * @param {Skyvern.UpdateWorkflowFolderRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.updateWorkflowFolder("wpid_123")
     */
    public updateWorkflowFolder(
        workflowPermanentId: string,
        request: Skyvern.UpdateWorkflowFolderRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Workflow> {
        return core.HttpResponsePromise.fromPromise(
            this.__updateWorkflowFolder(workflowPermanentId, request, requestOptions),
        );
    }

    private async __updateWorkflowFolder(
        workflowPermanentId: string,
        request: Skyvern.UpdateWorkflowFolderRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Workflow>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowPermanentId)}/folder`,
            ),
            method: "PUT",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Workflow, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling PUT /v1/agents/{workflow_permanent_id}/folder.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get the current tag state for a workflow.
     *
     * @param {string} workflowPermanentId - Workflow permanent ID
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getWorkflowTags("wpid_123")
     */
    public getWorkflowTags(
        workflowPermanentId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagsResponse> {
        return core.HttpResponsePromise.fromPromise(this.__getWorkflowTags(workflowPermanentId, requestOptions));
    }

    private async __getWorkflowTags(
        workflowPermanentId: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagsResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowPermanentId)}/tags`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagsResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/agents/{workflow_permanent_id}/tags.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Atomically apply tag changes to a workflow. Sets and deletes happen in one transaction; same-key collisions resolve set-wins.
     *
     * @param {string} workflowPermanentId - Workflow permanent ID
     * @param {Skyvern.TagApplyRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.applyWorkflowTags("wpid_123", {})
     */
    public applyWorkflowTags(
        workflowPermanentId: string,
        request: Skyvern.TagApplyRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagsResponse> {
        return core.HttpResponsePromise.fromPromise(
            this.__applyWorkflowTags(workflowPermanentId, request, requestOptions),
        );
    }

    private async __applyWorkflowTags(
        workflowPermanentId: string,
        request: Skyvern.TagApplyRequest,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagsResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowPermanentId)}/tags`,
            ),
            method: "POST",
            headers: _headers,
            contentType: "application/json",
            queryParameters: requestOptions?.queryParams,
            requestType: "json",
            body: request,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagsResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/agents/{workflow_permanent_id}/tags.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Soft-delete a single tag from a workflow. Writes a DELETE event row.
     *
     * @param {string} workflowPermanentId - Workflow permanent ID
     * @param {string} key - Tag key to delete
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.deleteWorkflowTag("wpid_123", "env")
     */
    public deleteWorkflowTag(
        workflowPermanentId: string,
        key: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagsResponse> {
        return core.HttpResponsePromise.fromPromise(this.__deleteWorkflowTag(workflowPermanentId, key, requestOptions));
    }

    private async __deleteWorkflowTag(
        workflowPermanentId: string,
        key: string,
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagsResponse>> {
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowPermanentId)}/tags/${core.url.encodePathParam(key)}`,
            ),
            method: "DELETE",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagsResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling DELETE /v1/agents/{workflow_permanent_id}/tags/{key}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Chronological tag-event log for a workflow (newest first). Includes SET and DELETE events.
     *
     * @param {string} workflowPermanentId - Workflow permanent ID
     * @param {Skyvern.GetWorkflowTagHistoryRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getWorkflowTagHistory("wpid_123", {
     *         limit: 1,
     *         since: "2024-01-15T09:30:00Z",
     *         key: "key"
     *     })
     */
    public getWorkflowTagHistory(
        workflowPermanentId: string,
        request: Skyvern.GetWorkflowTagHistoryRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.TagHistoryResponse> {
        return core.HttpResponsePromise.fromPromise(
            this.__getWorkflowTagHistory(workflowPermanentId, request, requestOptions),
        );
    }

    private async __getWorkflowTagHistory(
        workflowPermanentId: string,
        request: Skyvern.GetWorkflowTagHistoryRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.TagHistoryResponse>> {
        const { limit, since, key } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (limit != null) {
            _queryParams.limit = limit.toString();
        }

        if (since != null) {
            _queryParams.since = since;
        }

        if (key != null) {
            _queryParams.key = key;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowPermanentId)}/tags/history`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.TagHistoryResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/agents/{workflow_permanent_id}/tags/history.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Retry a workflow run using the original run parameters.
     *
     * @param {string} workflowRunId - The id of the workflow run to retry.
     * @param {Skyvern.RetryWorkflowRunRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.BadRequestError}
     * @throws {@link Skyvern.NotFoundError}
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.retryWorkflowRun("wr_123", {
     *         "x-max-steps-override": 1,
     *         "x-user-agent": "x-user-agent"
     *     })
     */
    public retryWorkflowRun(
        workflowRunId: string,
        request: Skyvern.RetryWorkflowRunRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowRunResponse> {
        return core.HttpResponsePromise.fromPromise(this.__retryWorkflowRun(workflowRunId, request, requestOptions));
    }

    private async __retryWorkflowRun(
        workflowRunId: string,
        request: Skyvern.RetryWorkflowRunRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowRunResponse>> {
        const { "x-max-steps-override": maxStepsOverride, "x-user-agent": userAgent } = request;
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({
                "x-max-steps-override": maxStepsOverride != null ? maxStepsOverride.toString() : undefined,
                "x-user-agent": userAgent != null ? userAgent : undefined,
                "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey,
            }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/runs/${core.url.encodePathParam(workflowRunId)}/retry`,
            ),
            method: "POST",
            headers: _headers,
            queryParameters: requestOptions?.queryParams,
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowRunResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 400:
                    throw new Skyvern.BadRequestError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Skyvern.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling POST /v1/agents/runs/{workflow_run_id}/retry.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * List workflow runs across all workflows for the current organization.
     *
     * Results are paginated and can be filtered by **status**, **search_key**, and **error_code**. All filters are combined with **AND** logic — a run must match every supplied filter to be returned.
     *
     * ### search_key
     *
     * A case-insensitive substring search that matches against **any** of the following fields:
     *
     * | Searched field | Description |
     * |---|---|
     * | `workflow_run_id` | The unique run identifier (e.g. `wr_123…`) |
     * | Parameter **key** | The `key` of any workflow parameter definition associated with the run |
     * | Parameter **description** | The `description` of any workflow parameter definition |
     * | Run parameter **value** | The actual value supplied for any parameter when the run was created |
     * | `extra_http_headers` | Extra HTTP headers attached to the run (searched as raw JSON text) |
     *
     * Soft-deleted parameter definitions are excluded from key/description matching. A run is returned if **any** of the fields above contain the search term.
     *
     * ### error_code
     *
     * An **exact-match** filter against the `error_code` field inside each task's `errors` JSON array. A run matches if **any** of its tasks contains an error object with a matching `error_code` value. Error codes are user-defined strings set during workflow execution (e.g. `INVALID_CREDENTIALS`, `LOGIN_FAILED`, `CAPTCHA_DETECTED`).
     *
     * ### Combining filters
     *
     * All query parameters use AND logic:
     * - `?status=failed` — only failed runs
     * - `?status=failed&error_code=LOGIN_FAILED` — failed runs **and** have a LOGIN_FAILED error
     * - `?status=failed&error_code=LOGIN_FAILED&search_key=prod_credential` — all three conditions must match
     *
     * @param {Skyvern.GetWorkflowRunsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getWorkflowRuns({
     *         page: 1,
     *         page_size: 1,
     *         search_key: "search_key",
     *         error_code: "error_code"
     *     })
     */
    public getWorkflowRuns(
        request: Skyvern.GetWorkflowRunsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowRun[]> {
        return core.HttpResponsePromise.fromPromise(this.__getWorkflowRuns(request, requestOptions));
    }

    private async __getWorkflowRuns(
        request: Skyvern.GetWorkflowRunsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowRun[]>> {
        const { page, page_size: pageSize, status, search_key: searchKey, error_code: errorCode } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        if (status != null) {
            if (Array.isArray(status)) {
                _queryParams.status = status.map((item) => item);
            } else {
                _queryParams.status = status;
            }
        }

        if (searchKey != null) {
            _queryParams.search_key = searchKey;
        }

        if (errorCode != null) {
            _queryParams.error_code = errorCode;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                "v1/agents/runs",
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowRun[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError("Timeout exceeded when calling GET /v1/agents/runs.");
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * List runs for a specific workflow.
     *
     * Supports filtering by **status**, **search_key**, and **error_code**. All filters are combined with **AND** logic.
     *
     * ### search_key
     *
     * Case-insensitive substring search across: workflow run ID, parameter key, parameter description, run parameter value, and extra HTTP headers. Soft-deleted parameter definitions are excluded.
     *
     * ### error_code
     *
     * Exact-match filter on the `error_code` field inside each task's `errors` JSON array. A run matches if any of its tasks contains an error with a matching `error_code`.
     *
     * @param {string} workflowId
     * @param {Skyvern.GetWorkflowRunsByIdRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getWorkflowRunsById("workflow_id", {
     *         page: 1,
     *         page_size: 1,
     *         search_key: "search_key",
     *         error_code: "error_code",
     *         created_at_start: "2024-01-15T09:30:00Z",
     *         created_at_end: "2024-01-15T09:30:00Z"
     *     })
     */
    public getWorkflowRunsById(
        workflowId: string,
        request: Skyvern.GetWorkflowRunsByIdRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.WorkflowRun[]> {
        return core.HttpResponsePromise.fromPromise(this.__getWorkflowRunsById(workflowId, request, requestOptions));
    }

    private async __getWorkflowRunsById(
        workflowId: string,
        request: Skyvern.GetWorkflowRunsByIdRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.WorkflowRun[]>> {
        const {
            page,
            page_size: pageSize,
            status,
            search_key: searchKey,
            error_code: errorCode,
            created_at_start: createdAtStart,
            created_at_end: createdAtEnd,
        } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (page != null) {
            _queryParams.page = page.toString();
        }

        if (pageSize != null) {
            _queryParams.page_size = pageSize.toString();
        }

        if (status != null) {
            if (Array.isArray(status)) {
                _queryParams.status = status.map((item) => item);
            } else {
                _queryParams.status = status;
            }
        }

        if (searchKey != null) {
            _queryParams.search_key = searchKey;
        }

        if (errorCode != null) {
            _queryParams.error_code = errorCode;
        }

        if (createdAtStart != null) {
            _queryParams.created_at_start = createdAtStart;
        }

        if (createdAtEnd != null) {
            _queryParams.created_at_end = createdAtEnd;
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowId)}/runs`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.WorkflowRun[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/agents/{workflow_id}/runs.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * @param {string} workflowPermanentId
     * @param {Skyvern.GetWorkflowRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getWorkflow("workflow_permanent_id", {
     *         version: 1,
     *         template: true
     *     })
     */
    public getWorkflow(
        workflowPermanentId: string,
        request: Skyvern.GetWorkflowRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Workflow> {
        return core.HttpResponsePromise.fromPromise(this.__getWorkflow(workflowPermanentId, request, requestOptions));
    }

    private async __getWorkflow(
        workflowPermanentId: string,
        request: Skyvern.GetWorkflowRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Workflow>> {
        const { version, template } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (version != null) {
            _queryParams.version = version.toString();
        }

        if (template != null) {
            _queryParams.template = template.toString();
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowPermanentId)}`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Workflow, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/agents/{workflow_permanent_id}.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }

    /**
     * Get all versions of a workflow by its permanent ID.
     *
     * @param {string} workflowPermanentId
     * @param {Skyvern.GetWorkflowVersionsRequest} request
     * @param {SkyvernClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Skyvern.UnprocessableEntityError}
     *
     * @example
     *     await client.getWorkflowVersions("workflow_permanent_id", {
     *         template: true
     *     })
     */
    public getWorkflowVersions(
        workflowPermanentId: string,
        request: Skyvern.GetWorkflowVersionsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): core.HttpResponsePromise<Skyvern.Workflow[]> {
        return core.HttpResponsePromise.fromPromise(
            this.__getWorkflowVersions(workflowPermanentId, request, requestOptions),
        );
    }

    private async __getWorkflowVersions(
        workflowPermanentId: string,
        request: Skyvern.GetWorkflowVersionsRequest = {},
        requestOptions?: SkyvernClient.RequestOptions,
    ): Promise<core.WithRawResponse<Skyvern.Workflow[]>> {
        const { template } = request;
        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
        if (template != null) {
            _queryParams.template = template.toString();
        }

        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "x-api-key": requestOptions?.apiKey ?? this._options?.apiKey }),
            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.SkyvernEnvironment.Cloud,
                `v1/agents/${core.url.encodePathParam(workflowPermanentId)}/versions`,
            ),
            method: "GET",
            headers: _headers,
            queryParameters: { ..._queryParams, ...requestOptions?.queryParams },
            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
            abortSignal: requestOptions?.abortSignal,
        });
        if (_response.ok) {
            return { data: _response.body as Skyvern.Workflow[], rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 422:
                    throw new Skyvern.UnprocessableEntityError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SkyvernError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        switch (_response.error.reason) {
            case "non-json":
                throw new errors.SkyvernError({
                    statusCode: _response.error.statusCode,
                    body: _response.error.rawBody,
                    rawResponse: _response.rawResponse,
                });
            case "timeout":
                throw new errors.SkyvernTimeoutError(
                    "Timeout exceeded when calling GET /v1/agents/{workflow_permanent_id}/versions.",
                );
            case "unknown":
                throw new errors.SkyvernError({
                    message: _response.error.errorMessage,
                    rawResponse: _response.rawResponse,
                });
        }
    }
}