@lusor/sdk 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,1241 @@
+// This file was auto-generated by Fern from our API Definition.
+import { normalizeClientOptionsWithAuth } from "../../../../BaseClient.js";
+import * as core from "../../../../core/index.js";
+import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js";
+import { mergeAdditionalBodyParameters } from "../../../../core/requestBody.js";
+import * as environments from "../../../../environments.js";
+import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js";
+import * as errors from "../../../../errors/index.js";
+import * as Lusor from "../../../index.js";
+import { LiveViewClient } from "../resources/liveView/client/Client.js";
+/**
+ * Run records: list, inspect, stop, and read events and artifacts. Start
+ * a run with `POST /v1/agents/{id}/turns`, or without an agent through
+ * `POST /v1/workspaces/{workspaceId}/devices/{deviceId}/sessions`.
+ */
+export class SessionsClient {
+    _options;
+    _liveView;
+    constructor(options = {}) {
+        this._options = normalizeClientOptionsWithAuth(options);
+    }
+    get liveView() {
+        return (this._liveView ??= new LiveViewClient(this._options));
+    }
+    /**
+     * @param {Lusor.GetSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.get({
+     *         id: "id"
+     *     })
+     */
+    get(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__get(request, requestOptions));
+    }
+    async __get(request, requestOptions) {
+        const { id } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}");
+    }
+    /**
+     * Sets the session's display name. Send `name: null` to clear it, so
+     * the name is derived from the prompt again. Returns the updated
+     * session.
+     *
+     * Workspace scope is resolved from `workspaceId` in the JSON body, or
+     * the workspace bound to the API key, so API-key callers may omit it.
+     *
+     * **Retries:** safe without an `Idempotency-Key`: the same patch converges on the same state.
+     *
+     * @param {Lusor.UpdateSessionInput} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.update({
+     *         id: "id"
+     *     })
+     */
+    update(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__update(request, requestOptions));
+    }
+    async __update(request, requestOptions) {
+        const { id, ..._body } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}`),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: 0,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/v1/sessions/{id}");
+    }
+    /**
+     * @param {Lusor.EventsSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.events({
+     *         id: "id"
+     *     })
+     */
+    events(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__events(request, requestOptions));
+    }
+    async __events(request, requestOptions) {
+        const { id, since } = request;
+        const _queryParams = {
+            since: since != null ? since : undefined,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/events`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/events");
+    }
+    /**
+     * The replay view's JSON breakdown: the session detail and its full event
+     * list as one `lusor.session.v1` document. Included only on App tiers with
+     * the detailed step breakdown (Hobby and above); other tiers get 403
+     * `detailed_breakdown_not_in_plan` and no session data. The same
+     * retention window as `GET /v1/sessions/{id}` and `/events` applies.
+     *
+     * @param {Lusor.BreakdownSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.breakdown({
+     *         id: "id"
+     *     })
+     */
+    breakdown(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__breakdown(request, requestOptions));
+    }
+    async __breakdown(request, requestOptions) {
+        const { id } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/breakdown`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Lusor.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Lusor.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/breakdown");
+    }
+    /**
+     * Server-side filtering over the workspace's session history, newest
+     * first. `deviceId` and `status` are exact single-value matches; the
+     * filter parameters (`statuses`, `statusMode`,
+     * `nameContains`, `deviceContains`, `createdBefore`, `createdAfter`)
+     * are applied server-side so the result stays correct across
+     * `limit`/`offset` pages.
+     *
+     * @param {Lusor.ListSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.list()
+     */
+    list(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
+    }
+    async __list(request = {}, requestOptions) {
+        const { workspaceId, deviceId, status, statuses, statusMode, nameContains, deviceContains, createdBefore, createdAfter, limit, offset, } = request;
+        const _queryParams = {
+            workspaceId,
+            deviceId,
+            status,
+            statuses,
+            statusMode: statusMode != null ? statusMode : undefined,
+            nameContains,
+            deviceContains,
+            createdBefore,
+            createdAfter,
+            limit,
+            offset,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, "v1/sessions"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions");
+    }
+    /**
+     * How long the workspace's plan keeps session history and recordings,
+     * with the server's clock. A session older than `cutoff` answers
+     * `403 upgrade_required` on its reads.
+     *
+     * @param {Lusor.HistoryPolicySessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.historyPolicy()
+     */
+    historyPolicy(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__historyPolicy(request, requestOptions));
+    }
+    async __historyPolicy(request = {}, requestOptions) {
+        const { workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, "v1/sessions/history-policy"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/history-policy");
+    }
+    /**
+     * @deprecated
+     *
+     * The original session shape, kept for older clients. Use
+     * `GET /v1/sessions/{id}`.
+     *
+     * @param {Lusor.GetLegacySessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.getLegacy({
+     *         id: "id"
+     *     })
+     */
+    getLegacy(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getLegacy(request, requestOptions));
+    }
+    async __getLegacy(request, requestOptions) {
+        const { id, workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/legacy`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/legacy");
+    }
+    /**
+     * @param {Lusor.StatusSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.status({
+     *         id: "id"
+     *     })
+     */
+    status(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__status(request, requestOptions));
+    }
+    async __status(request, requestOptions) {
+        const { id, workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/status`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/status");
+    }
+    /**
+     * @param {Lusor.ArtifactsSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.artifacts({
+     *         id: "id"
+     *     })
+     */
+    artifacts(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__artifacts(request, requestOptions));
+    }
+    async __artifacts(request, requestOptions) {
+        const { id, workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/artifacts`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/artifacts");
+    }
+    /**
+     * Idempotent cancel. Repeated calls after a successful cancel return
+     * `status: "noop"`.
+     *
+     * Workspace scope is resolved in this order (first non-empty wins):
+     * `workspaceId` in the JSON body, then `?workspaceId=`, then the
+     * workspace bound to the API key, so API-key callers may omit it.
+     *
+     * **Retries:** safe without an `Idempotency-Key`: a repeat converges on the same stopped state.
+     *
+     * @param {Lusor.StopSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.stop({
+     *         id: "id",
+     *         body: {}
+     *     })
+     */
+    stop(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__stop(request, requestOptions));
+    }
+    async __stop(request, requestOptions) {
+        const { id, workspaceId, body: _body } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/stop`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: 0,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/sessions/{id}/stop");
+    }
+    /**
+     * The UI tree the agent saw at one step of the run, as the JSON array
+     * of nodes it was captured as. `file` is the step index followed by
+     * `.json`, for example `0.json`. Content follows the workspace's
+     * history window: a state older than the window returns `404`.
+     *
+     * @param {Lusor.GetUiStateSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.getUiState({
+     *         id: "id",
+     *         file: "file"
+     *     })
+     */
+    getUiState(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getUiState(request, requestOptions));
+    }
+    async __getUiState(request, requestOptions) {
+        const { id, file, workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/ui-states/${core.url.encodePathParam(file)}`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Lusor.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/ui-states/{file}");
+    }
+    /**
+     * Removes a turn that is waiting behind a running one, before it
+     * starts. `invocationId` is the `invocationId` of the `202`
+     * `{ queued: true }` response of `POST /v1/sessions/{id}/continue` or
+     * `POST /v1/agents/{id}/turns`. Idempotent: cancelling an
+     * already-cancelled entry returns `alreadyCancelled: true`. An unknown
+     * `invocationId` returns `404`.
+     *
+     * Workspace scope is resolved from `?workspaceId=` or the workspace
+     * bound to the API key.
+     *
+     * **Retries:** safe without an `Idempotency-Key`: a repeat converges on the same cancelled state.
+     *
+     * @param {Lusor.CancelQueuedSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.cancelQueued({
+     *         id: "id",
+     *         invocationId: "invocationId"
+     *     })
+     */
+    cancelQueued(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__cancelQueued(request, requestOptions));
+    }
+    async __cancelQueued(request, requestOptions) {
+        const { id, invocationId, workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/queue/${core.url.encodePathParam(invocationId)}`),
+            method: "DELETE",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: 0,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/sessions/{id}/queue/{invocationId}");
+    }
+    /**
+     * Continues the session with a new prompt on the same transcript. The
+     * follow-up runs on the session's phone (for an agent's session, the
+     * phone the agent has now). If the session is still running, the
+     * follow-up is queued behind it (`queued: true`) and runs when the
+     * current run ends. Continuing a finished session is allowed.
+     *
+     * Send an `Idempotency-Key` header to make retries safe: the same key
+     * attaches to the original follow-up instead of sending a second one.
+     *
+     * Workspace scope: `workspaceId` in the body, otherwise the workspace
+     * bound to the API key.
+     *
+     * @param {Lusor.ContinueSessionInput} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.TooManyRequestsError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.continue({
+     *         id: "id",
+     *         prompt: "prompt"
+     *     })
+     */
+    continue(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__continue(request, requestOptions));
+    }
+    async __continue(request, requestOptions) {
+        const { id, "Idempotency-Key": idempotencyKey, ..._body } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, mergeOnlyDefinedHeaders({ "Idempotency-Key": idempotencyKey }), 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.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/continue`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: 0,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new Lusor.PaymentRequiredError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new Lusor.ConflictError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new Lusor.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/sessions/{id}/continue");
+    }
+    /**
+     * When the agent asks a question, the run pauses: the session's status
+     * becomes `awaiting_human` and its events include a `hitl_requested`
+     * event whose `data.correlation_id` identifies the question
+     * (`data.question`, and `data.options` when the agent offered
+     * answer labels). Post the answer here; the run resumes with your text
+     * as the reply. A question stays answerable until the session ends or
+     * a newer message supersedes it.
+     *
+     * Only plain questions can be answered here. A request for a secret
+     * (a `hitl_requested` event whose `data.kind` is `credential` or
+     * `2fa`) is answered only in the Lusor dashboard: any reply to it
+     * made with an API key returns `403` `secure_ask_dashboard_only` and
+     * stores nothing.
+     *
+     * A run created with an API key never reaches that state: when the
+     * agent asks for a secret, the run ends as `failed` with `error`
+     * `secret_required:<name>` (see `SessionV2.error`) instead of
+     * pausing, so there is nothing to answer. Save the secret in the
+     * workspace, then retry the run naming it in `secrets`.
+     *
+     * Retrying with the same text is idempotent (`idempotent: true`). A
+     * different answer to a question that was already answered returns
+     * `409`; the first answer stands.
+     *
+     * Workspace scope: `workspaceId` in the body, otherwise the workspace
+     * bound to the API key.
+     *
+     * **Retries:** safe without an `Idempotency-Key`: an answer is keyed by its `correlationId`, so a repeat is delivered once.
+     *
+     * @param {Lusor.AnswerHitlInput} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.GoneError}
+     * @throws {@link Lusor.TooManyRequestsError}
+     * @throws {@link Lusor.InternalServerError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.answer({
+     *         id: "id",
+     *         correlation_id: "correlation_id",
+     *         response: "response"
+     *     })
+     */
+    answer(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__answer(request, requestOptions));
+    }
+    async __answer(request, requestOptions) {
+        const { id, ..._body } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/hitl`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(_body, requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: 0,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Lusor.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new Lusor.PaymentRequiredError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Lusor.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new Lusor.ConflictError(_response.error.body, _response.rawResponse);
+                case 410:
+                    throw new Lusor.GoneError(_response.error.body, _response.rawResponse);
+                case 429:
+                    throw new Lusor.TooManyRequestsError(_response.error.body, _response.rawResponse);
+                case 500:
+                    throw new Lusor.InternalServerError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/sessions/{id}/hitl");
+    }
+    /**
+     * Returns signed URLs for the recording's MP4 segments, in order.
+     * URLs expire at each segment's `expires_at` (Unix seconds); fetch
+     * this endpoint again for fresh ones.
+     *
+     * `recording_status` is always present:
+     *
+     * - `absent`: the session has no recording.
+     * - `pending`: the recording is still being finalized. Poll again.
+     * - `complete`: finished. When `data` is present it is always
+     *   `complete`.
+     * - `failed`: finalization failed; `recording_status_reason` says
+     *   why.
+     *
+     * `data` is null until there is playable media. A recording follows
+     * the workspace's history window: past it, `402` with
+     * `reason: "history_window"`, unless the plan includes video replay
+     * or the recording was made on a paid Lusor Phone plan.
+     *
+     * @param {Lusor.RecordingSessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.recording({
+     *         id: "id"
+     *     })
+     */
+    recording(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recording(request, requestOptions));
+    }
+    async __recording(request, requestOptions) {
+        const { id, workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/recording`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new Lusor.PaymentRequiredError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Lusor.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/recording");
+    }
+    /**
+     * Each completed action paired with the screenshot taken after it, in
+     * time order, with a signed `frame_url` that expires at `expires_at`
+     * (Unix seconds, about five minutes). Frames still uploading are left
+     * out until they are ready. Past the workspace's history window this
+     * returns `402` with `reason: "history_window"`.
+     *
+     * @param {Lusor.ReplaySessionsRequest} request
+     * @param {SessionsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.sessions.replay({
+     *         id: "id"
+     *     })
+     */
+    replay(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__replay(request, requestOptions));
+    }
+    async __replay(request, requestOptions) {
+        const { id, workspaceId } = request;
+        const _queryParams = {
+            workspaceId,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/replay`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new Lusor.PaymentRequiredError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Lusor.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/replay");
+    }
+    /**
+     * The bytes of one replay screenshot, served by the API instead of a
+     * signed URL. `index` selects into the list `GET
+     * /v1/sessions/{id}/replay` returns, counting from 0.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     */
+    replayFrame(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__replayFrame(request, requestOptions));
+    }
+    async __replayFrame(request, requestOptions) {
+        const { id, workspaceId, index } = request;
+        const _queryParams = {
+            workspaceId,
+            index,
+        };
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        let _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.LusorEnvironment.Production, `v1/sessions/${core.url.encodePathParam(id)}/replay/frame`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .mergeAdditional(requestOptions?.queryParams)
+                .build(),
+            responseType: "binary-response",
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return { data: _response.body, rawResponse: _response.rawResponse };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Lusor.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 402:
+                    throw new Lusor.PaymentRequiredError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Lusor.NotFoundError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Lusor.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/sessions/{id}/replay/frame");
+    }
+}