@lusor/sdk 0.0.0-stage → 1.0.0

package/dist/api/resources/devices/client/Client.d.ts

@@ -0,0 +1,979 @@
+import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js";
+import { type NormalizedClientOptionsWithAuth } from "../../../../BaseClient.js";
+import * as core from "../../../../core/index.js";
+import * as Lusor from "../../../index.js";
+import { SessionsClient } from "../resources/sessions/client/Client.js";
+export declare namespace DevicesClient {
+    type Options = BaseClientOptions;
+    interface RequestOptions extends BaseRequestOptions {
+    }
+}
+/**
+ * The phones in your workspace, and reads of their current screen and
+ * UI tree.
+ */
+export declare class DevicesClient {
+    protected readonly _options: NormalizedClientOptionsWithAuth<DevicesClient.Options>;
+    protected _sessions: SessionsClient | undefined;
+    constructor(options?: DevicesClient.Options);
+    get sessions(): SessionsClient;
+    /**
+     * 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?: Lusor.ListDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.ListDevicesResponse>;
+    private __list;
+    /**
+     * @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: Lusor.ListInWorkspaceDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.ListInWorkspaceDevicesResponse>;
+    private __listInWorkspace;
+    /**
+     * 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: Lusor.DeviceDeployPreviewInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.PreviewDeployDevicesResponse>;
+    private __previewDeploy;
+    /**
+     * 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: Lusor.DeployDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.DeployDevicesResponse>;
+    private __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: Lusor.PreviewRemoveDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.PreviewRemoveDevicesResponse>;
+    private __previewRemove;
+    /**
+     * 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: Lusor.RemoveDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.RemoveDevicesResponse>;
+    private __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: Lusor.GetGeoDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.GetGeoDevicesResponse>;
+    private __getGeo;
+    /**
+     * 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: Lusor.DeviceGeoInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.SetGeoDevicesResponse>;
+    private __setGeo;
+    /**
+     * 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: Lusor.ClearGeoDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.ClearGeoDevicesResponse>;
+    private __clearGeo;
+    /**
+     * `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: Lusor.OccupancyDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.OccupancyDevicesResponse>;
+    private __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: Lusor.ListInternetLocationsRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.ListInternetLocationsResponse>;
+    private __listInternetLocations;
+    /**
+     * 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: Lusor.GetInternetLocationDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.GetInternetLocationDevicesResponse>;
+    private __getInternetLocation;
+    /**
+     * 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: Lusor.GetStaticIpDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.GetStaticIpDevicesResponse>;
+    private __getStaticIp;
+    /**
+     * 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: Lusor.GetResetDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.GetResetDevicesResponse>;
+    private __getReset;
+    /**
+     * 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: Lusor.StateDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.DeviceState>;
+    private __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: Lusor.ScreenshotDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<core.BinaryResponse>;
+    private __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: Lusor.TakeScreenshotDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __takeScreenshot;
+    /**
+     * 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: Lusor.TapInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.TapResult>;
+    private __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: Lusor.SwipeInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __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: Lusor.TypeTextInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __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: Lusor.KeyInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __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: Lusor.ClearDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __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: Lusor.BackDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __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: Lusor.HomeDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __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: Lusor.RecentDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __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: Lusor.StartAppInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __startApp;
+    /**
+     * 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: Lusor.StopAppInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.VerbResultWithOptionalCapture>;
+    private __stopApp;
+    /**
+     * 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: Lusor.ChainRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.ChainResponse>;
+    private __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: Lusor.ShellInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.ShellResult>;
+    private __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: Lusor.GetLanguageDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.GetLanguageDevicesResponse>;
+    private __getLanguage;
+    /**
+     * 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: Lusor.DeviceLanguageInput, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.SetLanguageDevicesResponse>;
+    private __setLanguage;
+    /**
+     * 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: Lusor.GetIdentityDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.GetIdentityDevicesResponse>;
+    private __getIdentity;
+    /**
+     * 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: Lusor.SetIdentityDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.SetIdentityDevicesResponse>;
+    private __setIdentity;
+    /**
+     * 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: Lusor.GetAdvertisingIdDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.GetAdvertisingIdDevicesResponse>;
+    private __getAdvertisingId;
+    /**
+     * 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: Lusor.ResetAdvertisingIdDevicesRequest, requestOptions?: DevicesClient.RequestOptions): core.HttpResponsePromise<Lusor.ResetAdvertisingIdDevicesResponse>;
+    private __resetAdvertisingId;
+}