@lusor/sdk 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,2576 @@
+// 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 { SessionsClient } from "../resources/sessions/client/Client.js";
+/**
+ * The phones in your workspace, and reads of their current screen and
+ * UI tree.
+ */
+export class DevicesClient {
+    _options;
+    _sessions;
+    constructor(options = {}) {
+        this._options = normalizeClientOptionsWithAuth(options);
+    }
+    get sessions() {
+        return (this._sessions ??= new SessionsClient(this._options));
+    }
+    /**
+     * Returns every phone in the API key's workspace, including offline
+     * ones. The same list as `GET /v1/workspaces/{workspaceId}/devices`,
+     * without needing the workspace id in the path.
+     *
+     * @param {Lusor.ListDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.list()
+     */
+    list(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
+    }
+    async __list(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/devices"),
+            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);
+                default:
+                    throw new errors.LusorError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/devices");
+    }
+    /**
+     * @param {Lusor.ListInWorkspaceDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.listInWorkspace({
+     *         workspaceId: "workspaceId"
+     *     })
+     */
+    listInWorkspace(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__listInWorkspace(request, requestOptions));
+    }
+    async __listInWorkspace(request, requestOptions) {
+        const { workspaceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices`),
+            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/workspaces/{workspaceId}/devices");
+    }
+    /**
+     * Quotes `quantity` more Lusor Phones (default 1) on the workspace's
+     * Phone plan, as one change: the
+     * prorated amount charged today for the rest of the current period,
+     * and the next full invoice. Nothing is charged. The quote expires
+     * after 10 minutes; confirm it with `POST /devices/deploy`.
+     *
+     * Phones are deployed into the tenant's Default workspace only; any
+     * other workspace answers 409 `default_workspace_only`.
+     *
+     * **Retries:** safe without an `Idempotency-Key`: a preview only quotes, it changes nothing.
+     *
+     * @param {Lusor.DeviceDeployPreviewInput} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.previewDeploy({
+     *         workspaceId: "workspaceId"
+     *     })
+     */
+    previewDeploy(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__previewDeploy(request, requestOptions));
+    }
+    async __previewDeploy(request, requestOptions) {
+        const { workspaceId, ..._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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/deploy/preview`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/deploy/preview");
+    }
+    /**
+     * Confirms a deploy quote: the Phone plan quantity rises by the quoted
+     * number of phones and the quoted amount is charged to the saved card
+     * now. If the payment does not go through, the quantity stays
+     * unchanged, `paymentPending` is true and no phone is deployed;
+     * complete the payment in billing management.
+     *
+     * Each new phone appears in `GET /devices` once the payment is
+     * confirmed (seconds), and is ready to use once it has deployed
+     * (minutes).
+     *
+     * **Retries:** safe without an `Idempotency-Key`: a confirmed `previewId` replays its stored receipt, so it never charges or deploys twice.
+     *
+     * @param {Lusor.DeployDevicesRequest} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.deploy({
+     *         workspaceId: "workspaceId",
+     *         body: {
+     *             previewId: "previewId"
+     *         }
+     *     })
+     */
+    deploy(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__deploy(request, requestOptions));
+    }
+    async __deploy(request, requestOptions) {
+        const { workspaceId, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/deploy`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/deploy");
+    }
+    /**
+     * Quotes removing this Lusor Phone from the Phone plan: the plan
+     * quantity falls by one and the unused rest of the current period is
+     * credited to the account balance (applied to the next invoice).
+     * Nothing changes yet. The quote expires after 10 minutes; confirm it
+     * with `POST /devices/{deviceId}/remove`.
+     *
+     * Refused with 409 `device_busy` while a session is running on the
+     * phone, and 409 `last_phone` for the plan's last phone (cancel the
+     * plan in billing management instead).
+     *
+     * **Retries:** safe without an `Idempotency-Key`: a preview only quotes, it changes nothing.
+     *
+     * @param {Lusor.PreviewRemoveDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.previewRemove({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {
+     *             "key": "value"
+     *         }
+     *     })
+     */
+    previewRemove(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__previewRemove(request, requestOptions));
+    }
+    async __previewRemove(request, requestOptions) {
+        const { workspaceId, deviceId, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/remove/preview`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/remove/preview");
+    }
+    /**
+     * Confirms a removal quote. This phone, and no other, stops accepting
+     * runs at once; the plan quantity falls by one, and the phone is then
+     * wiped and released. Its data cannot be recovered. A session started
+     * on it since the quote refuses the removal with 409 `device_busy`.
+     *
+     * **Retries:** safe without an `Idempotency-Key`: a confirmed `previewId` replays its stored receipt, so it never removes twice.
+     *
+     * @param {Lusor.RemoveDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.remove({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {
+     *             previewId: "previewId"
+     *         }
+     *     })
+     */
+    remove(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__remove(request, requestOptions));
+    }
+    async __remove(request, requestOptions) {
+        const { workspaceId, deviceId, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/remove`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/remove");
+    }
+    /**
+     * The GPS location and timezone the phone reports to apps. In `auto`
+     * mode both follow the phone's Internet exit IP and are re-applied
+     * after every IP change. In `override` mode they are the values set
+     * with `PUT /geo`, and `apply.state` says whether the phone has them
+     * yet (`pending`, `applied`, `held` while the phone restarts or
+     * resets, or `failed`).
+     *
+     * @param {Lusor.GetGeoDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.getGeo({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    getGeo(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getGeo(request, requestOptions));
+    }
+    async __getGeo(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/geo`),
+            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);
+                case 409:
+                    throw new Lusor.ConflictError(_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, "GET", "/v1/workspaces/{workspaceId}/devices/{deviceId}/geo");
+    }
+    /**
+     * Sets the GPS location and timezone the phone reports, replacing the
+     * automatic match to its Internet exit IP. The setting persists across
+     * restarts and IP changes until it is cleared with `DELETE /geo`, or
+     * until the phone is wiped (Wipe & reset) or removed. It can
+     * disagree with the exit IP's country or timezone; that is allowed.
+     *
+     * The change is stored at once and given to the phone in the
+     * background (usually within a minute); read `apply.state` with
+     * `GET /geo`. Allowed for an API key on its own workspace and for
+     * workspace admins and members.
+     *
+     * @param {Lusor.DeviceGeoInput} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link Lusor.GatewayTimeoutError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.setGeo({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         latitude: 1.1,
+     *         longitude: 1.1,
+     *         timezone: "timezone"
+     *     })
+     */
+    setGeo(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__setGeo(request, requestOptions));
+    }
+    async __setGeo(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/geo`),
+            method: "PUT",
+            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 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 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                case 504:
+                    throw new Lusor.GatewayTimeoutError(_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, "PUT", "/v1/workspaces/{workspaceId}/devices/{deviceId}/geo");
+    }
+    /**
+     * Clears a location set with `PUT /geo`. The phone's GPS location and
+     * timezone follow its Internet exit IP again and are re-applied now.
+     * Clearing when nothing is set changes nothing.
+     *
+     * @param {Lusor.ClearGeoDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link Lusor.GatewayTimeoutError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.clearGeo({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    clearGeo(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__clearGeo(request, requestOptions));
+    }
+    async __clearGeo(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/geo`),
+            method: "DELETE",
+            headers: _headers,
+            queryString: core.url.queryBuilder().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 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 409:
+                    throw new Lusor.ConflictError(_response.error.body, _response.rawResponse);
+                case 502:
+                    throw new Lusor.BadGatewayError(_response.error.body, _response.rawResponse);
+                case 504:
+                    throw new Lusor.GatewayTimeoutError(_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/workspaces/{workspaceId}/devices/{deviceId}/geo");
+    }
+    /**
+     * `active` is the run currently holding the phone (null when idle;
+     * `agentId` is null for a run started without an agent). `queue` lists
+     * agent turns waiting for the phone, oldest first. `assigned` lists the
+     * agents attached to the phone.
+     *
+     * @param {Lusor.OccupancyDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.occupancy({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    occupancy(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__occupancy(request, requestOptions));
+    }
+    async __occupancy(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/occupancy`),
+            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/workspaces/{workspaceId}/devices/{deviceId}/occupancy");
+    }
+    /**
+     * `rotating`: the countries a phone can be bought in or moved to on the
+     * residential route. `persistent`: the countries a static IP is sold in.
+     * ISO 3166-1 alpha-2 codes, lowercase. Any other country answers 400
+     * `unsupported_country` at purchase and on a location change.
+     *
+     * @param {Lusor.ListInternetLocationsRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.listInternetLocations({
+     *         workspaceId: "workspaceId"
+     *     })
+     */
+    listInternetLocations(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__listInternetLocations(request, requestOptions));
+    }
+    async __listInternetLocations(request, requestOptions) {
+        const { workspaceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/internet/locations`),
+            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/workspaces/{workspaceId}/internet/locations");
+    }
+    /**
+     * The country the phone's Internet traffic exits from, and whether the
+     * phone is on its static IP (`route: "static"`) or the shared
+     * residential route (`route: "residential"`). `applied` is `pending`
+     * until the phone's route is recorded.
+     *
+     * @param {Lusor.GetInternetLocationDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.getInternetLocation({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    getInternetLocation(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getInternetLocation(request, requestOptions));
+    }
+    async __getInternetLocation(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/internet-location`),
+            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);
+                case 409:
+                    throw new Lusor.ConflictError(_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/workspaces/{workspaceId}/devices/{deviceId}/internet-location");
+    }
+    /**
+     * Without `operation`, returns the phone's static IP state. With the
+     * `operation` id returned when a static IP was requested, returns that
+     * operation's outcome: `200` once it settled, `202` while it is still
+     * in progress (poll again).
+     *
+     * @param {Lusor.GetStaticIpDevicesRequest} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.getStaticIp({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    getStaticIp(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getStaticIp(request, requestOptions));
+    }
+    async __getStaticIp(request, requestOptions) {
+        const { workspaceId, deviceId, operation } = request;
+        const _queryParams = {
+            operation,
+        };
+        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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/static-ip`),
+            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 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 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/workspaces/{workspaceId}/devices/{deviceId}/static-ip");
+    }
+    /**
+     * The state of the phone's most recent wipe and reset: `idle` (none
+     * has run), `running`, `succeeded`, `refused` (it did not start; see
+     * `reason`), or `failed`.
+     *
+     * @param {Lusor.GetResetDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.getReset({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    getReset(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getReset(request, requestOptions));
+    }
+    async __getReset(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/reset`),
+            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);
+                case 409:
+                    throw new Lusor.ConflictError(_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, "GET", "/v1/workspaces/{workspaceId}/devices/{deviceId}/reset");
+    }
+    /**
+     * Captures the current UI tree and screen dimensions. The `a11yTree`
+     * field carries the formatted element tree (with 1-based interactive
+     * indices) used by `POST /tap { index }`.
+     *
+     * On a Lusor Phone, an API-key read meters phone minutes like any
+     * other direct action.
+     *
+     * @param {Lusor.StateDevicesRequest} request
+     * @param {DevicesClient.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.devices.state({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    state(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__state(request, requestOptions));
+    }
+    async __state(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/state`),
+            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 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/workspaces/{workspaceId}/devices/{deviceId}/state");
+    }
+    /**
+     * Triggers a fresh screenshot on the device and returns the resulting
+     * PNG bytes. Response is binary `image/png`.
+     *
+     * On a Lusor Phone, an API-key read meters phone minutes like any
+     * other direct action.
+     *
+     * @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}
+     */
+    screenshot(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__screenshot(request, requestOptions));
+    }
+    async __screenshot(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/screenshot`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().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/workspaces/{workspaceId}/devices/{deviceId}/screenshot");
+    }
+    /**
+     * Triggers a fresh screenshot on the device and returns
+     * the standard verb envelope. Pass `capture: true` (or
+     * `capture: { screenshot: true, ui: true }`) to receive the
+     * formatted element tree + `screenshot_url` in the same response.
+     *
+     * Unlike `GET /screenshot` (which returns binary PNG), this verb
+     * is the chain-compatible variant — the same shape as `tap`,
+     * `swipe`, etc. so it slots into a `POST /chain` step list.
+     *
+     * @param {Lusor.TakeScreenshotDevicesRequest} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.takeScreenshot({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {}
+     *     })
+     */
+    takeScreenshot(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__takeScreenshot(request, requestOptions));
+    }
+    async __takeScreenshot(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/screenshot`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/screenshot");
+    }
+    /**
+     * Tap an interactive element by `{ index }` (1-based, from
+     * `/state.a11yTree`) OR an explicit `{ x, y }` coordinate. Supplying
+     * both is accepted and `index` wins. At least one of the two forms is
+     * required: supplying neither is a 400, and `x` without `y` is also a
+     * 400 when no `index` is supplied (with `index`, any coordinates are
+     * accepted and ignored).
+     *
+     * Optionally include `capture: true | CaptureOptions` to
+     * return a fresh element tree + screen dimensions in the same
+     * round trip.
+     *
+     * @param {Lusor.TapInput} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.tap({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    tap(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__tap(request, requestOptions));
+    }
+    async __tap(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/tap`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/tap");
+    }
+    /**
+     * Optionally include `capture: true | CaptureOptions` to
+     * return a fresh element tree + screen dimensions in the same
+     * round trip.
+     *
+     * @param {Lusor.SwipeInput} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.swipe({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         startX: 1.1,
+     *         startY: 1.1,
+     *         endX: 1.1,
+     *         endY: 1.1
+     *     })
+     */
+    swipe(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__swipe(request, requestOptions));
+    }
+    async __swipe(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/swipe`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/swipe");
+    }
+    /**
+     * Optionally include `capture: true | CaptureOptions` to
+     * return a fresh element tree + screen dimensions in the same
+     * round trip.
+     *
+     * @param {Lusor.TypeTextInput} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.type({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         text: "text"
+     *     })
+     */
+    type(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__type(request, requestOptions));
+    }
+    async __type(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/type`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/type");
+    }
+    /**
+     * Send a single Android KeyEvent. Common codes: 66=Enter, 67=Del,
+     * 61=Tab, 111=Esc, 19/20/21/22=DPad.
+     *
+     * Optionally include `capture: true | CaptureOptions` to
+     * return a fresh element tree + screen dimensions in the same
+     * round trip.
+     *
+     * @param {Lusor.KeyInput} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.key({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         keyCode: 1
+     *     })
+     */
+    key(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__key(request, requestOptions));
+    }
+    async __key(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/key`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/key");
+    }
+    /**
+     * Accepts an optional `capture` field identical in shape to the
+     * parameterised verbs.
+     *
+     * @param {Lusor.ClearDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.clear({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {}
+     *     })
+     */
+    clear(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__clear(request, requestOptions));
+    }
+    async __clear(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/clear`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/clear");
+    }
+    /**
+     * Accepts an optional `capture` field.
+     *
+     * @param {Lusor.BackDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.back({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {}
+     *     })
+     */
+    back(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__back(request, requestOptions));
+    }
+    async __back(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/back`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/back");
+    }
+    /**
+     * Accepts an optional `capture` field.
+     *
+     * @param {Lusor.HomeDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.home({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {}
+     *     })
+     */
+    home(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__home(request, requestOptions));
+    }
+    async __home(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/home`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/home");
+    }
+    /**
+     * Accepts an optional `capture` field.
+     *
+     * @param {Lusor.RecentDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.recent({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {}
+     *     })
+     */
+    recent(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__recent(request, requestOptions));
+    }
+    async __recent(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/recent`),
+            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 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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/recent");
+    }
+    /**
+     * Launch an Android app by package name. The `package` and optional
+     * `activity` must be dotted identifiers (for example
+     * `com.android.settings`); anything else is a 400.
+     *
+     * Optionally include `capture: true | CaptureOptions` to
+     * return a fresh element tree + screen dimensions in the same
+     * round trip.
+     *
+     * @param {Lusor.StartAppInput} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.startApp({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         "package": "package"
+     *     })
+     */
+    startApp(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__startApp(request, requestOptions));
+    }
+    async __startApp(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/apps/start`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/apps/start");
+    }
+    /**
+     * Force-stop an Android app by package name. The `package` is
+     * validated the same way as `apps/start`.
+     *
+     * Optionally include `capture: true | CaptureOptions` to
+     * return a fresh element tree + screen dimensions in the same
+     * round trip.
+     *
+     * @param {Lusor.StopAppInput} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.stopApp({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         "package": "package"
+     *     })
+     */
+    stopApp(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__stopApp(request, requestOptions));
+    }
+    async __stopApp(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/apps/stop`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/apps/stop");
+    }
+    /**
+     * Execute a typed sequence of up to 20 deterministic actions in
+     * order, optionally collecting a UI capture per step. On a Lusor
+     * Phone, an API-key chain meters phone minutes before every step; a
+     * `402` or `503` stops the chain before that step reaches the phone.
+     *
+     * ## Capture resolution rules
+     *
+     * Per-step `capture` always wins. Top-level `capture` supplies
+     * the default policy:
+     *
+     *   - `'none'`  (default) — no capture on any step.
+     *   - `'each'`            — capture on every step.
+     *   - `'final'`           — capture only on the last step.
+     *
+     * ## Step verbs
+     *
+     * `tap`, `swipe`, `type`, `key`, `clear`, `back`, `home`, `recent`,
+     * `start_app`, `stop_app`, `screenshot`, `wait`. Each step has the
+     * same params as the corresponding direct-verb route plus an
+     * optional `capture` override.
+     *
+     * ## Settling
+     *
+     * Steps execute back-to-back with no implicit inter-step delay.
+     * Insert `wait` steps (`{ verb: "wait", params: { duration_ms: N } }`,
+     * 0–60000 ms) where the UI needs time to settle — e.g. after a tap
+     * that opens a screen, or before typing into a freshly focused
+     * field. Cumulative wait duration per chain is capped at 120s so
+     * the worst case stays inside the chain timeout.
+     *
+     * A step that completes with `ok: false` does not stop the chain:
+     * the next step still runs, the top-level `ok` is true only when every
+     * step succeeded, and each step's `ok` shows which one failed.
+     *
+     * A step that errors instead aborts the chain. This happens when the
+     * phone cannot be reached, when a step's capture fails, or when
+     * metering refuses a later step (`402`/`503`). The response is then
+     * that error alone, with no per-step results, and the steps before it
+     * have already run on the phone. Read the screen before you retry a
+     * chain.
+     *
+     * @param {Lusor.ChainRequest} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.chain({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         steps: [{
+     *                 verb: "tap",
+     *                 params: {}
+     *             }]
+     *     })
+     */
+    chain(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__chain(request, requestOptions));
+    }
+    async __chain(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/chain`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/chain");
+    }
+    /**
+     * Last-resort shell access. The command is checked against a
+     * server-side denylist (shell metacharacters such as `|`, `;`, `&`
+     * and backticks are refused anywhere in the string) and every
+     * attempt, allowed or denied, is audit-logged. The response reports
+     * whether the command ran; command output is not returned.
+     *
+     * @param {Lusor.ShellInput} request
+     * @param {DevicesClient.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.ServiceUnavailableError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.shell({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         command: "command"
+     *     })
+     */
+    shell(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__shell(request, requestOptions));
+    }
+    async __shell(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/shell`),
+            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 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, "POST", "/v1/workspaces/{workspaceId}/devices/{deviceId}/shell");
+    }
+    /**
+     * The language last set through `PUT .../language` and how applying
+     * it ended. `null` fields mean none has been set. `inProgress` names a
+     * change that is still being applied.
+     *
+     * @param {Lusor.GetLanguageDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.getLanguage({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    getLanguage(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getLanguage(request, requestOptions));
+    }
+    async __getLanguage(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/language`),
+            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);
+                case 409:
+                    throw new Lusor.ConflictError(_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, "GET", "/v1/workspaces/{workspaceId}/devices/{deviceId}/language");
+    }
+    /**
+     * Sets the phone's system language (and optional region). Answers 202
+     * at once with the change `pending`; read `GET .../language` until
+     * `state` is `applied` or `failed`. The phone may restart to apply it.
+     * Refused with 409 `phone_busy` while a session or live viewer holds
+     * the phone or another change is being applied.
+     *
+     * @param {Lusor.DeviceLanguageInput} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.setLanguage({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         language: "de"
+     *     })
+     */
+    setLanguage(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__setLanguage(request, requestOptions));
+    }
+    async __setLanguage(request, requestOptions) {
+        const { workspaceId, deviceId, "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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/language`),
+            method: "PUT",
+            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 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 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, "PUT", "/v1/workspaces/{workspaceId}/devices/{deviceId}/language");
+    }
+    /**
+     * The identity fields set so far (latest value of each) and how the
+     * last change ended. Fields never set keep the phone's own values and
+     * are absent here.
+     *
+     * @param {Lusor.GetIdentityDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.getIdentity({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    getIdentity(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getIdentity(request, requestOptions));
+    }
+    async __getIdentity(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/identity`),
+            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);
+                case 409:
+                    throw new Lusor.ConflictError(_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, "GET", "/v1/workspaces/{workspaceId}/devices/{deviceId}/identity");
+    }
+    /**
+     * Sets the device identity apps read: brand, manufacturer, model,
+     * device codename, product name, build fingerprint and Android ID.
+     * Only the fields sent change. Raw Android properties are refused
+     * (400 `identity_prop_refused`). Answers 202 with the change
+     * `pending`; once written (`state` `applied`, `restartQueued` true)
+     * **the phone restarts** to apply it, which takes a few minutes. The
+     * values persist across restarts and resets; set the old values again
+     * to undo a change.
+     *
+     * @param {Lusor.SetIdentityDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.BadRequestError}
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.setIdentity({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId",
+     *         body: {}
+     *     })
+     */
+    setIdentity(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__setIdentity(request, requestOptions));
+    }
+    async __setIdentity(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey, body: _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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/identity`),
+            method: "PUT",
+            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 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 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, "PUT", "/v1/workspaces/{workspaceId}/devices/{deviceId}/identity");
+    }
+    /**
+     * How the last advertising-ID reset ended. The ID itself is not returned.
+     *
+     * @param {Lusor.GetAdvertisingIdDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.getAdvertisingId({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    getAdvertisingId(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getAdvertisingId(request, requestOptions));
+    }
+    async __getAdvertisingId(request, requestOptions) {
+        const { workspaceId, deviceId } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/advertising-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);
+                case 409:
+                    throw new Lusor.ConflictError(_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, "GET", "/v1/workspaces/{workspaceId}/devices/{deviceId}/advertising-id");
+    }
+    /**
+     * Gives the phone a new Google advertising ID. **Irreversible**: the
+     * previous ID cannot be restored. Answers 202 with the reset
+     * `pending`; read `GET .../advertising-id` until it is `applied` or
+     * `failed`.
+     *
+     * @param {Lusor.ResetAdvertisingIdDevicesRequest} request
+     * @param {DevicesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Lusor.UnauthorizedError}
+     * @throws {@link Lusor.PaymentRequiredError}
+     * @throws {@link Lusor.ForbiddenError}
+     * @throws {@link Lusor.NotFoundError}
+     * @throws {@link Lusor.ConflictError}
+     * @throws {@link Lusor.BadGatewayError}
+     * @throws {@link errors.LusorError}
+     * @throws {@link errors.LusorTimeoutError}
+     *
+     * @example
+     *     await client.devices.resetAdvertisingId({
+     *         workspaceId: "workspaceId",
+     *         deviceId: "deviceId"
+     *     })
+     */
+    resetAdvertisingId(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__resetAdvertisingId(request, requestOptions));
+    }
+    async __resetAdvertisingId(request, requestOptions) {
+        const { workspaceId, deviceId, "Idempotency-Key": idempotencyKey } = 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/workspaces/${core.url.encodePathParam(workspaceId)}/devices/${core.url.encodePathParam(deviceId)}/advertising-id/reset`),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().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 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 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/workspaces/{workspaceId}/devices/{deviceId}/advertising-id/reset");
+    }
+}