@omirion/orbit-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3714 @@
+type ClientOptions$1 = {
+    baseUrl: 'https://orbit.omirion.com' | (string & {});
+};
+/**
+ * A single error. `code` is a stable machine-readable identifier.
+ */
+type ErrorItem = {
+    code?: string;
+    message: string;
+    field?: string | null;
+};
+/**
+ * Standard error envelope. `code` values are stable within `/api/v1`.
+ */
+type ErrorResponse = {
+    errors: Array<ErrorItem>;
+};
+/**
+ * Cursor-pagination metadata. Pass `nextCursor` back as `?cursor=` to page.
+ */
+type PageMeta = {
+    hasMore: boolean;
+    nextCursor: string | null;
+};
+/**
+ * The user the token was minted by, and acts as.
+ */
+type IdentityUser = {
+    id: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    role: 'admin' | 'user';
+    organizationId: string;
+};
+/**
+ * The presented token. `abilities` is the ceiling on this credential. It never widens with the user’s role, so an admin may hold a read-only token.
+ */
+type IdentityToken = {
+    /**
+     * Token identifier. The secret is never returned.
+     */
+    id: string;
+    name: string | null;
+    /**
+     * Functional grants. Project scope is reported separately.
+     */
+    abilities: Array<'api:projects:read' | 'api:projects:manage' | 'api:devices:read' | 'api:devices:manage' | 'api:telemetry:read' | 'api:firmware:read' | 'api:firmware:write' | 'api:command:exec' | 'api:webhooks:read' | 'api:webhooks:manage' | 'api:device-types:manage' | 'api:admissions:read' | 'api:admissions:manage' | 'api:usb:attach' | 'api:terminal:open'>;
+    /**
+     * Project ids this token is restricted to. `null` means every project the user can reach (an absent restriction, not an empty one).
+     */
+    projectScope: Array<string> | null;
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+};
+/**
+ * A project reachable with this user and token scope.
+ */
+type IdentityProject = {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+};
+/**
+ * Who this token authenticates as, what it may do, and which projects it reaches. `projects` is the effective set (the user’s organisation access intersected with the token’s project scope), so it is the list of ids every other endpoint accepts.
+ */
+type Identity = {
+    user: IdentityUser;
+    token: IdentityToken;
+    projects: Array<IdentityProject>;
+};
+/**
+ * A project as a resource. Richer than `IdentityProject`, which `/api/v1/me` returns under no ability and which stays limited to what a caller needs to address other endpoints.
+ */
+type Project = {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+    /**
+     * Whether a provisioning (app) token is set, so devices can enrol. The token itself is never returned.
+     */
+    hasAppToken: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * A device type: the model a device identifies as, and the contract for what it reports and what it can be told to do. Project-scoped (#47).
+ */
+type DeviceType = {
+    id: string;
+    projectId: string;
+    organizationId: string;
+    /**
+     * Stable identifier the device presents when it identifies. Immutable once set.
+     */
+    slug: string;
+    name: string;
+    description: string | null;
+    version: string;
+    manifest: TelemetryManifest;
+    /**
+     * Telegraf collection profile for gateway-class types. Null for MCU-class types, which report through the device agent rather than a collector.
+     */
+    collectionProfile: {
+        [key: string]: unknown;
+    } | null;
+    commandManifest: CommandManifest | null;
+    /**
+     * Which USB peripherals a device of this type may export over USB/IP. Declaring one grants nothing on its own: attaching still requires `api:usb:attach`.
+     */
+    usbManifest: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Raw nanopb `.options` file text for this device type’s firmware build, uploaded as-is. Declares the wire-size limits (`max_size`, `max_count`) the compiled firmware actually has room for; the server truncates downlink fields (e.g. a firmware rollback `reason`) to fit rather than sending something the device fails to decode. Null: unconstrained, same as before this existed.
+     */
+    protocolOptions: string | null;
+    offlineAfterSeconds: number | null;
+    dispatchProfile: string;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * Compact device type for list responses: manifest **counts** instead of the manifests, so a page stays small. Read one type for the full contract.
+ */
+type DeviceTypeListItem = {
+    id: string;
+    projectId: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    version: string;
+    metricsCount: number;
+    groupsCount: number;
+    commandsCount: number;
+    hasProtocolOptions: boolean;
+    dispatchProfile: string;
+    createdAt: string;
+};
+/**
+ * A page of device types with cursor-pagination metadata.
+ */
+type DeviceTypeListPage = {
+    data: Array<DeviceTypeListItem>;
+    meta: PageMeta;
+};
+/**
+ * A new device type. The owning project comes from the path, not this body.
+ */
+type DeviceTypeCreateRequest = {
+    /**
+     * Lowercase identifier the device presents when it identifies.
+     */
+    slug: string;
+    name: string;
+    description?: string;
+    /**
+     * Defaults to `1.0.0`.
+     */
+    version?: string;
+    manifest: TelemetryManifest;
+    collectionProfile?: {
+        [key: string]: unknown;
+    } | null;
+    commandManifest?: CommandManifest | null;
+    usbManifest?: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Raw nanopb `.options` file text, see the `DeviceType` schema.
+     */
+    protocolOptions?: string | null;
+    offlineAfterSeconds?: number | null;
+    dispatchProfile?: string;
+};
+/**
+ * Partial update: only the fields sent change. `slug` is absent by design, being the identifier. A manifest sent here replaces the stored one wholesale.
+ */
+type DeviceTypeUpdateRequest = {
+    name?: string;
+    description?: string | null;
+    version?: string;
+    manifest?: TelemetryManifest;
+    collectionProfile?: {
+        [key: string]: unknown;
+    } | null;
+    commandManifest?: CommandManifest | null;
+    usbManifest?: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Raw nanopb `.options` file text, see the `DeviceType` schema.
+     */
+    protocolOptions?: string | null;
+    offlineAfterSeconds?: number | null;
+    dispatchProfile?: string;
+};
+/**
+ * A newly minted provisioning (app) token. `token` is the plaintext value, returned exactly once: the server keeps only its sha256, so a lost token can be replaced but never recovered.
+ */
+type ProjectAppToken = {
+    project: Project;
+    /**
+     * The plaintext `omr_prj_…` token. Present only in this response, never in any later read of the project.
+     */
+    token: string;
+    /**
+     * First 16 characters, safe to log or display so an operator can tell two tokens apart without holding either.
+     */
+    tokenPrefix: string;
+};
+/**
+ * A page of projects with cursor-pagination metadata.
+ */
+type ProjectListPage = {
+    data: Array<Project>;
+    meta: PageMeta;
+};
+/**
+ * Compact device representation used in list responses.
+ */
+type DeviceListItem = {
+    id: string;
+    /**
+     * Owning project. Resolves the fleet a device belongs to without a walk.
+     */
+    projectId: string;
+    name: string;
+    /**
+     * Hardware identity (e.g. a modem IMEI) integrators key their records on.
+     */
+    fingerprint: string | null;
+    isOnline: boolean;
+    lastSeenAt: string | null;
+    deviceTypeSlug: string | null;
+    createdAt: string;
+};
+/**
+ * Full device detail.
+ */
+type Device = {
+    id: string;
+    /**
+     * Owning project. Resolves the fleet a device belongs to without a walk.
+     */
+    projectId: string;
+    name: string;
+    /**
+     * Hardware identity (e.g. a modem IMEI) integrators key their records on.
+     */
+    fingerprint: string | null;
+    isOnline: boolean;
+    lastSeenAt: string | null;
+    deviceTypeName: string | null;
+    deviceTypeSlug: string | null;
+    firmwareVersion: string | null;
+    agentVersion: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * A page of devices with cursor-pagination metadata.
+ */
+type DeviceListPage = {
+    data: Array<DeviceListItem>;
+    meta: PageMeta;
+};
+/**
+ * A freshly rotated device token. Shown once. Persist it and load it onto the device (or let the device re-admit with its fingerprint to receive it automatically). The previous token is invalidated.
+ */
+type DeviceTokenReset = {
+    deviceId: string;
+    /**
+     * The new plaintext token (prefixed `omr_`). Not retrievable again.
+     */
+    deviceToken: string;
+};
+/**
+ * A device admission (fleet-join) request. `status` is `pending` until reviewed; accepting it provisions a device and sets `deviceId`.
+ */
+type Admission = {
+    id: string;
+    projectId: string;
+    /**
+     * Hardware identity the requesting unit presented (e.g. a modem IMEI).
+     */
+    fingerprint: string;
+    hostname: string | null;
+    /**
+     * Free-form attributes the agent attached to the request.
+     */
+    metadata: {
+        [key: string]: unknown;
+    } | null;
+    status: 'pending' | 'accepted' | 'rejected' | 'dismissed';
+    /**
+     * The device provisioned when the request was accepted; null otherwise.
+     */
+    deviceId: string | null;
+    reviewedBy: string | null;
+    reviewedAt: string | null;
+    createdAt: string;
+    updatedAt: string | null;
+};
+/**
+ * A page of admission requests with cursor-pagination metadata.
+ */
+type AdmissionListPage = {
+    data: Array<Admission>;
+    meta: PageMeta;
+};
+/**
+ * Provisioning details for the device created when the admission is accepted.
+ */
+type AdmissionAcceptRequest = {
+    /**
+     * Human-readable name for the new device.
+     */
+    deviceName: string;
+    /**
+     * Device-type to classify the device (must be in the project). Required. Pass the type resolved from the device’s declared model, or another to override it.
+     */
+    deviceTypeId: string;
+};
+/**
+ * The reviewed admission and the device it provisioned.
+ */
+type AdmissionAcceptResponse = {
+    admission: Admission;
+    device: Device;
+};
+/**
+ * A telemetry sample. `metrics` is an open map keyed by the device-type manifest metric `key` (snake_case); resolve labels/units/types via the manifest endpoint. Values are already expressed in the metric's declared unit. A manifest `scale` has been applied on the way out, so never multiply by it again.
+ */
+type TelemetrySample = {
+    metrics: {
+        [key: string]: number | boolean | string;
+    };
+    recordedAt: string;
+};
+/**
+ * Time-ordered (ascending) telemetry samples for a window.
+ */
+type TelemetryHistory = {
+    data: Array<TelemetrySample>;
+};
+/**
+ * Definition of a single metric a device type can report.
+ */
+type MetricDefinition = {
+    id: number;
+    key: string;
+    label: string;
+    type: 'float' | 'int' | 'uint' | 'bool' | 'string';
+    deviceClass: string;
+    stateClass: 'measurement' | 'total' | 'total_increasing';
+    unit?: string;
+    min?: number;
+    max?: number;
+    /**
+     * Multiplier the device's raw integer reading was decoded with (`value = raw × scale`), for devices that keep floats off the wire. Already applied to the values returned by the telemetry endpoints; it is documentation, not an instruction to multiply again. Defaults to 1.
+     */
+    scale?: number;
+    /**
+     * Decimal places to round to for display. Does not scale the value.
+     */
+    precision?: number;
+    optional?: boolean;
+    group: string;
+};
+/**
+ * UI grouping metadata for metrics.
+ */
+type MetricGroup = {
+    key: string;
+    label: string;
+    icon: string;
+};
+/**
+ * Metric manifest for a device type (what each metric key means).
+ */
+type TelemetryManifest = {
+    version: string;
+    metrics: Array<MetricDefinition>;
+    groups: Array<MetricGroup>;
+};
+/**
+ * A stored firmware bundle (RAUC or MCUboot).
+ */
+type FirmwareBundle = {
+    id: string;
+    projectId: string;
+    /**
+     * Image kind: `rauc` (Linux A/B .raucb) or `mcuboot` (signed MCU image).
+     */
+    kind: 'rauc' | 'mcuboot';
+    version: string;
+    /**
+     * Target compatibility key, i.e. the RAUC `compatible` string for `rauc` bundles, a board/device-type identifier for `mcuboot`.
+     */
+    compatible: string;
+    filename: string;
+    sizeBytes: number;
+    sha256: string;
+    description: string | null;
+    uploadedBy: string;
+    createdAt: string;
+};
+/**
+ * A page of firmware bundles with cursor-pagination metadata.
+ */
+type FirmwareBundleListPage = {
+    data: Array<FirmwareBundle>;
+    meta: PageMeta;
+};
+type FirmwareUploadResponse = {
+    bundle: FirmwareBundle;
+};
+/**
+ * A firmware rollout to a single device. `status` walks `pending → downloading → installing → succeeded` (or `failed` / `canceled` / `rolled_back`); `phase`, `progressPercent`, `message` and `error` reflect the latest agent report.
+ */
+type FirmwareDeployment = {
+    id: string;
+    bundleId: string;
+    deviceId: string;
+    status: 'pending' | 'downloading' | 'installing' | 'succeeded' | 'failed' | 'canceled' | 'rolled_back';
+    phase: string | null;
+    progressPercent: number;
+    message: string | null;
+    error: string | null;
+    /**
+     * The slot the device reported booting into after install.
+     */
+    bootedSlot: string | null;
+    installedVersion: string | null;
+    triggeredBy: string | null;
+    dispatchedAt: string | null;
+    finishedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * A page of firmware deployments with cursor-pagination metadata.
+ */
+type FirmwareDeploymentListPage = {
+    data: Array<FirmwareDeployment>;
+    meta: PageMeta;
+};
+/**
+ * The bundle to roll out and the devices to target.
+ */
+type FirmwareDeploymentTriggerRequest = {
+    bundleId: string;
+    /**
+     * Devices to upgrade. All must belong to the bundle’s project.
+     */
+    deviceIds: Array<string>;
+};
+/**
+ * Cancellation intent. The body is optional: with no `force`, only a `pending` deployment cancels.
+ */
+type FirmwareDeploymentCancelRequest = {
+    /**
+     * Abort a deployment already in flight (`downloading` / `installing`). Required for those states, because the device may be partway through an install; the server records who forced it in the deployment’s `error` and `message`.
+     */
+    force?: boolean;
+};
+/**
+ * Rollback intent. The body is optional: omit `reason` for a generic operator-issued message.
+ */
+type FirmwareDeploymentRollbackRequest = {
+    /**
+     * Free text recorded on the rollback row and echoed to the device.
+     */
+    reason?: string;
+};
+/**
+ * The deployments created by the trigger, one per targeted device.
+ */
+type FirmwareDeploymentTriggerResponse = {
+    deployments: Array<FirmwareDeployment>;
+};
+/**
+ * Outcome of a dispatch. `queued` says which of the two it is, and is the field to branch on: `false` (HTTP 200, interactive device) means the device ran the command and the result fields below are populated; `true` (HTTP 202, queued device) means it was accepted for store-and-forward delivery and no result exists yet, so poll `GET /api/v1/devices/{id}/commands/{invocationId}` until `status` is terminal.
+ */
+type CommandResult = {
+    invocationId: string;
+    /**
+     * Lifecycle status at the moment the call returned. Non-terminal (keep polling): `queued`, `sent`, `delivered`. Terminal: `completed`, `failed`, `expired`, `timeout`, `error`.
+     */
+    status: 'queued' | 'sent' | 'delivered' | 'completed' | 'failed' | 'expired' | 'timeout' | 'error';
+    /**
+     * True when accepted for asynchronous delivery, so the result fields are absent.
+     */
+    queued: boolean;
+    /**
+     * Synchronous result only; absent when `queued` is true.
+     */
+    success?: boolean;
+    /**
+     * Device-defined exit/status code; 0 when successful. Synchronous result only.
+     */
+    exitCode?: number;
+    /**
+     * Captured output / structured payload (device-defined). Synchronous result only.
+     */
+    output?: string;
+    /**
+     * Error detail; empty when successful. Synchronous result only.
+     */
+    error?: string;
+    /**
+     * Synchronous result only.
+     */
+    durationMs?: number;
+};
+/**
+ * Durable record of a command invocation. Its delivery/execution lifecycle `status` and, once terminal, its result. Poll this (`GET /api/v1/devices/{id}/commands/{invocationId}`) after a queued (202) dispatch to retrieve the eventual outcome; it is the pull counterpart to the `command.result` webhook.
+ */
+type CommandInvocation = {
+    invocationId: string;
+    deviceId: string;
+    /**
+     * Declared command name that was invoked.
+     */
+    command: string;
+    /**
+     * Lifecycle status. Non-terminal (keep polling): `queued`, `sent`, `delivered`. Terminal: `completed`, `failed`, `expired`, `timeout`, `error`.
+     */
+    status: 'queued' | 'sent' | 'delivered' | 'completed' | 'failed' | 'expired' | 'timeout' | 'error';
+    /**
+     * `true` when the device reported success, `false` on any terminal failure, `null` while still pending (no result recorded yet).
+     */
+    success: boolean | null;
+    /**
+     * Device-defined exit/status code; null until a result is recorded.
+     */
+    exitCode: number | null;
+    /**
+     * Captured output excerpt (up to 4 KiB); null until a result is recorded.
+     */
+    output: string | null;
+    /**
+     * Error detail; null when successful or still pending.
+     */
+    error: string | null;
+    durationMs: number | null;
+    /**
+     * Number of delivery attempts made for this invocation.
+     */
+    attempts: number;
+    createdAt: string;
+    sentAt: string | null;
+    deliveredAt: string | null;
+};
+/**
+ * Declared command to run on a device, dispatched over the MQTT data plane as a protobuf CommandRequest frame.
+ */
+type CommandRequest = {
+    /**
+     * Declared command name for the device type (e.g. `lock`, `unlock`, `state-request`).
+     */
+    name: string;
+    /**
+     * Typed key/value arguments (max 64 entries). Values may be strings, numbers, or booleans. Keep payloads small: MCU-class modems cap MQTT publishes around 4 KiB.
+     */
+    args?: {
+        [key: string]: string | number | boolean;
+    };
+    /**
+     * Device-side hard deadline in milliseconds; the invocation is failed if no result arrives in time.
+     */
+    timeoutMs?: number;
+};
+/**
+ * Declared argument of a command: key, expected type (aligned with the protobuf `CommandArg` value types), and whether it is required.
+ */
+type CommandArgDefinition = {
+    key: string;
+    type: 'string' | 'int' | 'float' | 'bool';
+    required: boolean;
+    description?: string;
+};
+/**
+ * A command a device type declares. `allowExtraArgs` permits arg keys beyond the declared ones (values are still scalar-typed by the request validator).
+ */
+type CommandDefinition = {
+    name: string;
+    description?: string;
+    args: Array<CommandArgDefinition>;
+    allowExtraArgs?: boolean;
+};
+/**
+ * Command manifest for a device type, i.e. the declared command contract that `POST /api/v1/devices/{id}/command` validates against before publishing. The command-plane sibling of the telemetry metric manifest.
+ */
+type CommandManifest = {
+    version: string;
+    commands: Array<CommandDefinition>;
+};
+/**
+ * Multipart form for a firmware bundle upload.
+ */
+type FirmwareUploadRequest = {
+    /**
+     * The bundle file (≤ 512 MB): `.raucb` for `kind=rauc`, `.bin` for `kind=mcuboot`.
+     */
+    file: Blob | File;
+    /**
+     * Target project. Must be in this token's effective scope.
+     */
+    projectId: string;
+    /**
+     * Bundle kind. Omit for the default RAUC flow. A `rauc` file with no `manifest.raucm`, or a `mcuboot` file with a bad header magic, is rejected with 422.
+     */
+    kind?: 'rauc' | 'mcuboot';
+    /**
+     * Bundle version, e.g. `0.10.0`. Decoded from the binary for `rauc` (manifest) and `mcuboot` (image header) and ignored if sent.
+     */
+    version?: string;
+    /**
+     * Hardware target. Decoded from the RAUC manifest for `rauc` (ignored if sent); required for `mcuboot` as a board/device-type id (e.g. `gtm-sgc-nrf52`).
+     */
+    compatible?: string;
+    /**
+     * Optional notes (truncated to 2000 chars).
+     */
+    description?: string | null;
+};
+/**
+ * Conflict body for a duplicate bundle (distinct from the standard error envelope).
+ */
+type FirmwareConflictResponse = {
+    error: string;
+    message: string;
+};
+/**
+ * Event types deliverable to a webhook subscription.
+ */
+type WebhookEventType = 'device.online' | 'device.offline' | 'telemetry.metric_changed' | 'command.result' | 'deployment.status_changed' | 'admission.requested';
+/**
+ * How failed deliveries are retried. `null` (or omitted on create) uses the default capped-exponential backoff (~10s / 1m / 5m / 30m / 2h, 6 attempts total).
+ *
+ * - `none` delivers once; dead-letters on the first failure.
+ * - `fixed` retries up to `maxAttempts` times (2–10), waiting `intervalMs` each time.
+ * - `backoff` retries along the explicit `delaysMs` ladder (1–9 entries); omit `delaysMs` for the default ladder. `maxAttempts` = ladder length + 1.
+ */
+type WebhookRetryPolicy = {
+    mode: 'none' | 'fixed' | 'backoff';
+    /**
+     * Total attempts incl. the first. Required and used only when `mode` is `fixed`.
+     */
+    maxAttempts?: number;
+    /**
+     * Delay between attempts. Required and used only when `mode` is `fixed`.
+     */
+    intervalMs?: number;
+    /**
+     * Explicit backoff ladder. Used only when `mode` is `backoff`.
+     */
+    delaysMs?: Array<number>;
+} | null;
+/**
+ * An outbound webhook subscription. The HMAC signing secret is not readable after creation. `consecutiveFailures` counts dead-lettered deliveries in a row; the subscription is auto-disabled after 20 and re-enabling resets the counter. `retryPolicy` is `null` when the default backoff applies.
+ */
+type WebhookSubscription = {
+    id: string;
+    projectId: string;
+    url: string;
+    enabled: boolean;
+    eventTypes: Array<WebhookEventType>;
+    retryPolicy: WebhookRetryPolicy;
+    consecutiveFailures: number;
+    createdAt: string;
+    updatedAt: string;
+};
+/**
+ * One page of webhook subscriptions.
+ */
+type WebhookSubscriptionPage = {
+    data: Array<WebhookSubscription>;
+    meta: PageMeta;
+};
+/**
+ * Subscription to create. `url` must be https in production and must not target a private/internal address.
+ */
+type WebhookCreateRequest = {
+    /**
+     * Project whose device events to deliver. Must be in this token's scope.
+     */
+    projectId: string;
+    url: string;
+    eventTypes: Array<WebhookEventType>;
+    retryPolicy?: WebhookRetryPolicy;
+};
+type WebhookCreateResponse = WebhookSubscription & {
+    /**
+     * HMAC-SHA256 signing secret (`whsec_…`). Shown only here.
+     */
+    secret: string;
+};
+/**
+ * Fields to update on a subscription. All optional.
+ */
+type WebhookUpdateRequest = {
+    url?: string;
+    eventTypes?: Array<WebhookEventType>;
+    /**
+     * Re-enabling resets the consecutive-failure counter.
+     */
+    enabled?: boolean;
+    retryPolicy?: WebhookRetryPolicy;
+};
+/**
+ * One recorded POST attempt within a delivery. Attempts are append-only and never overwritten, so the full failure timeline is preserved. `attemptNo` is 1-indexed and matches the delivery’s attempt count at the time.
+ */
+type WebhookDeliveryAttempt = {
+    id: string;
+    attemptNo: number;
+    statusCode: number | null;
+    error: string | null;
+    attemptedAt: string;
+};
+/**
+ * One delivery of an event to a subscription. `eventId` is the idempotency key shared across subscriptions for the same event; `id` is sent to the receiver as the `X-Orbit-Delivery` header. `lastStatusCode` / `lastError` summarise the most recent attempt; `attempts` is the full per-attempt timeline (oldest first).
+ */
+type WebhookDelivery = {
+    id: string;
+    subscriptionId: string;
+    eventId: string;
+    eventType: WebhookEventType;
+    status: 'pending' | 'delivered' | 'failed';
+    attemptCount: number;
+    retryPolicy: WebhookRetryPolicy;
+    lastStatusCode: number | null;
+    lastError: string | null;
+    nextAttemptAt: string | null;
+    deliveredAt: string | null;
+    createdAt: string;
+    attempts: Array<WebhookDeliveryAttempt>;
+};
+/**
+ * One page of the delivery log (newest first).
+ */
+type WebhookDeliveryPage = {
+    data: Array<WebhookDelivery>;
+    meta: PageMeta;
+};
+type GetIdentityData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/me';
+};
+type GetIdentityErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+};
+type GetIdentityError = GetIdentityErrors[keyof GetIdentityErrors];
+type GetIdentityResponses = {
+    /**
+     * The authenticated identity.
+     */
+    200: Identity;
+};
+type GetIdentityResponse = GetIdentityResponses[keyof GetIdentityResponses];
+type ListProjectsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Restrict to one organisation. Narrows the reachable set, never widens it: an organisation the caller cannot reach yields an empty page rather than a 403.
+         */
+        organizationId?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/projects';
+};
+type ListProjectsErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:projects:read` ability.
+     */
+    403: ErrorResponse;
+};
+type ListProjectsError = ListProjectsErrors[keyof ListProjectsErrors];
+type ListProjectsResponses = {
+    /**
+     * Paginated list of projects.
+     */
+    200: ProjectListPage;
+};
+type ListProjectsResponse = ListProjectsResponses[keyof ListProjectsResponses];
+type GetProjectData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{id}';
+};
+type GetProjectErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:projects:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Project not found, or outside the token’s reach.
+     */
+    404: ErrorResponse;
+};
+type GetProjectError = GetProjectErrors[keyof GetProjectErrors];
+type GetProjectResponses = {
+    /**
+     * The project.
+     */
+    200: Project;
+};
+type GetProjectResponse = GetProjectResponses[keyof GetProjectResponses];
+type CreateProjectAppTokenData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{id}/app-token';
+};
+type CreateProjectAppTokenErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:projects:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Project not found, or outside the token’s reach.
+     */
+    404: ErrorResponse;
+    /**
+     * The project already has an app token. Rotate it instead.
+     */
+    409: ErrorResponse;
+};
+type CreateProjectAppTokenError = CreateProjectAppTokenErrors[keyof CreateProjectAppTokenErrors];
+type CreateProjectAppTokenResponses = {
+    /**
+     * The project and its new plaintext token.
+     */
+    201: ProjectAppToken;
+};
+type CreateProjectAppTokenResponse = CreateProjectAppTokenResponses[keyof CreateProjectAppTokenResponses];
+type RotateProjectAppTokenData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{id}/app-token/rotate';
+};
+type RotateProjectAppTokenErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:projects:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Project not found, or outside the token’s reach.
+     */
+    404: ErrorResponse;
+};
+type RotateProjectAppTokenError = RotateProjectAppTokenErrors[keyof RotateProjectAppTokenErrors];
+type RotateProjectAppTokenResponses = {
+    /**
+     * The project and its new plaintext token.
+     */
+    200: ProjectAppToken;
+};
+type RotateProjectAppTokenResponse = RotateProjectAppTokenResponses[keyof RotateProjectAppTokenResponses];
+type ListDevicesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        status?: 'online' | 'offline';
+        /**
+         * Filter to devices whose device type carries this exact slug. An unknown or out-of-scope slug reads as an empty page.
+         */
+        deviceTypeSlug?: string;
+        /**
+         * Filter to the device with this exact hardware fingerprint (e.g. modem IMEI).
+         */
+        fingerprint?: string;
+        /**
+         * Restrict to a single project (must be in scope).
+         */
+        projectId?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/devices';
+};
+type ListDevicesErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:read` ability.
+     */
+    403: ErrorResponse;
+};
+type ListDevicesError = ListDevicesErrors[keyof ListDevicesErrors];
+type ListDevicesResponses = {
+    /**
+     * Paginated list of devices.
+     */
+    200: DeviceListPage;
+};
+type ListDevicesResponse = ListDevicesResponses[keyof ListDevicesResponses];
+type DeleteDeviceData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}';
+};
+type DeleteDeviceErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found.
+     */
+    404: ErrorResponse;
+};
+type DeleteDeviceError = DeleteDeviceErrors[keyof DeleteDeviceErrors];
+type DeleteDeviceResponses = {
+    /**
+     * Deleted.
+     */
+    204: unknown;
+};
+type GetDeviceData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}';
+};
+type GetDeviceErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found.
+     */
+    404: ErrorResponse;
+};
+type GetDeviceError = GetDeviceErrors[keyof GetDeviceErrors];
+type GetDeviceResponses = {
+    /**
+     * The device.
+     */
+    200: Device;
+};
+type GetDeviceResponse = GetDeviceResponses[keyof GetDeviceResponses];
+type ResetDeviceTokenData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}/token/reset';
+};
+type ResetDeviceTokenErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found.
+     */
+    404: ErrorResponse;
+};
+type ResetDeviceTokenError = ResetDeviceTokenErrors[keyof ResetDeviceTokenErrors];
+type ResetDeviceTokenResponses = {
+    /**
+     * The rotated device token.
+     */
+    200: DeviceTokenReset;
+};
+type ResetDeviceTokenResponse = ResetDeviceTokenResponses[keyof ResetDeviceTokenResponses];
+type GetLatestTelemetryData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}/telemetry/latest';
+};
+type GetLatestTelemetryErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:telemetry:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found.
+     */
+    404: ErrorResponse;
+};
+type GetLatestTelemetryError = GetLatestTelemetryErrors[keyof GetLatestTelemetryErrors];
+type GetLatestTelemetryResponses = {
+    /**
+     * Latest telemetry sample, or `null` if unavailable.
+     */
+    200: TelemetrySample | null;
+};
+type GetLatestTelemetryResponse = GetLatestTelemetryResponses[keyof GetLatestTelemetryResponses];
+type GetTelemetryHistoryData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        hours?: number;
+    };
+    url: '/api/v1/devices/{id}/telemetry';
+};
+type GetTelemetryHistoryErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:telemetry:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found.
+     */
+    404: ErrorResponse;
+};
+type GetTelemetryHistoryError = GetTelemetryHistoryErrors[keyof GetTelemetryHistoryErrors];
+type GetTelemetryHistoryResponses = {
+    /**
+     * Time-ordered (asc) telemetry samples.
+     */
+    200: TelemetryHistory;
+};
+type GetTelemetryHistoryResponse = GetTelemetryHistoryResponses[keyof GetTelemetryHistoryResponses];
+type GetTelemetryManifestData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}/telemetry/manifest';
+};
+type GetTelemetryManifestErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:telemetry:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found or out of scope.
+     */
+    404: ErrorResponse;
+};
+type GetTelemetryManifestError = GetTelemetryManifestErrors[keyof GetTelemetryManifestErrors];
+type GetTelemetryManifestResponses = {
+    /**
+     * The device type's manifest, or `null` when none is declared.
+     */
+    200: TelemetryManifest | null;
+};
+type GetTelemetryManifestResponse = GetTelemetryManifestResponses[keyof GetTelemetryManifestResponses];
+type ListAdmissionsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        status?: 'pending' | 'accepted' | 'rejected' | 'dismissed';
+        /**
+         * Filter to the request raised by this exact hardware fingerprint.
+         */
+        fingerprint?: string;
+        /**
+         * Restrict to a single project (must be in scope).
+         */
+        projectId?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/admissions';
+};
+type ListAdmissionsErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:admissions:read` ability.
+     */
+    403: ErrorResponse;
+};
+type ListAdmissionsError = ListAdmissionsErrors[keyof ListAdmissionsErrors];
+type ListAdmissionsResponses = {
+    /**
+     * Paginated list of admission requests.
+     */
+    200: AdmissionListPage;
+};
+type ListAdmissionsResponse = ListAdmissionsResponses[keyof ListAdmissionsResponses];
+type GetAdmissionData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/admissions/{id}';
+};
+type GetAdmissionErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:admissions:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Admission not found.
+     */
+    404: ErrorResponse;
+};
+type GetAdmissionError = GetAdmissionErrors[keyof GetAdmissionErrors];
+type GetAdmissionResponses = {
+    /**
+     * The admission request.
+     */
+    200: Admission;
+};
+type GetAdmissionResponse = GetAdmissionResponses[keyof GetAdmissionResponses];
+type AcceptAdmissionData = {
+    body?: AdmissionAcceptRequest;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/admissions/{id}/accept';
+};
+type AcceptAdmissionErrors = {
+    /**
+     * Invalid body or the `deviceTypeId` does not belong to the project.
+     */
+    400: ErrorResponse;
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:admissions:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Admission not found.
+     */
+    404: ErrorResponse;
+    /**
+     * The admission has already been reviewed.
+     */
+    409: ErrorResponse;
+};
+type AcceptAdmissionError = AcceptAdmissionErrors[keyof AcceptAdmissionErrors];
+type AcceptAdmissionResponses = {
+    /**
+     * The reviewed admission and the newly provisioned device.
+     */
+    200: AdmissionAcceptResponse;
+};
+type AcceptAdmissionResponse = AcceptAdmissionResponses[keyof AcceptAdmissionResponses];
+type RejectAdmissionData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/admissions/{id}/reject';
+};
+type RejectAdmissionErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:admissions:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Admission not found.
+     */
+    404: ErrorResponse;
+    /**
+     * The admission has already been reviewed.
+     */
+    409: ErrorResponse;
+};
+type RejectAdmissionError = RejectAdmissionErrors[keyof RejectAdmissionErrors];
+type RejectAdmissionResponses = {
+    /**
+     * The rejected admission.
+     */
+    200: Admission;
+};
+type RejectAdmissionResponse = RejectAdmissionResponses[keyof RejectAdmissionResponses];
+type DismissAdmissionData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/admissions/{id}/dismiss';
+};
+type DismissAdmissionErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:admissions:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Admission not found.
+     */
+    404: ErrorResponse;
+    /**
+     * The admission has already been reviewed.
+     */
+    409: ErrorResponse;
+};
+type DismissAdmissionError = DismissAdmissionErrors[keyof DismissAdmissionErrors];
+type DismissAdmissionResponses = {
+    /**
+     * The dismissed admission.
+     */
+    200: Admission;
+};
+type DismissAdmissionResponse = DismissAdmissionResponses[keyof DismissAdmissionResponses];
+type UploadFirmwareData = {
+    body?: FirmwareUploadRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/firmware/upload';
+};
+type UploadFirmwareErrors = {
+    /**
+     * Missing/invalid form field or bundle too large.
+     */
+    400: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:write` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * `projectId` is not in this token's effective scope.
+     */
+    404: ErrorResponse;
+    /**
+     * A bundle with the same projectId+version+compatible already exists.
+     */
+    409: FirmwareConflictResponse;
+    /**
+     * Bundle binary unreadable: a RAUC bundle with no `manifest.raucm`, or an MCUboot image with a bad header magic.
+     */
+    422: ErrorResponse;
+};
+type UploadFirmwareError = UploadFirmwareErrors[keyof UploadFirmwareErrors];
+type UploadFirmwareResponses = {
+    /**
+     * Bundle accepted and stored.
+     */
+    200: FirmwareUploadResponse;
+};
+type UploadFirmwareResponse = UploadFirmwareResponses[keyof UploadFirmwareResponses];
+type ListFirmwareBundlesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Case-insensitive substring of the bundle version (e.g. `0.10`).
+         */
+        version?: string;
+        /**
+         * Exact hardware target, as recorded on the bundle (e.g. `cm5-gateway`).
+         */
+        compatible?: string;
+        /**
+         * Restrict to a single project (must be in scope).
+         */
+        projectId?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/firmware/bundles';
+};
+type ListFirmwareBundlesErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:read` ability.
+     */
+    403: ErrorResponse;
+};
+type ListFirmwareBundlesError = ListFirmwareBundlesErrors[keyof ListFirmwareBundlesErrors];
+type ListFirmwareBundlesResponses = {
+    /**
+     * Paginated list of bundles.
+     */
+    200: FirmwareBundleListPage;
+};
+type ListFirmwareBundlesResponse = ListFirmwareBundlesResponses[keyof ListFirmwareBundlesResponses];
+type DeleteFirmwareBundleData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/firmware/bundles/{id}';
+};
+type DeleteFirmwareBundleErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:write` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Bundle not found in this token’s scope.
+     */
+    404: ErrorResponse;
+    /**
+     * The bundle has an in-flight deployment. Cancel it first.
+     */
+    409: ErrorResponse;
+};
+type DeleteFirmwareBundleError = DeleteFirmwareBundleErrors[keyof DeleteFirmwareBundleErrors];
+type DeleteFirmwareBundleResponses = {
+    /**
+     * Deleted.
+     */
+    204: unknown;
+};
+type GetFirmwareBundleData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/firmware/bundles/{id}';
+};
+type GetFirmwareBundleErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Bundle not found in this token’s scope.
+     */
+    404: ErrorResponse;
+};
+type GetFirmwareBundleError = GetFirmwareBundleErrors[keyof GetFirmwareBundleErrors];
+type GetFirmwareBundleResponses = {
+    /**
+     * The bundle.
+     */
+    200: FirmwareBundle;
+};
+type GetFirmwareBundleResponse = GetFirmwareBundleResponses[keyof GetFirmwareBundleResponses];
+type ListFirmwareDeploymentsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        status?: 'pending' | 'downloading' | 'installing' | 'succeeded' | 'failed' | 'canceled' | 'rolled_back';
+        bundleId?: string;
+        deviceId?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/firmware/deployments';
+};
+type ListFirmwareDeploymentsErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:read` ability.
+     */
+    403: ErrorResponse;
+};
+type ListFirmwareDeploymentsError = ListFirmwareDeploymentsErrors[keyof ListFirmwareDeploymentsErrors];
+type ListFirmwareDeploymentsResponses = {
+    /**
+     * Paginated list of deployments.
+     */
+    200: FirmwareDeploymentListPage;
+};
+type ListFirmwareDeploymentsResponse = ListFirmwareDeploymentsResponses[keyof ListFirmwareDeploymentsResponses];
+type TriggerFirmwareDeploymentData = {
+    body?: FirmwareDeploymentTriggerRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/firmware/deployments';
+};
+type TriggerFirmwareDeploymentErrors = {
+    /**
+     * Invalid body, too many devices, or a device outside the bundle’s project.
+     */
+    400: ErrorResponse;
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:write` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Bundle not found in this token’s scope.
+     */
+    404: ErrorResponse;
+    /**
+     * A targeted device’s recorded hardware compatibility does not match the bundle’s declared target, or its device type does not support firmware updates at all.
+     */
+    422: ErrorResponse;
+};
+type TriggerFirmwareDeploymentError = TriggerFirmwareDeploymentErrors[keyof TriggerFirmwareDeploymentErrors];
+type TriggerFirmwareDeploymentResponses = {
+    /**
+     * The created deployments (one per device).
+     */
+    200: FirmwareDeploymentTriggerResponse;
+};
+type TriggerFirmwareDeploymentResponse = TriggerFirmwareDeploymentResponses[keyof TriggerFirmwareDeploymentResponses];
+type GetFirmwareDeploymentData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/firmware/deployments/{id}';
+};
+type GetFirmwareDeploymentErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Deployment not found.
+     */
+    404: ErrorResponse;
+};
+type GetFirmwareDeploymentError = GetFirmwareDeploymentErrors[keyof GetFirmwareDeploymentErrors];
+type GetFirmwareDeploymentResponses = {
+    /**
+     * The deployment.
+     */
+    200: FirmwareDeployment;
+};
+type GetFirmwareDeploymentResponse = GetFirmwareDeploymentResponses[keyof GetFirmwareDeploymentResponses];
+type CancelFirmwareDeploymentData = {
+    body?: FirmwareDeploymentCancelRequest;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/firmware/deployments/{id}/cancel';
+};
+type CancelFirmwareDeploymentErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:write` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Deployment not found.
+     */
+    404: ErrorResponse;
+    /**
+     * Already terminal, or in flight without `force: true`. The message says which.
+     */
+    409: ErrorResponse;
+};
+type CancelFirmwareDeploymentError = CancelFirmwareDeploymentErrors[keyof CancelFirmwareDeploymentErrors];
+type CancelFirmwareDeploymentResponses = {
+    /**
+     * The canceled deployment.
+     */
+    200: FirmwareDeployment;
+};
+type CancelFirmwareDeploymentResponse = CancelFirmwareDeploymentResponses[keyof CancelFirmwareDeploymentResponses];
+type RollbackFirmwareDeploymentData = {
+    body?: FirmwareDeploymentRollbackRequest;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/firmware/deployments/{id}/rollback';
+};
+type RollbackFirmwareDeploymentErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:firmware:write` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Deployment not found.
+     */
+    404: ErrorResponse;
+    /**
+     * The source deployment is not `succeeded`; rollback only undoes a succeeded install.
+     */
+    409: ErrorResponse;
+    /**
+     * Rollback could not be dispatched: the device is offline, delivery to the device failed, or the device type does not support firmware rollback.
+     */
+    422: ErrorResponse;
+};
+type RollbackFirmwareDeploymentError = RollbackFirmwareDeploymentErrors[keyof RollbackFirmwareDeploymentErrors];
+type RollbackFirmwareDeploymentResponses = {
+    /**
+     * The new synthetic rollback deployment.
+     */
+    200: FirmwareDeployment;
+};
+type RollbackFirmwareDeploymentResponse = RollbackFirmwareDeploymentResponses[keyof RollbackFirmwareDeploymentResponses];
+type ExecDeviceCommandData = {
+    body?: CommandRequest;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}/command';
+};
+type ExecDeviceCommandErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:command:exec` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found or out of scope.
+     */
+    404: ErrorResponse;
+    /**
+     * Command rejected by the device type's manifest: unknown name, missing required arg, wrong arg type, or the device type declares no manifest at all.
+     */
+    422: ErrorResponse;
+    /**
+     * Device offline, command timed out, or transport failed.
+     */
+    502: ErrorResponse;
+};
+type ExecDeviceCommandError = ExecDeviceCommandErrors[keyof ExecDeviceCommandErrors];
+type ExecDeviceCommandResponses = {
+    /**
+     * Interactive device: command completed; returns status + captured output.
+     */
+    200: CommandResult;
+    /**
+     * Queued device: command accepted for store-and-forward delivery; returns the invocation id and status. Poll `GET /api/v1/devices/{id}/commands/{invocationId}` for the eventual result.
+     */
+    202: CommandResult;
+};
+type ExecDeviceCommandResponse = ExecDeviceCommandResponses[keyof ExecDeviceCommandResponses];
+type GetDeviceCommandInvocationData = {
+    body?: never;
+    path: {
+        id: string;
+        invocationId: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}/commands/{invocationId}';
+};
+type GetDeviceCommandInvocationErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:command:exec` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device or invocation not found, or out of scope.
+     */
+    404: ErrorResponse;
+};
+type GetDeviceCommandInvocationError = GetDeviceCommandInvocationErrors[keyof GetDeviceCommandInvocationErrors];
+type GetDeviceCommandInvocationResponses = {
+    /**
+     * The invocation record: lifecycle status plus the result when terminal.
+     */
+    200: CommandInvocation;
+};
+type GetDeviceCommandInvocationResponse = GetDeviceCommandInvocationResponses[keyof GetDeviceCommandInvocationResponses];
+type GetDeviceCommandsData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/devices/{id}/commands';
+};
+type GetDeviceCommandsErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device not found or out of scope.
+     */
+    404: ErrorResponse;
+};
+type GetDeviceCommandsError = GetDeviceCommandsErrors[keyof GetDeviceCommandsErrors];
+type GetDeviceCommandsResponses = {
+    /**
+     * The device type's command manifest, or null when none is declared.
+     */
+    200: CommandManifest | null;
+};
+type GetDeviceCommandsResponse = GetDeviceCommandsResponses[keyof GetDeviceCommandsResponses];
+type DeleteCommandManifestData = {
+    body?: never;
+    path: {
+        projectId: string;
+        slug: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{projectId}/device-types/{slug}/commands';
+};
+type DeleteCommandManifestErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:device-types:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device type not found or out of scope.
+     */
+    404: ErrorResponse;
+};
+type DeleteCommandManifestError = DeleteCommandManifestErrors[keyof DeleteCommandManifestErrors];
+type DeleteCommandManifestResponses = {
+    /**
+     * Deleted.
+     */
+    204: unknown;
+};
+type GetCommandManifestData = {
+    body?: never;
+    path: {
+        projectId: string;
+        slug: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{projectId}/device-types/{slug}/commands';
+};
+type GetCommandManifestErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device type not found or out of scope.
+     */
+    404: ErrorResponse;
+};
+type GetCommandManifestError = GetCommandManifestErrors[keyof GetCommandManifestErrors];
+type GetCommandManifestResponses = {
+    /**
+     * The command manifest, or null when none is declared.
+     */
+    200: CommandManifest | null;
+};
+type GetCommandManifestResponse = GetCommandManifestResponses[keyof GetCommandManifestResponses];
+type UpdateCommandManifestData = {
+    body?: CommandManifest;
+    path: {
+        projectId: string;
+        slug: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{projectId}/device-types/{slug}/commands';
+};
+type UpdateCommandManifestErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:device-types:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device type not found or out of scope.
+     */
+    404: ErrorResponse;
+    /**
+     * Malformed manifest (duplicate command names, bad arg types, …).
+     */
+    422: ErrorResponse;
+};
+type UpdateCommandManifestError = UpdateCommandManifestErrors[keyof UpdateCommandManifestErrors];
+type UpdateCommandManifestResponses = {
+    /**
+     * The stored command manifest.
+     */
+    200: CommandManifest;
+};
+type UpdateCommandManifestResponse = UpdateCommandManifestResponses[keyof UpdateCommandManifestResponses];
+type ListDeviceTypesData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: {
+        /**
+         * Exact slug to filter to.
+         */
+        slug?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/projects/{projectId}/device-types';
+};
+type ListDeviceTypesErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Project not found, or outside the token’s reach.
+     */
+    404: ErrorResponse;
+};
+type ListDeviceTypesError = ListDeviceTypesErrors[keyof ListDeviceTypesErrors];
+type ListDeviceTypesResponses = {
+    /**
+     * Paginated list of device types.
+     */
+    200: DeviceTypeListPage;
+};
+type ListDeviceTypesResponse = ListDeviceTypesResponses[keyof ListDeviceTypesResponses];
+type CreateDeviceTypeData = {
+    body?: DeviceTypeCreateRequest;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{projectId}/device-types';
+};
+type CreateDeviceTypeErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:device-types:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Project not found, or outside the token’s reach.
+     */
+    404: ErrorResponse;
+    /**
+     * A device type with this slug already exists in the project.
+     */
+    409: ErrorResponse;
+    /**
+     * Validation failed, the command manifest is semantically invalid, or protocolOptions is not parseable as a nanopb .options file.
+     */
+    422: ErrorResponse;
+};
+type CreateDeviceTypeError = CreateDeviceTypeErrors[keyof CreateDeviceTypeErrors];
+type CreateDeviceTypeResponses = {
+    /**
+     * The created device type.
+     */
+    201: DeviceType;
+};
+type CreateDeviceTypeResponse = CreateDeviceTypeResponses[keyof CreateDeviceTypeResponses];
+type DeleteDeviceTypeData = {
+    body?: never;
+    path: {
+        projectId: string;
+        slug: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{projectId}/device-types/{slug}';
+};
+type DeleteDeviceTypeErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:device-types:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device type or project not found.
+     */
+    404: ErrorResponse;
+    /**
+     * The device type is still assigned to devices.
+     */
+    409: ErrorResponse;
+};
+type DeleteDeviceTypeError = DeleteDeviceTypeErrors[keyof DeleteDeviceTypeErrors];
+type DeleteDeviceTypeResponses = {
+    /**
+     * Deleted.
+     */
+    204: unknown;
+};
+type GetDeviceTypeData = {
+    body?: never;
+    path: {
+        projectId: string;
+        slug: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{projectId}/device-types/{slug}';
+};
+type GetDeviceTypeErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:devices:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device type or project not found.
+     */
+    404: ErrorResponse;
+};
+type GetDeviceTypeError = GetDeviceTypeErrors[keyof GetDeviceTypeErrors];
+type GetDeviceTypeResponses = {
+    /**
+     * The device type.
+     */
+    200: DeviceType;
+};
+type GetDeviceTypeResponse = GetDeviceTypeResponses[keyof GetDeviceTypeResponses];
+type UpdateDeviceTypeData = {
+    body?: DeviceTypeUpdateRequest;
+    path: {
+        projectId: string;
+        slug: string;
+    };
+    query?: never;
+    url: '/api/v1/projects/{projectId}/device-types/{slug}';
+};
+type UpdateDeviceTypeErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:device-types:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Device type or project not found.
+     */
+    404: ErrorResponse;
+    /**
+     * Validation failed, the command manifest is semantically invalid, or protocolOptions is not parseable as a nanopb .options file.
+     */
+    422: ErrorResponse;
+};
+type UpdateDeviceTypeError = UpdateDeviceTypeErrors[keyof UpdateDeviceTypeErrors];
+type UpdateDeviceTypeResponses = {
+    /**
+     * The updated device type.
+     */
+    200: DeviceType;
+};
+type UpdateDeviceTypeResponse = UpdateDeviceTypeResponses[keyof UpdateDeviceTypeResponses];
+type ListWebhooksData = {
+    body?: never;
+    path?: never;
+    query?: {
+        projectId?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/webhooks';
+};
+type ListWebhooksErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:webhooks:read` ability.
+     */
+    403: ErrorResponse;
+};
+type ListWebhooksError = ListWebhooksErrors[keyof ListWebhooksErrors];
+type ListWebhooksResponses = {
+    /**
+     * Paginated list of webhook subscriptions.
+     */
+    200: WebhookSubscriptionPage;
+};
+type ListWebhooksResponse = ListWebhooksResponses[keyof ListWebhooksResponses];
+type CreateWebhookData = {
+    body?: WebhookCreateRequest;
+    path?: never;
+    query?: never;
+    url: '/api/v1/webhooks';
+};
+type CreateWebhookErrors = {
+    /**
+     * Invalid body or rejected URL.
+     */
+    400: ErrorResponse;
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:webhooks:manage` ability.
+     */
+    403: ErrorResponse;
+};
+type CreateWebhookError = CreateWebhookErrors[keyof CreateWebhookErrors];
+type CreateWebhookResponses = {
+    /**
+     * The created subscription, with the one-time signing secret.
+     */
+    201: WebhookCreateResponse;
+};
+type CreateWebhookResponse = CreateWebhookResponses[keyof CreateWebhookResponses];
+type DeleteWebhookData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/webhooks/{id}';
+};
+type DeleteWebhookErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:webhooks:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Subscription not found.
+     */
+    404: ErrorResponse;
+};
+type DeleteWebhookError = DeleteWebhookErrors[keyof DeleteWebhookErrors];
+type DeleteWebhookResponses = {
+    /**
+     * Deleted.
+     */
+    204: unknown;
+};
+type GetWebhookData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/webhooks/{id}';
+};
+type GetWebhookErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:webhooks:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Subscription not found.
+     */
+    404: ErrorResponse;
+};
+type GetWebhookError = GetWebhookErrors[keyof GetWebhookErrors];
+type GetWebhookResponses = {
+    /**
+     * The subscription.
+     */
+    200: WebhookSubscription;
+};
+type GetWebhookResponse = GetWebhookResponses[keyof GetWebhookResponses];
+type UpdateWebhookData = {
+    body?: WebhookUpdateRequest;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/webhooks/{id}';
+};
+type UpdateWebhookErrors = {
+    /**
+     * Invalid body or rejected URL.
+     */
+    400: ErrorResponse;
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:webhooks:manage` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Subscription not found.
+     */
+    404: ErrorResponse;
+};
+type UpdateWebhookError = UpdateWebhookErrors[keyof UpdateWebhookErrors];
+type UpdateWebhookResponses = {
+    /**
+     * The updated subscription.
+     */
+    200: WebhookSubscription;
+};
+type UpdateWebhookResponse = UpdateWebhookResponses[keyof UpdateWebhookResponses];
+type ListWebhookDeliveriesData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        status?: 'pending' | 'delivered' | 'failed';
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/v1/webhooks/{id}/deliveries';
+};
+type ListWebhookDeliveriesErrors = {
+    /**
+     * Missing or invalid token.
+     */
+    401: ErrorResponse;
+    /**
+     * Token is missing the `api:webhooks:read` ability.
+     */
+    403: ErrorResponse;
+    /**
+     * Subscription not found.
+     */
+    404: ErrorResponse;
+};
+type ListWebhookDeliveriesError = ListWebhookDeliveriesErrors[keyof ListWebhookDeliveriesErrors];
+type ListWebhookDeliveriesResponses = {
+    /**
+     * Paginated delivery log.
+     */
+    200: WebhookDeliveryPage;
+};
+type ListWebhookDeliveriesResponse = ListWebhookDeliveriesResponses[keyof ListWebhookDeliveriesResponses];
+
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+interface ClientMeta {
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options$1<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options$1<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
+
+/**
+ * USB/IP passthrough, the two HTTP calls that precede the tunnel.
+ *
+ * Hand-written, unlike every other operation here: these endpoints are
+ * deliberately absent from the published spec (`api/v1/DESIGN.md` scopes the
+ * public API to backend integration), so there is nothing to generate from.
+ * They stay in the SDK anyway to keep bearer auth, retries and typed errors in
+ * one client.
+ *
+ * The shapes below must therefore be kept in step with the server by hand —
+ * `app/controllers/usbip_controller.ts` and `#types/usb_manifest`.
+ */
+
+/** One VID:PID a peripheral can present. Four lowercase hex digits each. */
+interface UsbDeviceIdentifier {
+    vid: string;
+    pid: string;
+}
+/**
+ * One entry of a device type's USB manifest, a peripheral the device is
+ * *permitted* to export. This is the declared allowlist, not a live bus scan:
+ * an entry here may still be unplugged.
+ */
+interface UsbExportDefinition {
+    /** Stable key for this entry, used in the UI and the audit trail. */
+    key: string;
+    /** Human-readable label (e.g. `SEGGER J-Link`). */
+    label: string;
+    /**
+     * Every VID:PID this peripheral can present. A product id is per *mode*, so
+     * an entry lists each mode the peripheral may legitimately appear in.
+     */
+    ids: UsbDeviceIdentifier[];
+    /**
+     * Restrict to specific physical units by USB serial. VID:PID identifies a
+     * *model*, so leaving this unset allows any unit of it.
+     */
+    serials?: string[];
+    description?: string;
+}
+interface UsbExportList {
+    exports: UsbExportDefinition[];
+}
+interface UsbTicketRequest {
+    deviceId: string;
+    /** Four hex digits, as sysfs reports it (`1366`). */
+    vid: string;
+    /** Four hex digits (`1020`). */
+    pid: string;
+    /** Required when the device type pins serials, or to disambiguate units. */
+    serial?: string;
+}
+interface UsbTicketResponse {
+    /** Single-use, short-lived. Redeemed once on the `/ws/usbip` upgrade. */
+    ticket: string;
+    /** The manifest entry the request matched, what the ticket authorizes. */
+    export: UsbExportDefinition;
+}
+
+/**
+ * Device shell: the one HTTP call that precedes the WebSocket session.
+ *
+ * Hand-written for the same reason as `usb.ts`. These endpoints are
+ * deliberately absent from the published spec (`api/v1/DESIGN.md` scopes the
+ * public API to backend integration), so there is nothing to generate from.
+ * They stay in the SDK anyway to keep bearer auth, retries and typed errors in
+ * one client.
+ *
+ * The shape below is kept in step with
+ * `app/controllers/v1/terminal_controller.ts` by hand.
+ */
+
+interface TerminalTicketRequest {
+    deviceId: string;
+}
+interface TerminalTicketResponse {
+    /** Single-use and short-lived. Redeemed once on the `/ws/terminal` upgrade. */
+    ticket: string;
+}
+
+interface OrbitClientOptions {
+    /** Personal access token (`oat_…`) created in the dashboard at Account → API tokens. */
+    token: string;
+    /** API origin. Defaults to `https://orbit.omirion.com`. */
+    baseUrl?: string;
+    /** Max automatic retries for 429/502/503/504 and network errors. Default `2`. */
+    maxRetries?: number;
+    /** Base exponential-backoff delay in milliseconds. Default `500`. */
+    retryBaseDelayMs?: number;
+    /** Custom `fetch` implementation (e.g. for tests or non-standard runtimes). */
+    fetch?: typeof fetch;
+}
+interface ListProjectsParams {
+    /** Restrict to one organisation. Narrows the reachable set, never widens it. */
+    organizationId?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface IterateProjectsParams {
+    organizationId?: string;
+    limit?: number;
+}
+interface ListDeviceTypesParams {
+    /** Exact slug to filter to. */
+    slug?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface IterateDeviceTypesParams {
+    slug?: string;
+    limit?: number;
+}
+interface ListDevicesParams {
+    /** Restrict to one project (must be in this token's scope). */
+    projectId?: string;
+    /** Filter to the device with this exact hardware fingerprint (e.g. modem IMEI). */
+    fingerprint?: string;
+    /** Filter to devices whose device type carries this exact slug. */
+    deviceTypeSlug?: string;
+    limit?: number;
+    cursor?: string;
+    status?: 'online' | 'offline';
+}
+interface IterateDevicesParams {
+    projectId?: string;
+    fingerprint?: string;
+    deviceTypeSlug?: string;
+    limit?: number;
+    status?: 'online' | 'offline';
+}
+type AdmissionStatus = Admission['status'];
+type DeploymentStatus = FirmwareDeployment['status'];
+interface ListAdmissionsParams {
+    /** Restrict to one project (must be in this token's scope). */
+    projectId?: string;
+    /** Filter to the request raised by this exact hardware fingerprint. */
+    fingerprint?: string;
+    status?: AdmissionStatus;
+    limit?: number;
+    cursor?: string;
+}
+interface IterateAdmissionsParams {
+    projectId?: string;
+    fingerprint?: string;
+    status?: AdmissionStatus;
+    limit?: number;
+}
+interface ListDeploymentsParams {
+    deviceId?: string;
+    bundleId?: string;
+    status?: DeploymentStatus;
+    limit?: number;
+    cursor?: string;
+}
+interface IterateDeploymentsParams {
+    deviceId?: string;
+    bundleId?: string;
+    status?: DeploymentStatus;
+    limit?: number;
+}
+interface TelemetryHistoryParams {
+    /** Window size in hours (1–168). Defaults to the server default (6). */
+    hours?: number;
+}
+interface ListBundlesParams {
+    /** Restrict to one project (must be in this token's scope). */
+    projectId?: string;
+    /** Exact hardware target, as recorded on the bundle (e.g. `cm5-gateway`). */
+    compatible?: string;
+    /** Case-insensitive substring of the bundle version (e.g. `0.10`). */
+    version?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface IterateBundlesParams {
+    projectId?: string;
+    compatible?: string;
+    version?: string;
+    limit?: number;
+}
+interface UploadFirmwareParams {
+    /** The bundle file: `.raucb` for `kind: 'rauc'`, `.bin` for `kind: 'mcuboot'`. */
+    file: Blob | File;
+    /** Target project. Must be in this token's scope. */
+    projectId: string;
+    /** Bundle kind. Defaults to `rauc` when omitted. */
+    kind?: 'rauc' | 'mcuboot';
+    /**
+     * Bundle version. Decoded from the binary (RAUC manifest, MCUboot image
+     * header) and ignored if sent.
+     */
+    version?: string;
+    /**
+     * Hardware target. Optional for `rauc`, where it is decoded from the
+     * manifest; **required for `mcuboot`**, whose header has no target field.
+     */
+    compatible?: string;
+    description?: string | null;
+}
+interface CancelDeploymentParams {
+    /**
+     * Abort a deployment already in flight (`downloading` / `installing`), where
+     * the device may be partway through an install. Required for those states,
+     * and recorded on the deployment.
+     */
+    force?: boolean;
+}
+interface RollbackDeploymentParams {
+    /** Free text recorded on the rollback row and echoed to the device. */
+    reason?: string;
+}
+interface ListWebhooksParams {
+    /** Restrict to one project (must be in this token's scope). */
+    projectId?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface IterateWebhooksParams {
+    projectId?: string;
+    limit?: number;
+}
+interface WebhookDeliveriesParams {
+    status?: 'pending' | 'delivered' | 'failed';
+    limit?: number;
+    cursor?: string;
+}
+interface IterateWebhookDeliveriesParams {
+    status?: 'pending' | 'delivered' | 'failed';
+    limit?: number;
+}
+/**
+ * The ergonomic entry point to the Omirion Orbit public API. Wraps the
+ * generated transport client with bearer auth, automatic retries with backoff,
+ * typed errors, response unwrapping, and cursor auto-pagination.
+ *
+ * ```ts
+ * const orbit = new OrbitClient({ token: process.env.ORBIT_TOKEN! })
+ * for await (const device of orbit.devices.iterate({ status: 'online' })) {
+ *   const sample = await orbit.telemetry.latest(device.id)
+ * }
+ * ```
+ */
+declare class OrbitClient {
+    #private;
+    /**
+     * Who this token authenticates as, what it may do, and which projects it
+     * reaches. Requires no ability, the cheapest way to verify a token works.
+     */
+    readonly me: () => Promise<Identity>;
+    /**
+     * Projects as a resource. Requires `api:projects:read`; {@link me} returns
+     * the same ids under no ability.
+     */
+    readonly projects: {
+        /** A single page of projects. */
+        list: (params?: ListProjectsParams) => Promise<ProjectListPage>;
+        /** Every project across all pages, fetched lazily. */
+        iterate: (params?: IterateProjectsParams) => AsyncGenerator<Project, void, unknown>;
+        /** A project by id. */
+        get: (id: string) => Promise<Project>;
+        /**
+         * Provisioning (app) token. `token` is returned once and never again, so
+         * persist it from this result rather than expecting to read it back.
+         */
+        appToken: {
+            /** Mint the token. Rejects with 409 when the project already has one. */
+            create: (projectId: string) => Promise<ProjectAppToken>;
+            /**
+             * Replace the token, invalidating the previous one. Units still carrying
+             * the old value can no longer enrol; already-provisioned devices hold
+             * their own device token and are unaffected.
+             */
+            rotate: (projectId: string) => Promise<ProjectAppToken>;
+        };
+    };
+    /**
+     * Device types: the models a fleet identifies as. Reads need
+     * `api:devices:read`; writes need `api:device-types:manage`.
+     */
+    readonly deviceTypes: {
+        /** A single page of device types in a project (counts, not manifests). */
+        list: (projectId: string, params?: ListDeviceTypesParams) => Promise<DeviceTypeListPage>;
+        /** Every device type in a project across all pages, fetched lazily. */
+        iterate: (projectId: string, params?: IterateDeviceTypesParams) => AsyncGenerator<DeviceTypeListPage['data'][number], void, unknown>;
+        /** One device type by slug, with its manifests in full. */
+        get: (projectId: string, slug: string) => Promise<DeviceType>;
+        /** Declare a device type. Rejects with 409 when the slug is taken. */
+        create: (projectId: string, body: DeviceTypeCreateRequest) => Promise<DeviceType>;
+        /** Partial update. A manifest sent here replaces the stored one wholesale. */
+        update: (projectId: string, slug: string, body: DeviceTypeUpdateRequest) => Promise<DeviceType>;
+        /** Delete a type no device uses. Rejects with 409 while devices still reference it. */
+        delete: (projectId: string, slug: string) => Promise<void>;
+    };
+    readonly devices: {
+        /** A single page of devices. */
+        list: (params?: ListDevicesParams) => Promise<DeviceListPage>;
+        /** A device by id. */
+        get: (id: string) => Promise<Device>;
+        /** Every device across all pages, fetched lazily. */
+        iterate: (params?: IterateDevicesParams) => AsyncGenerator<DeviceListItem, void, unknown>;
+        /** Permanently delete a device (releases its licensing seat; evicts the live agent). */
+        delete: (id: string) => Promise<void>;
+        /**
+         * Rotate the device token in place, keeping the device and its history.
+         * The new token is returned once and cannot be retrieved again.
+         */
+        resetToken: (id: string) => Promise<DeviceTokenReset>;
+    };
+    readonly admissions: {
+        /** A single page of admission (fleet-join) requests. */
+        list: (params?: ListAdmissionsParams) => Promise<AdmissionListPage>;
+        /** Every admission across all pages, fetched lazily. */
+        iterate: (params?: IterateAdmissionsParams) => AsyncGenerator<Admission, void, unknown>;
+        /** An admission request by id. */
+        get: (id: string) => Promise<Admission>;
+        /** Accept a pending admission, provisioning a device (returns admission + device). */
+        accept: (id: string, params: AdmissionAcceptRequest) => Promise<AdmissionAcceptResponse>;
+        /** Reject a pending admission permanently. */
+        reject: (id: string) => Promise<Admission>;
+        /**
+         * Dismiss a pending admission without provisioning and without a permanent
+         * refusal: the request reopens as `pending` when the same fingerprint next
+         * asks to enrol.
+         */
+        dismiss: (id: string) => Promise<Admission>;
+    };
+    readonly telemetry: {
+        /** Most recent sample for a device, or `null` if it never reported. */
+        latest: (deviceId: string) => Promise<TelemetrySample | null>;
+        /** A time-window of samples (ascending). */
+        history: (deviceId: string, params?: TelemetryHistoryParams) => Promise<TelemetrySample[]>;
+        /** Metric manifest of a device's type, or `null` if it has none. */
+        manifest: (deviceId: string) => Promise<TelemetryManifest | null>;
+    };
+    readonly firmware: {
+        /** Upload a RAUC bundle; returns the stored bundle. */
+        upload: (params: UploadFirmwareParams) => Promise<FirmwareBundle>;
+        /** Delete a bundle (refused while it has an in-flight deployment). */
+        deleteBundle: (id: string) => Promise<void>;
+        bundles: {
+            /** A single page of bundles. */
+            list: (params?: ListBundlesParams) => Promise<FirmwareBundleListPage>;
+            /** Every bundle across all pages, fetched lazily. */
+            iterate: (params?: IterateBundlesParams) => AsyncGenerator<FirmwareBundle, void, unknown>;
+            /** A bundle by id. */
+            get: (id: string) => Promise<FirmwareBundle>;
+        };
+        deployments: {
+            /** Roll a bundle out to devices; returns one deployment per device. */
+            trigger: (params: FirmwareDeploymentTriggerRequest) => Promise<FirmwareDeployment[]>;
+            /** A single page of deployments. */
+            list: (params?: ListDeploymentsParams) => Promise<FirmwareDeploymentListPage>;
+            /** Every deployment across all pages, fetched lazily. */
+            iterate: (params?: IterateDeploymentsParams) => AsyncGenerator<FirmwareDeployment, void, unknown>;
+            /** A deployment by id. Poll it to follow a rollout. */
+            get: (id: string) => Promise<FirmwareDeployment>;
+            /**
+             * Cancel a deployment. A `pending` one cancels with no flag; one already
+             * in flight needs `force`. A terminal one throws `ConflictError`.
+             */
+            cancel: (id: string, params?: CancelDeploymentParams) => Promise<FirmwareDeployment>;
+            /**
+             * Roll back a `succeeded` deployment's device to its previous firmware.
+             * Returns a *new* deployment (not the source one), so poll it the same
+             * way as a forward rollout. Throws `ConflictError` if the source deployment
+             * is not `succeeded`, or `ValidationError` if the rollback could not be
+             * dispatched (device offline, delivery failed, or unsupported by the
+             * device type).
+             */
+            rollback: (id: string, params?: RollbackDeploymentParams) => Promise<FirmwareDeployment>;
+        };
+    };
+    readonly commands: {
+        /**
+         * Run a declared command on a device (name + typed args, no shell).
+         *
+         * Branch on `queued`: `false` means the device ran it and the result fields
+         * are populated; `true` means it was accepted for store-and-forward
+         * delivery, so poll {@link OrbitClient.commands.get} until `status` is
+         * terminal.
+         */
+        exec: (deviceId: string, command: CommandRequest) => Promise<CommandResult>;
+        /** The durable record of one invocation, the pull path for a queued dispatch. */
+        get: (deviceId: string, invocationId: string) => Promise<CommandInvocation>;
+        /** The command manifest of the device's type, or `null` if it declares none. */
+        manifest: (deviceId: string) => Promise<CommandManifest | null>;
+    };
+    /**
+     * USB/IP passthrough. Requires the `api:usb:attach` ability, which grants raw
+     * USB access to whatever hardware is attached to the device, so treat a token
+     * carrying it accordingly.
+     *
+     * Hand-written rather than generated; see `usb.ts` for why.
+     */
+    readonly usb: {
+        /** What the device's type permits exporting (the declared allowlist). */
+        list: (deviceId: string) => Promise<UsbExportDefinition[]>;
+        /**
+         * Authorize one peripheral and mint a single-use ticket for the tunnel.
+         * Short-lived: open `/ws/usbip` with it promptly or mint another.
+         */
+        ticket: (params: UsbTicketRequest) => Promise<UsbTicketResponse>;
+    };
+    /**
+     * Device shell. Requires the `api:terminal:open` ability, which is the widest
+     * grant the API offers: the agent runs as root, so the session is a root
+     * shell bounded by no manifest. Treat a token carrying it accordingly.
+     *
+     * Hand-written rather than generated; see `terminal.ts` for why.
+     */
+    readonly terminal: {
+        /**
+         * Mint a single-use ticket for a shell session. Short-lived: open
+         * `/ws/terminal` with it promptly or mint another.
+         */
+        ticket: (params: TerminalTicketRequest) => Promise<TerminalTicketResponse>;
+    };
+    readonly webhooks: {
+        /** A single page of webhook subscriptions. */
+        list: (params?: ListWebhooksParams) => Promise<WebhookSubscriptionPage>;
+        /** Every subscription across all pages, fetched lazily. */
+        iterate: (params?: IterateWebhooksParams) => AsyncGenerator<WebhookSubscription, void, unknown>;
+        /** Create a subscription. The signing `secret` is only in this response, store it now. */
+        create: (params: WebhookCreateRequest) => Promise<WebhookCreateResponse>;
+        /** A subscription by id (without its secret). */
+        get: (id: string) => Promise<WebhookSubscription>;
+        /** Update the URL, event-type filter and/or enabled flag. */
+        update: (id: string, params: WebhookUpdateRequest) => Promise<WebhookSubscription>;
+        /** Delete the subscription and its delivery log. */
+        delete: (id: string) => Promise<void>;
+        /** A single page of the subscription's delivery log (newest first). */
+        deliveries: (id: string, params?: WebhookDeliveriesParams) => Promise<WebhookDeliveryPage>;
+        /** Every delivery across all pages, fetched lazily. */
+        iterateDeliveries: (id: string, params?: IterateWebhookDeliveriesParams) => AsyncGenerator<WebhookDelivery, void, unknown>;
+    };
+    constructor(options: OrbitClientOptions);
+}
+
+/**
+ * Typed errors. The `/api/v1` surface returns several different error envelope
+ * shapes; {@link normalizeError} folds them all into one typed hierarchy so
+ * callers can `catch` a specific class instead of inspecting status codes:
+ *
+ *   - standard          `{ errors: [{ code, message, field }] }`
+ *   - device-RPC (502)  `{ errors: [{ code, message }] }`  (no `field`)
+ *   - firmware (409)    `{ error, message }`               (e.g. BUNDLE_ALREADY_EXISTS)
+ *   - validation (422)  `{ errors: [{ message, rule, field }] }`
+ *   - bare auth (401)   `{ errors: [{ message }] }`         (no `code`)
+ */
+interface OrbitErrorOptions {
+    status?: number;
+    code?: string;
+    field?: string | null;
+    body?: unknown;
+    response?: Response;
+    cause?: unknown;
+}
+/** Base class for every error thrown by the SDK. */
+declare class OrbitError extends Error {
+    /** HTTP status, when the failure came from a response. */
+    readonly status?: number;
+    /** Stable machine-readable code (e.g. `E_RESOURCE_NOT_FOUND`), when present. */
+    readonly code?: string;
+    /** Offending field for validation errors, when present. */
+    readonly field?: string | null;
+    /** Raw parsed response body. */
+    readonly body?: unknown;
+    /** The raw `Response`, when one was received. */
+    readonly response?: Response;
+    constructor(message: string, options?: OrbitErrorOptions);
+}
+/** 401, missing/invalid/expired/revoked token. */
+declare class AuthenticationError extends OrbitError {
+}
+/** 403, the token is missing the required ability. */
+declare class InsufficientScopeError extends OrbitError {
+}
+/**
+ * 404, resource not found. Note: a 404 on an id you believe exists usually
+ * means it is outside this token's project scope, not that it is truly absent.
+ */
+declare class ResourceNotFoundError extends OrbitError {
+}
+/** 400, malformed request (bad query param, missing form field, …). */
+declare class BadRequestError extends OrbitError {
+}
+/** One field error inside a 422 envelope. */
+interface ValidationFieldError {
+    /** The human-readable failure for this field. */
+    message: string;
+    /** Dot path of the offending field (e.g. `manifest.version`), when known. */
+    field: string | null;
+}
+/**
+ * 422, request-body validation failed. `fieldErrors` carries every entry of
+ * the envelope (`E_VALIDATION_FAILURE` emits one per field), while `message`
+ * and `field` reflect the first one.
+ */
+declare class ValidationError extends OrbitError {
+    readonly fieldErrors: ValidationFieldError[];
+    constructor(message: string, options?: OrbitErrorOptions & {
+        fieldErrors?: ValidationFieldError[];
+    });
+}
+/** 409, a firmware bundle with the same projectId+version+compatible exists. */
+declare class BundleExistsError extends OrbitError {
+}
+/** 502, the device is offline or the command transport failed. */
+declare class DeviceRpcError extends OrbitError {
+}
+/** 5xx, an unexpected server error. */
+declare class ServerError extends OrbitError {
+}
+/** The request failed before any response was received (DNS, TLS, offline). */
+declare class NetworkError extends OrbitError {
+}
+/** 429, rate limited. Carries the server's `Retry-After`, when provided. */
+declare class RateLimitError extends OrbitError {
+    readonly retryAfterSeconds?: number;
+    constructor(message: string, options?: OrbitErrorOptions & {
+        retryAfterSeconds?: number;
+    });
+}
+/** Read a numeric `Retry-After` (seconds) from a response, if present. */
+declare function parseRetryAfterSeconds(response?: Response): number | undefined;
+/** Map an HTTP status + parsed body into the matching typed error. */
+declare function normalizeError(status: number, body: unknown, response?: Response): OrbitError;
+
+/**
+ * A single telemetry reading joined to its manifest definition. Telemetry
+ * samples are keyed by abbreviated, device-type-specific metric keys; the
+ * decoder resolves each key to its human label, unit, and type so callers
+ * don't have to memorise the manifest.
+ */
+interface DecodedMetric {
+    /** The raw metric key (snake_case) as stored on the sample. */
+    key: string;
+    /** Human-readable label from the manifest, or the key if not in the manifest. */
+    label: string;
+    /** The reading. */
+    value: number | boolean | string;
+    /** Unit of measurement, when the manifest defines one. */
+    unit?: string;
+    /** Value type from the manifest. */
+    type?: MetricDefinition['type'];
+    /** Semantic device class (Home-Assistant convention), when defined. */
+    deviceClass?: string;
+    /** Group key for UI grouping, when defined. */
+    group?: string;
+    /** The full manifest definition, when the key was found in the manifest. */
+    definition?: MetricDefinition;
+}
+/**
+ * Decode a telemetry sample's `metrics` map into labelled rows using the
+ * device type's manifest (from `client.telemetry.manifest(deviceId)`). Keys absent
+ * from the manifest are passed through with the key as the label.
+ */
+declare function decodeSample(sample: TelemetrySample, manifest: TelemetryManifest): DecodedMetric[];
+/** Like {@link decodeSample}, applied to a history window. */
+declare function decodeSamples(samples: TelemetrySample[], manifest: TelemetryManifest): Array<{
+    recordedAt: string;
+    metrics: DecodedMetric[];
+}>;
+
+/** One page of a cursor-paginated list. */
+interface Page<T> {
+    data: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+/**
+ * Turn a cursor-paginated endpoint into an async iterator that yields every
+ * item across all pages, fetching the next page lazily as you consume it.
+ *
+ * ```ts
+ * for await (const device of paginate((cursor) => fetchPage(cursor))) { … }
+ * ```
+ */
+declare function paginate<T>(fetchPage: (cursor?: string) => Promise<Page<T>>): AsyncGenerator<T, void, unknown>;
+
+/**
+ * Webhook receiver helpers, verify `X-Orbit-Signature` on events pushed by
+ * Orbit's outbound webhooks and parse the JSON envelope.
+ *
+ * The signature is `HMAC-SHA256(secret, `${timestamp}.${rawBody}`)` hex-encoded,
+ * where `timestamp` is the `X-Orbit-Timestamp` header (unix seconds) and
+ * `rawBody` is the exact request body bytes. Receivers should reject events
+ * whose timestamp is more than 300 seconds from their clock (replay window);
+ * Orbit re-signs retries with a fresh timestamp.
+ *
+ * Uses the Web Crypto API, so it works in Node ≥ 18, Deno, Bun, and edge
+ * runtimes alike.
+ */
+/** Default replay tolerance, in seconds. */
+declare const WEBHOOK_REPLAY_TOLERANCE_SECONDS = 300;
+/** The JSON envelope Orbit POSTs to a webhook endpoint. */
+interface OrbitWebhookEvent<TData = Record<string, unknown>> {
+    /** Event UUID, the receiver-side idempotency key. */
+    id: string;
+    /** Event type, e.g. `device.online` or `telemetry.metric_changed`. */
+    type: string;
+    /** ISO-8601 emission time. */
+    createdAt: string;
+    /** Project the emitting device belongs to. */
+    projectId: string;
+    /** Event-type-specific payload. */
+    data: TData;
+}
+interface VerifyWebhookSignatureParams {
+    /** The subscription's signing secret (`whsec_…`, shown once at creation). */
+    secret: string;
+    /** The EXACT raw request body, do not re-serialize parsed JSON. */
+    rawBody: string;
+    /** `X-Orbit-Signature` header (hex). */
+    signature: string;
+    /** `X-Orbit-Timestamp` header (unix seconds). */
+    timestamp: number | string;
+    /** Replay window in seconds. Defaults to {@link WEBHOOK_REPLAY_TOLERANCE_SECONDS}. */
+    toleranceSeconds?: number;
+    /** Override "now" (unix seconds), mainly for tests. */
+    nowSeconds?: number;
+}
+/** Compute the hex HMAC-SHA256 signature over `${timestamp}.${rawBody}`. */
+declare function signWebhookPayload(secret: string, timestamp: number, rawBody: string): Promise<string>;
+/**
+ * Verify an Orbit webhook delivery: replay-window check on the timestamp,
+ * then a constant-time comparison of the expected signature.
+ */
+declare function verifyWebhookSignature(params: VerifyWebhookSignatureParams): Promise<boolean>;
+/**
+ * Verify a delivery and parse its envelope in one call. Returns the typed
+ * event, or `null` when the signature (or replay window) check fails.
+ */
+declare function parseWebhookEvent<TData = Record<string, unknown>>(params: VerifyWebhookSignatureParams): Promise<OrbitWebhookEvent<TData> | null>;
+
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options$1<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
+};
+/**
+ * Who this token authenticates as
+ *
+ * Returns the authenticated user, the presented token’s abilities and project scope, and the projects reachable with both. Requires no ability beyond a valid token. Call it to confirm a token works and to discover the `projectId` values other endpoints accept.
+ */
+declare const getIdentity: <ThrowOnError extends boolean = false>(options?: Options<GetIdentityData, ThrowOnError>) => RequestResult<GetIdentityResponses, GetIdentityErrors, ThrowOnError>;
+/**
+ * List projects
+ *
+ * Paginated list of the projects this token reaches (the caller’s organisation access intersected with the token’s project scope). Cursor-based; pass `meta.nextCursor` from the previous page as the `cursor` query parameter.
+ *
+ * Requires `api:projects:read`. Discovering project **ids** alone does not: `GET /api/v1/me` returns them under no ability so a token holding none can still address other endpoints. This endpoint reads the project as a resource, so it is gated and grows independently.
+ */
+declare const listProjects: <ThrowOnError extends boolean = false>(options?: Options<ListProjectsData, ThrowOnError>) => RequestResult<ListProjectsResponses, ListProjectsErrors, ThrowOnError>;
+/**
+ * Get a project
+ *
+ * One project by id. Requires `api:projects:read`. A project outside the token’s reach answers 404 rather than 403, so the refusal does not confirm it exists.
+ */
+declare const getProject: <ThrowOnError extends boolean = false>(options: Options<GetProjectData, ThrowOnError>) => RequestResult<GetProjectResponses, GetProjectErrors, ThrowOnError>;
+/**
+ * Mint the project provisioning (app) token
+ *
+ * Mints the `omr_prj_…` token devices present to enrol into this project. The plaintext value is returned **once, in this response, and is never retrievable again**. The server stores only its sha256. Store it before discarding the response.
+ *
+ * Refuses with 409 when the project already has one; use the rotate endpoint to replace it. Requires `api:projects:manage`, deliberately separate from `api:projects:read`: an app token admits new devices and so consumes licensing seats.
+ */
+declare const createProjectAppToken: <ThrowOnError extends boolean = false>(options: Options<CreateProjectAppTokenData, ThrowOnError>) => RequestResult<CreateProjectAppTokenResponses, CreateProjectAppTokenErrors, ThrowOnError>;
+/**
+ * Rotate the project provisioning (app) token
+ *
+ * Issues a fresh `omr_prj_…` token and invalidates the previous one, if any. The plaintext value is returned **once** and never again.
+ *
+ * **This is destructive for unprovisioned devices.** Any unit still carrying the old token can no longer enrol until it is reflashed or reconfigured; devices that already hold their own device token are unaffected, since enrolment is the only step the app token takes part in. Requires `api:projects:manage`.
+ */
+declare const rotateProjectAppToken: <ThrowOnError extends boolean = false>(options: Options<RotateProjectAppTokenData, ThrowOnError>) => RequestResult<RotateProjectAppTokenResponses, RotateProjectAppTokenErrors, ThrowOnError>;
+/**
+ * List devices
+ *
+ * Paginated list of devices across every project this token is scoped to (intersected with the caller's org access). Cursor-based; pass `meta.nextCursor` from the previous page as the `cursor` query parameter.
+ */
+declare const listDevices: <ThrowOnError extends boolean = false>(options?: Options<ListDevicesData, ThrowOnError>) => RequestResult<ListDevicesResponses, ListDevicesErrors, ThrowOnError>;
+/**
+ * Delete a device
+ *
+ * Permanently removes the device: releases its licensing seat and evicts any live agent (it re-admits on next connect). Must belong to a project this token can manage. Requires the `api:devices:manage` ability.
+ */
+declare const deleteDevice: <ThrowOnError extends boolean = false>(options: Options<DeleteDeviceData, ThrowOnError>) => RequestResult<DeleteDeviceResponses, DeleteDeviceErrors, ThrowOnError>;
+/**
+ * Get a device
+ *
+ * Returns the device with the given UUID. Must belong to a project this token can read.
+ */
+declare const getDevice: <ThrowOnError extends boolean = false>(options: Options<GetDeviceData, ThrowOnError>) => RequestResult<GetDeviceResponses, GetDeviceErrors, ThrowOnError>;
+/**
+ * Reset a device token
+ *
+ * Rotates the device token in place, keeping the device id, name, device-type link and history (unlike delete, which throws them away). The previous token is invalidated and any live agent is evicted so it re-admits/reconnects with the new one (a device that lost its token recovers automatically on its next admission). The new token is returned once and cannot be retrieved again. Must belong to a project this token can manage. Requires the `api:devices:manage` ability.
+ */
+declare const resetDeviceToken: <ThrowOnError extends boolean = false>(options: Options<ResetDeviceTokenData, ThrowOnError>) => RequestResult<ResetDeviceTokenResponses, ResetDeviceTokenErrors, ThrowOnError>;
+/**
+ * Latest telemetry sample for a device
+ *
+ * Returns the most recent telemetry sample. `null` if the device has never reported.
+ */
+declare const getLatestTelemetry: <ThrowOnError extends boolean = false>(options: Options<GetLatestTelemetryData, ThrowOnError>) => RequestResult<GetLatestTelemetryResponses, GetLatestTelemetryErrors, ThrowOnError>;
+/**
+ * Telemetry history for a device
+ *
+ * Returns a time-window of telemetry samples. Defaults to the last 6 hours.
+ */
+declare const getTelemetryHistory: <ThrowOnError extends boolean = false>(options: Options<GetTelemetryHistoryData, ThrowOnError>) => RequestResult<GetTelemetryHistoryResponses, GetTelemetryHistoryErrors, ThrowOnError>;
+/**
+ * Metric manifest for a device
+ *
+ * The metric definitions (label, unit, type, range) of the device's type, i.e. the schema its telemetry samples decode against. `null` when the device type declares no manifest. Requires the `api:telemetry:read` ability.
+ */
+declare const getTelemetryManifest: <ThrowOnError extends boolean = false>(options: Options<GetTelemetryManifestData, ThrowOnError>) => RequestResult<GetTelemetryManifestResponses, GetTelemetryManifestErrors, ThrowOnError>;
+/**
+ * List admission requests
+ *
+ * Paginated list of device admission requests across every project this token is scoped to. Filter by `status` (e.g. `pending`) to find requests awaiting review, or by `fingerprint` to resolve the request a specific unit raised. Cursor-based; pass `meta.nextCursor` as the `cursor` query parameter. Requires the `api:admissions:read` ability.
+ */
+declare const listAdmissions: <ThrowOnError extends boolean = false>(options?: Options<ListAdmissionsData, ThrowOnError>) => RequestResult<ListAdmissionsResponses, ListAdmissionsErrors, ThrowOnError>;
+/**
+ * Get an admission request
+ *
+ * Returns the admission request with the given UUID. Must belong to a project this token can read. Requires the `api:admissions:read` ability.
+ */
+declare const getAdmission: <ThrowOnError extends boolean = false>(options: Options<GetAdmissionData, ThrowOnError>) => RequestResult<GetAdmissionResponses, GetAdmissionErrors, ThrowOnError>;
+/**
+ * Accept an admission request
+ *
+ * Approves a pending admission and provisions a new device in the request’s project. The agent that raised the request receives its device token on its next admission poll. A `deviceTypeId` is required (must belong to the same project). Pass the type resolved from the device’s declared model, or another of the project’s types to override it. Requires the `api:admissions:manage` ability.
+ */
+declare const acceptAdmission: <ThrowOnError extends boolean = false>(options: Options<AcceptAdmissionData, ThrowOnError>) => RequestResult<AcceptAdmissionResponses, AcceptAdmissionErrors, ThrowOnError>;
+/**
+ * Reject an admission request
+ *
+ * Rejects a pending admission permanently. No device is provisioned. Requires the `api:admissions:manage` ability.
+ */
+declare const rejectAdmission: <ThrowOnError extends boolean = false>(options: Options<RejectAdmissionData, ThrowOnError>) => RequestResult<RejectAdmissionResponses, RejectAdmissionErrors, ThrowOnError>;
+/**
+ * Dismiss an admission request
+ *
+ * Dismisses a pending admission without provisioning a device and without refusing the unit permanently. Unlike `reject`, this is not a verdict the device has to live with: the next time the same fingerprint asks to enrol, the request reopens as `pending` and appears in the queue again. Use it for "not now" (an unrecognised unit, a fleet you are not ready to admit); use `reject` when the unit must stay out.
+ *
+ * Requires the `api:admissions:manage` ability.
+ */
+declare const dismissAdmission: <ThrowOnError extends boolean = false>(options: Options<DismissAdmissionData, ThrowOnError>) => RequestResult<DismissAdmissionResponses, DismissAdmissionErrors, ThrowOnError>;
+/**
+ * Upload a firmware bundle
+ *
+ * Streams a firmware bundle into project storage and creates the corresponding `firmware_bundles` row. Returns the bundle envelope (id, kind, sha256, sizeBytes, …). The `kind` field selects the image format: `rauc` (default, `.raucb`, Linux A/B) or `mcuboot` (signed MCUboot `.bin` for microcontrollers). Version and hardware target are decoded from the binary where it carries them (rauc: both from the manifest; mcuboot: version from the image header). The `version`/`compatible` form fields are only needed for what the binary lacks (mcuboot target). To roll the bundle out to devices, trigger a deployment via `POST /api/v1/firmware/deployments`. 512 MB hard cap.
+ */
+declare const uploadFirmware: <ThrowOnError extends boolean = false>(options?: Options<UploadFirmwareData, ThrowOnError>) => RequestResult<UploadFirmwareResponses, UploadFirmwareErrors, ThrowOnError>;
+/**
+ * List firmware bundles
+ *
+ * Paginated list of firmware bundles across every project this token is scoped to. Cursor-based; pass `meta.nextCursor` from the previous page as the `cursor` query parameter. Filter by `projectId`, by exact `compatible` target, or by a `version` substring to find the bundle to roll out. Deleted bundles are omitted; their deployment history remains readable through the deployments endpoints. Requires the `api:firmware:read` ability.
+ */
+declare const listFirmwareBundles: <ThrowOnError extends boolean = false>(options?: Options<ListFirmwareBundlesData, ThrowOnError>) => RequestResult<ListFirmwareBundlesResponses, ListFirmwareBundlesErrors, ThrowOnError>;
+/**
+ * Delete a firmware bundle
+ *
+ * Soft-deletes a bundle and frees its stored object; deployment history is retained for audit. A bundle with a genuinely in-flight deployment is refused (409) until it is canceled. Must belong to a project this token can write. Requires the `api:firmware:write` ability.
+ */
+declare const deleteFirmwareBundle: <ThrowOnError extends boolean = false>(options: Options<DeleteFirmwareBundleData, ThrowOnError>) => RequestResult<DeleteFirmwareBundleResponses, DeleteFirmwareBundleErrors, ThrowOnError>;
+/**
+ * Get a firmware bundle
+ *
+ * Returns one bundle: kind, version, hardware target, size and `sha256`, so a caller can verify what it is about to roll out. Requires the `api:firmware:read` ability.
+ */
+declare const getFirmwareBundle: <ThrowOnError extends boolean = false>(options: Options<GetFirmwareBundleData, ThrowOnError>) => RequestResult<GetFirmwareBundleResponses, GetFirmwareBundleErrors, ThrowOnError>;
+/**
+ * List firmware deployments
+ *
+ * Paginated list of firmware deployments across every project this token is scoped to, newest activity first via the opaque cursor. Filter by `deviceId`, `bundleId` or `status` to track a rollout. Requires the `api:firmware:read` ability.
+ */
+declare const listFirmwareDeployments: <ThrowOnError extends boolean = false>(options?: Options<ListFirmwareDeploymentsData, ThrowOnError>) => RequestResult<ListFirmwareDeploymentsResponses, ListFirmwareDeploymentsErrors, ThrowOnError>;
+/**
+ * Trigger a firmware deployment
+ *
+ * Creates one deployment per device for the given bundle and dispatches it immediately to any device that is currently online; offline devices stay `pending` and install on their next reconnect. Every device must belong to the bundle’s project. A device whose recorded hardware compatibility contradicts the bundle’s declared target is rejected (422) before any deployment row is created. Requires the `api:firmware:write` ability.
+ */
+declare const triggerFirmwareDeployment: <ThrowOnError extends boolean = false>(options?: Options<TriggerFirmwareDeploymentData, ThrowOnError>) => RequestResult<TriggerFirmwareDeploymentResponses, TriggerFirmwareDeploymentErrors, ThrowOnError>;
+/**
+ * Get a firmware deployment
+ *
+ * Returns the current state of a single deployment (status, phase, progress %, and any error or install result reported by the agent). Poll this to follow a rollout. Requires the `api:firmware:read` ability.
+ */
+declare const getFirmwareDeployment: <ThrowOnError extends boolean = false>(options: Options<GetFirmwareDeploymentData, ThrowOnError>) => RequestResult<GetFirmwareDeploymentResponses, GetFirmwareDeploymentErrors, ThrowOnError>;
+/**
+ * Cancel a firmware deployment
+ *
+ * Marks a deployment `canceled`. A `pending` deployment (the device has not picked it up yet) cancels with no flag. One already in flight (`downloading` / `installing`) requires `force: true`, because the device may be partway through an install; the forced abort is recorded in the deployment’s `error` and `message`. A deployment that already reached a terminal state is refused with 409. Cancelling is what unblocks deleting the bundle, which is refused while a deployment is genuinely in flight. Requires the `api:firmware:write` ability.
+ */
+declare const cancelFirmwareDeployment: <ThrowOnError extends boolean = false>(options: Options<CancelFirmwareDeploymentData, ThrowOnError>) => RequestResult<CancelFirmwareDeploymentResponses, CancelFirmwareDeploymentErrors, ThrowOnError>;
+/**
+ * Roll back a firmware deployment
+ *
+ * Issues a real rollback for the device behind a succeeded deployment: a RAUC slot-status flip on a gateway, or an MCUboot test-swap back to the previous image on an MCU. This creates and returns a *new* synthetic deployment row (not the source one) so a poller can follow the rollback the same way it follows a forward rollout. The device must be online, since the bootloader state being flipped is only valid right now. Requires the `api:firmware:write` ability.
+ */
+declare const rollbackFirmwareDeployment: <ThrowOnError extends boolean = false>(options: Options<RollbackFirmwareDeploymentData, ThrowOnError>) => RequestResult<RollbackFirmwareDeploymentResponses, RollbackFirmwareDeploymentErrors, ThrowOnError>;
+/**
+ * Run a command on a device
+ *
+ * Dispatches a declared command (name + typed args) to the device over the MQTT data plane. The command is validated against the device type's command manifest before publishing: an undeclared name, a missing required arg, or a wrongly-typed arg is rejected with 422. See `GET /api/v1/devices/{id}/commands` for the declared set. Delivery follows the device type's dispatch profile: `interactive` devices run it now and the call returns 200 with the result (or 502 if offline); `queued` devices accept it for store-and-forward delivery on their next check-in and the call returns 202 with `{ invocationId, status, queued: true }`. Poll `GET /api/v1/devices/{id}/commands/{invocationId}` for the eventual result. Requires the `api:command:exec` ability and project scope over the device. Audited.
+ */
+declare const execDeviceCommand: <ThrowOnError extends boolean = false>(options: Options<ExecDeviceCommandData, ThrowOnError>) => RequestResult<ExecDeviceCommandResponses, ExecDeviceCommandErrors, ThrowOnError>;
+/**
+ * Get a command invocation result
+ *
+ * Returns the durable record of a single command invocation. Its lifecycle `status` and, once terminal, its result (`success`, `exitCode`, `output`, `error`, `durationMs`). This is the pull counterpart to the `command.result` webhook: poll it after a queued (202) dispatch to retrieve the eventual outcome, so a missed or unsubscribed webhook delivery never makes a recorded result unrecoverable. The `invocationId` is the value returned by `POST /api/v1/devices/{id}/command`. Requires the `api:command:exec` ability and project scope over the device.
+ */
+declare const getDeviceCommandInvocation: <ThrowOnError extends boolean = false>(options: Options<GetDeviceCommandInvocationData, ThrowOnError>) => RequestResult<GetDeviceCommandInvocationResponses, GetDeviceCommandInvocationErrors, ThrowOnError>;
+/**
+ * Commands a device supports
+ *
+ * The command manifest of the device's type, i.e. the declared commands (name + typed arg schema) that `POST /api/v1/devices/{id}/command` will accept for this device. `null` when the device type declares no manifest (every command is then rejected with 422). Requires the `api:devices:read` ability.
+ */
+declare const getDeviceCommands: <ThrowOnError extends boolean = false>(options: Options<GetDeviceCommandsData, ThrowOnError>) => RequestResult<GetDeviceCommandsResponses, GetDeviceCommandsErrors, ThrowOnError>;
+/**
+ * Delete the command manifest of a device type
+ *
+ * Clears the declared command manifest. Devices of this type then reject every command with 422 until a new manifest is declared. Requires the `api:device-types:manage` ability.
+ */
+declare const deleteCommandManifest: <ThrowOnError extends boolean = false>(options: Options<DeleteCommandManifestData, ThrowOnError>) => RequestResult<DeleteCommandManifestResponses, DeleteCommandManifestErrors, ThrowOnError>;
+/**
+ * Command manifest for a device type
+ *
+ * The declared command manifest for the device type with the given slug, or `null` when none is declared. Requires the `api:devices:read` ability.
+ */
+declare const getCommandManifest: <ThrowOnError extends boolean = false>(options: Options<GetCommandManifestData, ThrowOnError>) => RequestResult<GetCommandManifestResponses, GetCommandManifestErrors, ThrowOnError>;
+/**
+ * Declare the command manifest for a device type
+ *
+ * Replaces the whole command manifest document for the device type (it is a single contract, not a collection of rows). Takes effect immediately: subsequent `POST /api/v1/devices/{id}/command` calls are validated against the new manifest. Requires the `api:device-types:manage` ability.
+ */
+declare const updateCommandManifest: <ThrowOnError extends boolean = false>(options: Options<UpdateCommandManifestData, ThrowOnError>) => RequestResult<UpdateCommandManifestResponses, UpdateCommandManifestErrors, ThrowOnError>;
+/**
+ * List device types in a project
+ *
+ * Paginated list of the project’s device types. Cursor-based; pass `meta.nextCursor` from the previous page as the `cursor` query parameter. List items carry manifest **counts** rather than the manifests themselves. Read one type to get those in full.
+ *
+ * Requires `api:devices:read`.
+ */
+declare const listDeviceTypes: <ThrowOnError extends boolean = false>(options: Options<ListDeviceTypesData, ThrowOnError>) => RequestResult<ListDeviceTypesResponses, ListDeviceTypesErrors, ThrowOnError>;
+/**
+ * Create a device type
+ *
+ * Declares a device type in the project. The owning project comes from the path, not the body, because device types are project-scoped and never created org-wide (#47). `version` defaults to `1.0.0`.
+ *
+ * Requires `api:device-types:manage`.
+ */
+declare const createDeviceType: <ThrowOnError extends boolean = false>(options: Options<CreateDeviceTypeData, ThrowOnError>) => RequestResult<CreateDeviceTypeResponses, CreateDeviceTypeErrors, ThrowOnError>;
+/**
+ * Delete a device type
+ *
+ * Deletes a device type that no device is using. A device’s type is mandatory (#238) and the foreign key is `RESTRICT`, so a type still assigned to devices is refused with 409 and the count, so reassign or delete those devices first.
+ *
+ * Requires `api:device-types:manage`.
+ */
+declare const deleteDeviceType: <ThrowOnError extends boolean = false>(options: Options<DeleteDeviceTypeData, ThrowOnError>) => RequestResult<DeleteDeviceTypeResponses, DeleteDeviceTypeErrors, ThrowOnError>;
+/**
+ * Get a device type
+ *
+ * One device type by slug, with its telemetry, command and USB manifests in full. Requires `api:devices:read`.
+ */
+declare const getDeviceType: <ThrowOnError extends boolean = false>(options: Options<GetDeviceTypeData, ThrowOnError>) => RequestResult<GetDeviceTypeResponses, GetDeviceTypeErrors, ThrowOnError>;
+/**
+ * Update a device type
+ *
+ * Partial update: every field is optional and only the ones sent change. The slug is the identifier and cannot be changed; create a new type instead. Sending a manifest replaces it wholesale rather than merging into it.
+ *
+ * Requires `api:device-types:manage`.
+ */
+declare const updateDeviceType: <ThrowOnError extends boolean = false>(options: Options<UpdateDeviceTypeData, ThrowOnError>) => RequestResult<UpdateDeviceTypeResponses, UpdateDeviceTypeErrors, ThrowOnError>;
+/**
+ * List webhook subscriptions
+ *
+ * Paginated list of webhook subscriptions across every project this token is scoped to. Requires the `api:webhooks:read` ability.
+ */
+declare const listWebhooks: <ThrowOnError extends boolean = false>(options?: Options<ListWebhooksData, ThrowOnError>) => RequestResult<ListWebhooksResponses, ListWebhooksErrors, ThrowOnError>;
+/**
+ * Create a webhook subscription
+ *
+ * Registers an endpoint that receives signed device events for the given project. The response includes the HMAC signing `secret` **exactly once**. Store it now; it cannot be retrieved again (delete and recreate the subscription to rotate it). URLs must be https in production and must not target private/internal addresses. Requires the `api:webhooks:manage` ability.
+ */
+declare const createWebhook: <ThrowOnError extends boolean = false>(options?: Options<CreateWebhookData, ThrowOnError>) => RequestResult<CreateWebhookResponses, CreateWebhookErrors, ThrowOnError>;
+/**
+ * Delete a webhook subscription
+ *
+ * Deletes the subscription and its delivery log. Requires the `api:webhooks:manage` ability.
+ */
+declare const deleteWebhook: <ThrowOnError extends boolean = false>(options: Options<DeleteWebhookData, ThrowOnError>) => RequestResult<DeleteWebhookResponses, DeleteWebhookErrors, ThrowOnError>;
+/**
+ * Get a webhook subscription
+ *
+ * Returns the subscription with the given UUID (without its secret). Requires the `api:webhooks:read` ability.
+ */
+declare const getWebhook: <ThrowOnError extends boolean = false>(options: Options<GetWebhookData, ThrowOnError>) => RequestResult<GetWebhookResponses, GetWebhookErrors, ThrowOnError>;
+/**
+ * Update a webhook subscription
+ *
+ * Updates the URL, event-type filter and/or enabled flag. Re-enabling a subscription resets its failure counter. Requires the `api:webhooks:manage` ability.
+ */
+declare const updateWebhook: <ThrowOnError extends boolean = false>(options: Options<UpdateWebhookData, ThrowOnError>) => RequestResult<UpdateWebhookResponses, UpdateWebhookErrors, ThrowOnError>;
+/**
+ * List deliveries for a webhook subscription
+ *
+ * Attempt log of recent deliveries (newest first): status, attempt count, last HTTP status / error, and retry schedule. Requires the `api:webhooks:read` ability.
+ */
+declare const listWebhookDeliveries: <ThrowOnError extends boolean = false>(options: Options<ListWebhookDeliveriesData, ThrowOnError>) => RequestResult<ListWebhookDeliveriesResponses, ListWebhookDeliveriesErrors, ThrowOnError>;
+
+type index_AcceptAdmissionData = AcceptAdmissionData;
+type index_AcceptAdmissionError = AcceptAdmissionError;
+type index_AcceptAdmissionErrors = AcceptAdmissionErrors;
+type index_AcceptAdmissionResponse = AcceptAdmissionResponse;
+type index_AcceptAdmissionResponses = AcceptAdmissionResponses;
+type index_Admission = Admission;
+type index_AdmissionAcceptRequest = AdmissionAcceptRequest;
+type index_AdmissionAcceptResponse = AdmissionAcceptResponse;
+type index_AdmissionListPage = AdmissionListPage;
+type index_CancelFirmwareDeploymentData = CancelFirmwareDeploymentData;
+type index_CancelFirmwareDeploymentError = CancelFirmwareDeploymentError;
+type index_CancelFirmwareDeploymentErrors = CancelFirmwareDeploymentErrors;
+type index_CancelFirmwareDeploymentResponse = CancelFirmwareDeploymentResponse;
+type index_CancelFirmwareDeploymentResponses = CancelFirmwareDeploymentResponses;
+type index_CommandArgDefinition = CommandArgDefinition;
+type index_CommandDefinition = CommandDefinition;
+type index_CommandInvocation = CommandInvocation;
+type index_CommandManifest = CommandManifest;
+type index_CommandRequest = CommandRequest;
+type index_CommandResult = CommandResult;
+type index_CreateDeviceTypeData = CreateDeviceTypeData;
+type index_CreateDeviceTypeError = CreateDeviceTypeError;
+type index_CreateDeviceTypeErrors = CreateDeviceTypeErrors;
+type index_CreateDeviceTypeResponse = CreateDeviceTypeResponse;
+type index_CreateDeviceTypeResponses = CreateDeviceTypeResponses;
+type index_CreateProjectAppTokenData = CreateProjectAppTokenData;
+type index_CreateProjectAppTokenError = CreateProjectAppTokenError;
+type index_CreateProjectAppTokenErrors = CreateProjectAppTokenErrors;
+type index_CreateProjectAppTokenResponse = CreateProjectAppTokenResponse;
+type index_CreateProjectAppTokenResponses = CreateProjectAppTokenResponses;
+type index_CreateWebhookData = CreateWebhookData;
+type index_CreateWebhookError = CreateWebhookError;
+type index_CreateWebhookErrors = CreateWebhookErrors;
+type index_CreateWebhookResponse = CreateWebhookResponse;
+type index_CreateWebhookResponses = CreateWebhookResponses;
+type index_DeleteCommandManifestData = DeleteCommandManifestData;
+type index_DeleteCommandManifestError = DeleteCommandManifestError;
+type index_DeleteCommandManifestErrors = DeleteCommandManifestErrors;
+type index_DeleteCommandManifestResponses = DeleteCommandManifestResponses;
+type index_DeleteDeviceData = DeleteDeviceData;
+type index_DeleteDeviceError = DeleteDeviceError;
+type index_DeleteDeviceErrors = DeleteDeviceErrors;
+type index_DeleteDeviceResponses = DeleteDeviceResponses;
+type index_DeleteDeviceTypeData = DeleteDeviceTypeData;
+type index_DeleteDeviceTypeError = DeleteDeviceTypeError;
+type index_DeleteDeviceTypeErrors = DeleteDeviceTypeErrors;
+type index_DeleteDeviceTypeResponses = DeleteDeviceTypeResponses;
+type index_DeleteFirmwareBundleData = DeleteFirmwareBundleData;
+type index_DeleteFirmwareBundleError = DeleteFirmwareBundleError;
+type index_DeleteFirmwareBundleErrors = DeleteFirmwareBundleErrors;
+type index_DeleteFirmwareBundleResponses = DeleteFirmwareBundleResponses;
+type index_DeleteWebhookData = DeleteWebhookData;
+type index_DeleteWebhookError = DeleteWebhookError;
+type index_DeleteWebhookErrors = DeleteWebhookErrors;
+type index_DeleteWebhookResponses = DeleteWebhookResponses;
+type index_Device = Device;
+type index_DeviceListItem = DeviceListItem;
+type index_DeviceListPage = DeviceListPage;
+type index_DeviceTokenReset = DeviceTokenReset;
+type index_DeviceType = DeviceType;
+type index_DeviceTypeCreateRequest = DeviceTypeCreateRequest;
+type index_DeviceTypeListItem = DeviceTypeListItem;
+type index_DeviceTypeListPage = DeviceTypeListPage;
+type index_DeviceTypeUpdateRequest = DeviceTypeUpdateRequest;
+type index_DismissAdmissionData = DismissAdmissionData;
+type index_DismissAdmissionError = DismissAdmissionError;
+type index_DismissAdmissionErrors = DismissAdmissionErrors;
+type index_DismissAdmissionResponse = DismissAdmissionResponse;
+type index_DismissAdmissionResponses = DismissAdmissionResponses;
+type index_ErrorItem = ErrorItem;
+type index_ErrorResponse = ErrorResponse;
+type index_ExecDeviceCommandData = ExecDeviceCommandData;
+type index_ExecDeviceCommandError = ExecDeviceCommandError;
+type index_ExecDeviceCommandErrors = ExecDeviceCommandErrors;
+type index_ExecDeviceCommandResponse = ExecDeviceCommandResponse;
+type index_ExecDeviceCommandResponses = ExecDeviceCommandResponses;
+type index_FirmwareBundle = FirmwareBundle;
+type index_FirmwareBundleListPage = FirmwareBundleListPage;
+type index_FirmwareConflictResponse = FirmwareConflictResponse;
+type index_FirmwareDeployment = FirmwareDeployment;
+type index_FirmwareDeploymentCancelRequest = FirmwareDeploymentCancelRequest;
+type index_FirmwareDeploymentListPage = FirmwareDeploymentListPage;
+type index_FirmwareDeploymentRollbackRequest = FirmwareDeploymentRollbackRequest;
+type index_FirmwareDeploymentTriggerRequest = FirmwareDeploymentTriggerRequest;
+type index_FirmwareDeploymentTriggerResponse = FirmwareDeploymentTriggerResponse;
+type index_FirmwareUploadRequest = FirmwareUploadRequest;
+type index_FirmwareUploadResponse = FirmwareUploadResponse;
+type index_GetAdmissionData = GetAdmissionData;
+type index_GetAdmissionError = GetAdmissionError;
+type index_GetAdmissionErrors = GetAdmissionErrors;
+type index_GetAdmissionResponse = GetAdmissionResponse;
+type index_GetAdmissionResponses = GetAdmissionResponses;
+type index_GetCommandManifestData = GetCommandManifestData;
+type index_GetCommandManifestError = GetCommandManifestError;
+type index_GetCommandManifestErrors = GetCommandManifestErrors;
+type index_GetCommandManifestResponse = GetCommandManifestResponse;
+type index_GetCommandManifestResponses = GetCommandManifestResponses;
+type index_GetDeviceCommandInvocationData = GetDeviceCommandInvocationData;
+type index_GetDeviceCommandInvocationError = GetDeviceCommandInvocationError;
+type index_GetDeviceCommandInvocationErrors = GetDeviceCommandInvocationErrors;
+type index_GetDeviceCommandInvocationResponse = GetDeviceCommandInvocationResponse;
+type index_GetDeviceCommandInvocationResponses = GetDeviceCommandInvocationResponses;
+type index_GetDeviceCommandsData = GetDeviceCommandsData;
+type index_GetDeviceCommandsError = GetDeviceCommandsError;
+type index_GetDeviceCommandsErrors = GetDeviceCommandsErrors;
+type index_GetDeviceCommandsResponse = GetDeviceCommandsResponse;
+type index_GetDeviceCommandsResponses = GetDeviceCommandsResponses;
+type index_GetDeviceData = GetDeviceData;
+type index_GetDeviceError = GetDeviceError;
+type index_GetDeviceErrors = GetDeviceErrors;
+type index_GetDeviceResponse = GetDeviceResponse;
+type index_GetDeviceResponses = GetDeviceResponses;
+type index_GetDeviceTypeData = GetDeviceTypeData;
+type index_GetDeviceTypeError = GetDeviceTypeError;
+type index_GetDeviceTypeErrors = GetDeviceTypeErrors;
+type index_GetDeviceTypeResponse = GetDeviceTypeResponse;
+type index_GetDeviceTypeResponses = GetDeviceTypeResponses;
+type index_GetFirmwareBundleData = GetFirmwareBundleData;
+type index_GetFirmwareBundleError = GetFirmwareBundleError;
+type index_GetFirmwareBundleErrors = GetFirmwareBundleErrors;
+type index_GetFirmwareBundleResponse = GetFirmwareBundleResponse;
+type index_GetFirmwareBundleResponses = GetFirmwareBundleResponses;
+type index_GetFirmwareDeploymentData = GetFirmwareDeploymentData;
+type index_GetFirmwareDeploymentError = GetFirmwareDeploymentError;
+type index_GetFirmwareDeploymentErrors = GetFirmwareDeploymentErrors;
+type index_GetFirmwareDeploymentResponse = GetFirmwareDeploymentResponse;
+type index_GetFirmwareDeploymentResponses = GetFirmwareDeploymentResponses;
+type index_GetIdentityData = GetIdentityData;
+type index_GetIdentityError = GetIdentityError;
+type index_GetIdentityErrors = GetIdentityErrors;
+type index_GetIdentityResponse = GetIdentityResponse;
+type index_GetIdentityResponses = GetIdentityResponses;
+type index_GetLatestTelemetryData = GetLatestTelemetryData;
+type index_GetLatestTelemetryError = GetLatestTelemetryError;
+type index_GetLatestTelemetryErrors = GetLatestTelemetryErrors;
+type index_GetLatestTelemetryResponse = GetLatestTelemetryResponse;
+type index_GetLatestTelemetryResponses = GetLatestTelemetryResponses;
+type index_GetProjectData = GetProjectData;
+type index_GetProjectError = GetProjectError;
+type index_GetProjectErrors = GetProjectErrors;
+type index_GetProjectResponse = GetProjectResponse;
+type index_GetProjectResponses = GetProjectResponses;
+type index_GetTelemetryHistoryData = GetTelemetryHistoryData;
+type index_GetTelemetryHistoryError = GetTelemetryHistoryError;
+type index_GetTelemetryHistoryErrors = GetTelemetryHistoryErrors;
+type index_GetTelemetryHistoryResponse = GetTelemetryHistoryResponse;
+type index_GetTelemetryHistoryResponses = GetTelemetryHistoryResponses;
+type index_GetTelemetryManifestData = GetTelemetryManifestData;
+type index_GetTelemetryManifestError = GetTelemetryManifestError;
+type index_GetTelemetryManifestErrors = GetTelemetryManifestErrors;
+type index_GetTelemetryManifestResponse = GetTelemetryManifestResponse;
+type index_GetTelemetryManifestResponses = GetTelemetryManifestResponses;
+type index_GetWebhookData = GetWebhookData;
+type index_GetWebhookError = GetWebhookError;
+type index_GetWebhookErrors = GetWebhookErrors;
+type index_GetWebhookResponse = GetWebhookResponse;
+type index_GetWebhookResponses = GetWebhookResponses;
+type index_Identity = Identity;
+type index_IdentityProject = IdentityProject;
+type index_IdentityToken = IdentityToken;
+type index_IdentityUser = IdentityUser;
+type index_ListAdmissionsData = ListAdmissionsData;
+type index_ListAdmissionsError = ListAdmissionsError;
+type index_ListAdmissionsErrors = ListAdmissionsErrors;
+type index_ListAdmissionsResponse = ListAdmissionsResponse;
+type index_ListAdmissionsResponses = ListAdmissionsResponses;
+type index_ListDeviceTypesData = ListDeviceTypesData;
+type index_ListDeviceTypesError = ListDeviceTypesError;
+type index_ListDeviceTypesErrors = ListDeviceTypesErrors;
+type index_ListDeviceTypesResponse = ListDeviceTypesResponse;
+type index_ListDeviceTypesResponses = ListDeviceTypesResponses;
+type index_ListDevicesData = ListDevicesData;
+type index_ListDevicesError = ListDevicesError;
+type index_ListDevicesErrors = ListDevicesErrors;
+type index_ListDevicesResponse = ListDevicesResponse;
+type index_ListDevicesResponses = ListDevicesResponses;
+type index_ListFirmwareBundlesData = ListFirmwareBundlesData;
+type index_ListFirmwareBundlesError = ListFirmwareBundlesError;
+type index_ListFirmwareBundlesErrors = ListFirmwareBundlesErrors;
+type index_ListFirmwareBundlesResponse = ListFirmwareBundlesResponse;
+type index_ListFirmwareBundlesResponses = ListFirmwareBundlesResponses;
+type index_ListFirmwareDeploymentsData = ListFirmwareDeploymentsData;
+type index_ListFirmwareDeploymentsError = ListFirmwareDeploymentsError;
+type index_ListFirmwareDeploymentsErrors = ListFirmwareDeploymentsErrors;
+type index_ListFirmwareDeploymentsResponse = ListFirmwareDeploymentsResponse;
+type index_ListFirmwareDeploymentsResponses = ListFirmwareDeploymentsResponses;
+type index_ListProjectsData = ListProjectsData;
+type index_ListProjectsError = ListProjectsError;
+type index_ListProjectsErrors = ListProjectsErrors;
+type index_ListProjectsResponse = ListProjectsResponse;
+type index_ListProjectsResponses = ListProjectsResponses;
+type index_ListWebhookDeliveriesData = ListWebhookDeliveriesData;
+type index_ListWebhookDeliveriesError = ListWebhookDeliveriesError;
+type index_ListWebhookDeliveriesErrors = ListWebhookDeliveriesErrors;
+type index_ListWebhookDeliveriesResponse = ListWebhookDeliveriesResponse;
+type index_ListWebhookDeliveriesResponses = ListWebhookDeliveriesResponses;
+type index_ListWebhooksData = ListWebhooksData;
+type index_ListWebhooksError = ListWebhooksError;
+type index_ListWebhooksErrors = ListWebhooksErrors;
+type index_ListWebhooksResponse = ListWebhooksResponse;
+type index_ListWebhooksResponses = ListWebhooksResponses;
+type index_MetricDefinition = MetricDefinition;
+type index_MetricGroup = MetricGroup;
+type index_Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options<TData, ThrowOnError, TResponse>;
+type index_PageMeta = PageMeta;
+type index_Project = Project;
+type index_ProjectAppToken = ProjectAppToken;
+type index_ProjectListPage = ProjectListPage;
+type index_RejectAdmissionData = RejectAdmissionData;
+type index_RejectAdmissionError = RejectAdmissionError;
+type index_RejectAdmissionErrors = RejectAdmissionErrors;
+type index_RejectAdmissionResponse = RejectAdmissionResponse;
+type index_RejectAdmissionResponses = RejectAdmissionResponses;
+type index_ResetDeviceTokenData = ResetDeviceTokenData;
+type index_ResetDeviceTokenError = ResetDeviceTokenError;
+type index_ResetDeviceTokenErrors = ResetDeviceTokenErrors;
+type index_ResetDeviceTokenResponse = ResetDeviceTokenResponse;
+type index_ResetDeviceTokenResponses = ResetDeviceTokenResponses;
+type index_RollbackFirmwareDeploymentData = RollbackFirmwareDeploymentData;
+type index_RollbackFirmwareDeploymentError = RollbackFirmwareDeploymentError;
+type index_RollbackFirmwareDeploymentErrors = RollbackFirmwareDeploymentErrors;
+type index_RollbackFirmwareDeploymentResponse = RollbackFirmwareDeploymentResponse;
+type index_RollbackFirmwareDeploymentResponses = RollbackFirmwareDeploymentResponses;
+type index_RotateProjectAppTokenData = RotateProjectAppTokenData;
+type index_RotateProjectAppTokenError = RotateProjectAppTokenError;
+type index_RotateProjectAppTokenErrors = RotateProjectAppTokenErrors;
+type index_RotateProjectAppTokenResponse = RotateProjectAppTokenResponse;
+type index_RotateProjectAppTokenResponses = RotateProjectAppTokenResponses;
+type index_TelemetryHistory = TelemetryHistory;
+type index_TelemetryManifest = TelemetryManifest;
+type index_TelemetrySample = TelemetrySample;
+type index_TriggerFirmwareDeploymentData = TriggerFirmwareDeploymentData;
+type index_TriggerFirmwareDeploymentError = TriggerFirmwareDeploymentError;
+type index_TriggerFirmwareDeploymentErrors = TriggerFirmwareDeploymentErrors;
+type index_TriggerFirmwareDeploymentResponse = TriggerFirmwareDeploymentResponse;
+type index_TriggerFirmwareDeploymentResponses = TriggerFirmwareDeploymentResponses;
+type index_UpdateCommandManifestData = UpdateCommandManifestData;
+type index_UpdateCommandManifestError = UpdateCommandManifestError;
+type index_UpdateCommandManifestErrors = UpdateCommandManifestErrors;
+type index_UpdateCommandManifestResponse = UpdateCommandManifestResponse;
+type index_UpdateCommandManifestResponses = UpdateCommandManifestResponses;
+type index_UpdateDeviceTypeData = UpdateDeviceTypeData;
+type index_UpdateDeviceTypeError = UpdateDeviceTypeError;
+type index_UpdateDeviceTypeErrors = UpdateDeviceTypeErrors;
+type index_UpdateDeviceTypeResponse = UpdateDeviceTypeResponse;
+type index_UpdateDeviceTypeResponses = UpdateDeviceTypeResponses;
+type index_UpdateWebhookData = UpdateWebhookData;
+type index_UpdateWebhookError = UpdateWebhookError;
+type index_UpdateWebhookErrors = UpdateWebhookErrors;
+type index_UpdateWebhookResponse = UpdateWebhookResponse;
+type index_UpdateWebhookResponses = UpdateWebhookResponses;
+type index_UploadFirmwareData = UploadFirmwareData;
+type index_UploadFirmwareError = UploadFirmwareError;
+type index_UploadFirmwareErrors = UploadFirmwareErrors;
+type index_UploadFirmwareResponse = UploadFirmwareResponse;
+type index_UploadFirmwareResponses = UploadFirmwareResponses;
+type index_WebhookCreateRequest = WebhookCreateRequest;
+type index_WebhookCreateResponse = WebhookCreateResponse;
+type index_WebhookDelivery = WebhookDelivery;
+type index_WebhookDeliveryAttempt = WebhookDeliveryAttempt;
+type index_WebhookDeliveryPage = WebhookDeliveryPage;
+type index_WebhookEventType = WebhookEventType;
+type index_WebhookRetryPolicy = WebhookRetryPolicy;
+type index_WebhookSubscription = WebhookSubscription;
+type index_WebhookSubscriptionPage = WebhookSubscriptionPage;
+type index_WebhookUpdateRequest = WebhookUpdateRequest;
+declare const index_acceptAdmission: typeof acceptAdmission;
+declare const index_cancelFirmwareDeployment: typeof cancelFirmwareDeployment;
+declare const index_createDeviceType: typeof createDeviceType;
+declare const index_createProjectAppToken: typeof createProjectAppToken;
+declare const index_createWebhook: typeof createWebhook;
+declare const index_deleteCommandManifest: typeof deleteCommandManifest;
+declare const index_deleteDevice: typeof deleteDevice;
+declare const index_deleteDeviceType: typeof deleteDeviceType;
+declare const index_deleteFirmwareBundle: typeof deleteFirmwareBundle;
+declare const index_deleteWebhook: typeof deleteWebhook;
+declare const index_dismissAdmission: typeof dismissAdmission;
+declare const index_execDeviceCommand: typeof execDeviceCommand;
+declare const index_getAdmission: typeof getAdmission;
+declare const index_getCommandManifest: typeof getCommandManifest;
+declare const index_getDevice: typeof getDevice;
+declare const index_getDeviceCommandInvocation: typeof getDeviceCommandInvocation;
+declare const index_getDeviceCommands: typeof getDeviceCommands;
+declare const index_getDeviceType: typeof getDeviceType;
+declare const index_getFirmwareBundle: typeof getFirmwareBundle;
+declare const index_getFirmwareDeployment: typeof getFirmwareDeployment;
+declare const index_getIdentity: typeof getIdentity;
+declare const index_getLatestTelemetry: typeof getLatestTelemetry;
+declare const index_getProject: typeof getProject;
+declare const index_getTelemetryHistory: typeof getTelemetryHistory;
+declare const index_getTelemetryManifest: typeof getTelemetryManifest;
+declare const index_getWebhook: typeof getWebhook;
+declare const index_listAdmissions: typeof listAdmissions;
+declare const index_listDeviceTypes: typeof listDeviceTypes;
+declare const index_listDevices: typeof listDevices;
+declare const index_listFirmwareBundles: typeof listFirmwareBundles;
+declare const index_listFirmwareDeployments: typeof listFirmwareDeployments;
+declare const index_listProjects: typeof listProjects;
+declare const index_listWebhookDeliveries: typeof listWebhookDeliveries;
+declare const index_listWebhooks: typeof listWebhooks;
+declare const index_rejectAdmission: typeof rejectAdmission;
+declare const index_resetDeviceToken: typeof resetDeviceToken;
+declare const index_rollbackFirmwareDeployment: typeof rollbackFirmwareDeployment;
+declare const index_rotateProjectAppToken: typeof rotateProjectAppToken;
+declare const index_triggerFirmwareDeployment: typeof triggerFirmwareDeployment;
+declare const index_updateCommandManifest: typeof updateCommandManifest;
+declare const index_updateDeviceType: typeof updateDeviceType;
+declare const index_updateWebhook: typeof updateWebhook;
+declare const index_uploadFirmware: typeof uploadFirmware;
+declare namespace index {
+  export { type index_AcceptAdmissionData as AcceptAdmissionData, type index_AcceptAdmissionError as AcceptAdmissionError, type index_AcceptAdmissionErrors as AcceptAdmissionErrors, type index_AcceptAdmissionResponse as AcceptAdmissionResponse, type index_AcceptAdmissionResponses as AcceptAdmissionResponses, type index_Admission as Admission, type index_AdmissionAcceptRequest as AdmissionAcceptRequest, type index_AdmissionAcceptResponse as AdmissionAcceptResponse, type index_AdmissionListPage as AdmissionListPage, type index_CancelFirmwareDeploymentData as CancelFirmwareDeploymentData, type index_CancelFirmwareDeploymentError as CancelFirmwareDeploymentError, type index_CancelFirmwareDeploymentErrors as CancelFirmwareDeploymentErrors, type index_CancelFirmwareDeploymentResponse as CancelFirmwareDeploymentResponse, type index_CancelFirmwareDeploymentResponses as CancelFirmwareDeploymentResponses, type ClientOptions$1 as ClientOptions, type index_CommandArgDefinition as CommandArgDefinition, type index_CommandDefinition as CommandDefinition, type index_CommandInvocation as CommandInvocation, type index_CommandManifest as CommandManifest, type index_CommandRequest as CommandRequest, type index_CommandResult as CommandResult, type index_CreateDeviceTypeData as CreateDeviceTypeData, type index_CreateDeviceTypeError as CreateDeviceTypeError, type index_CreateDeviceTypeErrors as CreateDeviceTypeErrors, type index_CreateDeviceTypeResponse as CreateDeviceTypeResponse, type index_CreateDeviceTypeResponses as CreateDeviceTypeResponses, type index_CreateProjectAppTokenData as CreateProjectAppTokenData, type index_CreateProjectAppTokenError as CreateProjectAppTokenError, type index_CreateProjectAppTokenErrors as CreateProjectAppTokenErrors, type index_CreateProjectAppTokenResponse as CreateProjectAppTokenResponse, type index_CreateProjectAppTokenResponses as CreateProjectAppTokenResponses, type index_CreateWebhookData as CreateWebhookData, type index_CreateWebhookError as CreateWebhookError, type index_CreateWebhookErrors as CreateWebhookErrors, type index_CreateWebhookResponse as CreateWebhookResponse, type index_CreateWebhookResponses as CreateWebhookResponses, type index_DeleteCommandManifestData as DeleteCommandManifestData, type index_DeleteCommandManifestError as DeleteCommandManifestError, type index_DeleteCommandManifestErrors as DeleteCommandManifestErrors, type index_DeleteCommandManifestResponses as DeleteCommandManifestResponses, type index_DeleteDeviceData as DeleteDeviceData, type index_DeleteDeviceError as DeleteDeviceError, type index_DeleteDeviceErrors as DeleteDeviceErrors, type index_DeleteDeviceResponses as DeleteDeviceResponses, type index_DeleteDeviceTypeData as DeleteDeviceTypeData, type index_DeleteDeviceTypeError as DeleteDeviceTypeError, type index_DeleteDeviceTypeErrors as DeleteDeviceTypeErrors, type index_DeleteDeviceTypeResponses as DeleteDeviceTypeResponses, type index_DeleteFirmwareBundleData as DeleteFirmwareBundleData, type index_DeleteFirmwareBundleError as DeleteFirmwareBundleError, type index_DeleteFirmwareBundleErrors as DeleteFirmwareBundleErrors, type index_DeleteFirmwareBundleResponses as DeleteFirmwareBundleResponses, type index_DeleteWebhookData as DeleteWebhookData, type index_DeleteWebhookError as DeleteWebhookError, type index_DeleteWebhookErrors as DeleteWebhookErrors, type index_DeleteWebhookResponses as DeleteWebhookResponses, type index_Device as Device, type index_DeviceListItem as DeviceListItem, type index_DeviceListPage as DeviceListPage, type index_DeviceTokenReset as DeviceTokenReset, type index_DeviceType as DeviceType, type index_DeviceTypeCreateRequest as DeviceTypeCreateRequest, type index_DeviceTypeListItem as DeviceTypeListItem, type index_DeviceTypeListPage as DeviceTypeListPage, type index_DeviceTypeUpdateRequest as DeviceTypeUpdateRequest, type index_DismissAdmissionData as DismissAdmissionData, type index_DismissAdmissionError as DismissAdmissionError, type index_DismissAdmissionErrors as DismissAdmissionErrors, type index_DismissAdmissionResponse as DismissAdmissionResponse, type index_DismissAdmissionResponses as DismissAdmissionResponses, type index_ErrorItem as ErrorItem, type index_ErrorResponse as ErrorResponse, type index_ExecDeviceCommandData as ExecDeviceCommandData, type index_ExecDeviceCommandError as ExecDeviceCommandError, type index_ExecDeviceCommandErrors as ExecDeviceCommandErrors, type index_ExecDeviceCommandResponse as ExecDeviceCommandResponse, type index_ExecDeviceCommandResponses as ExecDeviceCommandResponses, type index_FirmwareBundle as FirmwareBundle, type index_FirmwareBundleListPage as FirmwareBundleListPage, type index_FirmwareConflictResponse as FirmwareConflictResponse, type index_FirmwareDeployment as FirmwareDeployment, type index_FirmwareDeploymentCancelRequest as FirmwareDeploymentCancelRequest, type index_FirmwareDeploymentListPage as FirmwareDeploymentListPage, type index_FirmwareDeploymentRollbackRequest as FirmwareDeploymentRollbackRequest, type index_FirmwareDeploymentTriggerRequest as FirmwareDeploymentTriggerRequest, type index_FirmwareDeploymentTriggerResponse as FirmwareDeploymentTriggerResponse, type index_FirmwareUploadRequest as FirmwareUploadRequest, type index_FirmwareUploadResponse as FirmwareUploadResponse, type index_GetAdmissionData as GetAdmissionData, type index_GetAdmissionError as GetAdmissionError, type index_GetAdmissionErrors as GetAdmissionErrors, type index_GetAdmissionResponse as GetAdmissionResponse, type index_GetAdmissionResponses as GetAdmissionResponses, type index_GetCommandManifestData as GetCommandManifestData, type index_GetCommandManifestError as GetCommandManifestError, type index_GetCommandManifestErrors as GetCommandManifestErrors, type index_GetCommandManifestResponse as GetCommandManifestResponse, type index_GetCommandManifestResponses as GetCommandManifestResponses, type index_GetDeviceCommandInvocationData as GetDeviceCommandInvocationData, type index_GetDeviceCommandInvocationError as GetDeviceCommandInvocationError, type index_GetDeviceCommandInvocationErrors as GetDeviceCommandInvocationErrors, type index_GetDeviceCommandInvocationResponse as GetDeviceCommandInvocationResponse, type index_GetDeviceCommandInvocationResponses as GetDeviceCommandInvocationResponses, type index_GetDeviceCommandsData as GetDeviceCommandsData, type index_GetDeviceCommandsError as GetDeviceCommandsError, type index_GetDeviceCommandsErrors as GetDeviceCommandsErrors, type index_GetDeviceCommandsResponse as GetDeviceCommandsResponse, type index_GetDeviceCommandsResponses as GetDeviceCommandsResponses, type index_GetDeviceData as GetDeviceData, type index_GetDeviceError as GetDeviceError, type index_GetDeviceErrors as GetDeviceErrors, type index_GetDeviceResponse as GetDeviceResponse, type index_GetDeviceResponses as GetDeviceResponses, type index_GetDeviceTypeData as GetDeviceTypeData, type index_GetDeviceTypeError as GetDeviceTypeError, type index_GetDeviceTypeErrors as GetDeviceTypeErrors, type index_GetDeviceTypeResponse as GetDeviceTypeResponse, type index_GetDeviceTypeResponses as GetDeviceTypeResponses, type index_GetFirmwareBundleData as GetFirmwareBundleData, type index_GetFirmwareBundleError as GetFirmwareBundleError, type index_GetFirmwareBundleErrors as GetFirmwareBundleErrors, type index_GetFirmwareBundleResponse as GetFirmwareBundleResponse, type index_GetFirmwareBundleResponses as GetFirmwareBundleResponses, type index_GetFirmwareDeploymentData as GetFirmwareDeploymentData, type index_GetFirmwareDeploymentError as GetFirmwareDeploymentError, type index_GetFirmwareDeploymentErrors as GetFirmwareDeploymentErrors, type index_GetFirmwareDeploymentResponse as GetFirmwareDeploymentResponse, type index_GetFirmwareDeploymentResponses as GetFirmwareDeploymentResponses, type index_GetIdentityData as GetIdentityData, type index_GetIdentityError as GetIdentityError, type index_GetIdentityErrors as GetIdentityErrors, type index_GetIdentityResponse as GetIdentityResponse, type index_GetIdentityResponses as GetIdentityResponses, type index_GetLatestTelemetryData as GetLatestTelemetryData, type index_GetLatestTelemetryError as GetLatestTelemetryError, type index_GetLatestTelemetryErrors as GetLatestTelemetryErrors, type index_GetLatestTelemetryResponse as GetLatestTelemetryResponse, type index_GetLatestTelemetryResponses as GetLatestTelemetryResponses, type index_GetProjectData as GetProjectData, type index_GetProjectError as GetProjectError, type index_GetProjectErrors as GetProjectErrors, type index_GetProjectResponse as GetProjectResponse, type index_GetProjectResponses as GetProjectResponses, type index_GetTelemetryHistoryData as GetTelemetryHistoryData, type index_GetTelemetryHistoryError as GetTelemetryHistoryError, type index_GetTelemetryHistoryErrors as GetTelemetryHistoryErrors, type index_GetTelemetryHistoryResponse as GetTelemetryHistoryResponse, type index_GetTelemetryHistoryResponses as GetTelemetryHistoryResponses, type index_GetTelemetryManifestData as GetTelemetryManifestData, type index_GetTelemetryManifestError as GetTelemetryManifestError, type index_GetTelemetryManifestErrors as GetTelemetryManifestErrors, type index_GetTelemetryManifestResponse as GetTelemetryManifestResponse, type index_GetTelemetryManifestResponses as GetTelemetryManifestResponses, type index_GetWebhookData as GetWebhookData, type index_GetWebhookError as GetWebhookError, type index_GetWebhookErrors as GetWebhookErrors, type index_GetWebhookResponse as GetWebhookResponse, type index_GetWebhookResponses as GetWebhookResponses, type index_Identity as Identity, type index_IdentityProject as IdentityProject, type index_IdentityToken as IdentityToken, type index_IdentityUser as IdentityUser, type index_ListAdmissionsData as ListAdmissionsData, type index_ListAdmissionsError as ListAdmissionsError, type index_ListAdmissionsErrors as ListAdmissionsErrors, type index_ListAdmissionsResponse as ListAdmissionsResponse, type index_ListAdmissionsResponses as ListAdmissionsResponses, type index_ListDeviceTypesData as ListDeviceTypesData, type index_ListDeviceTypesError as ListDeviceTypesError, type index_ListDeviceTypesErrors as ListDeviceTypesErrors, type index_ListDeviceTypesResponse as ListDeviceTypesResponse, type index_ListDeviceTypesResponses as ListDeviceTypesResponses, type index_ListDevicesData as ListDevicesData, type index_ListDevicesError as ListDevicesError, type index_ListDevicesErrors as ListDevicesErrors, type index_ListDevicesResponse as ListDevicesResponse, type index_ListDevicesResponses as ListDevicesResponses, type index_ListFirmwareBundlesData as ListFirmwareBundlesData, type index_ListFirmwareBundlesError as ListFirmwareBundlesError, type index_ListFirmwareBundlesErrors as ListFirmwareBundlesErrors, type index_ListFirmwareBundlesResponse as ListFirmwareBundlesResponse, type index_ListFirmwareBundlesResponses as ListFirmwareBundlesResponses, type index_ListFirmwareDeploymentsData as ListFirmwareDeploymentsData, type index_ListFirmwareDeploymentsError as ListFirmwareDeploymentsError, type index_ListFirmwareDeploymentsErrors as ListFirmwareDeploymentsErrors, type index_ListFirmwareDeploymentsResponse as ListFirmwareDeploymentsResponse, type index_ListFirmwareDeploymentsResponses as ListFirmwareDeploymentsResponses, type index_ListProjectsData as ListProjectsData, type index_ListProjectsError as ListProjectsError, type index_ListProjectsErrors as ListProjectsErrors, type index_ListProjectsResponse as ListProjectsResponse, type index_ListProjectsResponses as ListProjectsResponses, type index_ListWebhookDeliveriesData as ListWebhookDeliveriesData, type index_ListWebhookDeliveriesError as ListWebhookDeliveriesError, type index_ListWebhookDeliveriesErrors as ListWebhookDeliveriesErrors, type index_ListWebhookDeliveriesResponse as ListWebhookDeliveriesResponse, type index_ListWebhookDeliveriesResponses as ListWebhookDeliveriesResponses, type index_ListWebhooksData as ListWebhooksData, type index_ListWebhooksError as ListWebhooksError, type index_ListWebhooksErrors as ListWebhooksErrors, type index_ListWebhooksResponse as ListWebhooksResponse, type index_ListWebhooksResponses as ListWebhooksResponses, type index_MetricDefinition as MetricDefinition, type index_MetricGroup as MetricGroup, type index_Options as Options, type index_PageMeta as PageMeta, type index_Project as Project, type index_ProjectAppToken as ProjectAppToken, type index_ProjectListPage as ProjectListPage, type index_RejectAdmissionData as RejectAdmissionData, type index_RejectAdmissionError as RejectAdmissionError, type index_RejectAdmissionErrors as RejectAdmissionErrors, type index_RejectAdmissionResponse as RejectAdmissionResponse, type index_RejectAdmissionResponses as RejectAdmissionResponses, type index_ResetDeviceTokenData as ResetDeviceTokenData, type index_ResetDeviceTokenError as ResetDeviceTokenError, type index_ResetDeviceTokenErrors as ResetDeviceTokenErrors, type index_ResetDeviceTokenResponse as ResetDeviceTokenResponse, type index_ResetDeviceTokenResponses as ResetDeviceTokenResponses, type index_RollbackFirmwareDeploymentData as RollbackFirmwareDeploymentData, type index_RollbackFirmwareDeploymentError as RollbackFirmwareDeploymentError, type index_RollbackFirmwareDeploymentErrors as RollbackFirmwareDeploymentErrors, type index_RollbackFirmwareDeploymentResponse as RollbackFirmwareDeploymentResponse, type index_RollbackFirmwareDeploymentResponses as RollbackFirmwareDeploymentResponses, type index_RotateProjectAppTokenData as RotateProjectAppTokenData, type index_RotateProjectAppTokenError as RotateProjectAppTokenError, type index_RotateProjectAppTokenErrors as RotateProjectAppTokenErrors, type index_RotateProjectAppTokenResponse as RotateProjectAppTokenResponse, type index_RotateProjectAppTokenResponses as RotateProjectAppTokenResponses, type index_TelemetryHistory as TelemetryHistory, type index_TelemetryManifest as TelemetryManifest, type index_TelemetrySample as TelemetrySample, type index_TriggerFirmwareDeploymentData as TriggerFirmwareDeploymentData, type index_TriggerFirmwareDeploymentError as TriggerFirmwareDeploymentError, type index_TriggerFirmwareDeploymentErrors as TriggerFirmwareDeploymentErrors, type index_TriggerFirmwareDeploymentResponse as TriggerFirmwareDeploymentResponse, type index_TriggerFirmwareDeploymentResponses as TriggerFirmwareDeploymentResponses, type index_UpdateCommandManifestData as UpdateCommandManifestData, type index_UpdateCommandManifestError as UpdateCommandManifestError, type index_UpdateCommandManifestErrors as UpdateCommandManifestErrors, type index_UpdateCommandManifestResponse as UpdateCommandManifestResponse, type index_UpdateCommandManifestResponses as UpdateCommandManifestResponses, type index_UpdateDeviceTypeData as UpdateDeviceTypeData, type index_UpdateDeviceTypeError as UpdateDeviceTypeError, type index_UpdateDeviceTypeErrors as UpdateDeviceTypeErrors, type index_UpdateDeviceTypeResponse as UpdateDeviceTypeResponse, type index_UpdateDeviceTypeResponses as UpdateDeviceTypeResponses, type index_UpdateWebhookData as UpdateWebhookData, type index_UpdateWebhookError as UpdateWebhookError, type index_UpdateWebhookErrors as UpdateWebhookErrors, type index_UpdateWebhookResponse as UpdateWebhookResponse, type index_UpdateWebhookResponses as UpdateWebhookResponses, type index_UploadFirmwareData as UploadFirmwareData, type index_UploadFirmwareError as UploadFirmwareError, type index_UploadFirmwareErrors as UploadFirmwareErrors, type index_UploadFirmwareResponse as UploadFirmwareResponse, type index_UploadFirmwareResponses as UploadFirmwareResponses, type index_WebhookCreateRequest as WebhookCreateRequest, type index_WebhookCreateResponse as WebhookCreateResponse, type index_WebhookDelivery as WebhookDelivery, type index_WebhookDeliveryAttempt as WebhookDeliveryAttempt, type index_WebhookDeliveryPage as WebhookDeliveryPage, type index_WebhookEventType as WebhookEventType, type index_WebhookRetryPolicy as WebhookRetryPolicy, type index_WebhookSubscription as WebhookSubscription, type index_WebhookSubscriptionPage as WebhookSubscriptionPage, type index_WebhookUpdateRequest as WebhookUpdateRequest, index_acceptAdmission as acceptAdmission, index_cancelFirmwareDeployment as cancelFirmwareDeployment, index_createDeviceType as createDeviceType, index_createProjectAppToken as createProjectAppToken, index_createWebhook as createWebhook, index_deleteCommandManifest as deleteCommandManifest, index_deleteDevice as deleteDevice, index_deleteDeviceType as deleteDeviceType, index_deleteFirmwareBundle as deleteFirmwareBundle, index_deleteWebhook as deleteWebhook, index_dismissAdmission as dismissAdmission, index_execDeviceCommand as execDeviceCommand, index_getAdmission as getAdmission, index_getCommandManifest as getCommandManifest, index_getDevice as getDevice, index_getDeviceCommandInvocation as getDeviceCommandInvocation, index_getDeviceCommands as getDeviceCommands, index_getDeviceType as getDeviceType, index_getFirmwareBundle as getFirmwareBundle, index_getFirmwareDeployment as getFirmwareDeployment, index_getIdentity as getIdentity, index_getLatestTelemetry as getLatestTelemetry, index_getProject as getProject, index_getTelemetryHistory as getTelemetryHistory, index_getTelemetryManifest as getTelemetryManifest, index_getWebhook as getWebhook, index_listAdmissions as listAdmissions, index_listDeviceTypes as listDeviceTypes, index_listDevices as listDevices, index_listFirmwareBundles as listFirmwareBundles, index_listFirmwareDeployments as listFirmwareDeployments, index_listProjects as listProjects, index_listWebhookDeliveries as listWebhookDeliveries, index_listWebhooks as listWebhooks, index_rejectAdmission as rejectAdmission, index_resetDeviceToken as resetDeviceToken, index_rollbackFirmwareDeployment as rollbackFirmwareDeployment, index_rotateProjectAppToken as rotateProjectAppToken, index_triggerFirmwareDeployment as triggerFirmwareDeployment, index_updateCommandManifest as updateCommandManifest, index_updateDeviceType as updateDeviceType, index_updateWebhook as updateWebhook, index_uploadFirmware as uploadFirmware };
+}
+
+export { type Admission, type AdmissionAcceptRequest, type AdmissionAcceptResponse, type AdmissionListPage, AuthenticationError, BadRequestError, BundleExistsError, type CancelDeploymentParams, type CommandArgDefinition, type CommandDefinition, type CommandInvocation, type CommandManifest, type CommandRequest, type CommandResult, type DecodedMetric, type Device, type DeviceListItem, type DeviceListPage, DeviceRpcError, type DeviceTokenReset, type DeviceType, type DeviceTypeCreateRequest, type DeviceTypeListItem, type DeviceTypeListPage, type DeviceTypeUpdateRequest, type ErrorItem, type ErrorResponse, type FirmwareBundle, type FirmwareBundleListPage, type FirmwareDeployment, type FirmwareDeploymentCancelRequest, type FirmwareDeploymentListPage, type FirmwareDeploymentTriggerRequest, type FirmwareUploadResponse, type Identity, type IdentityProject, type IdentityToken, type IdentityUser, InsufficientScopeError, type IterateBundlesParams, type IterateDeploymentsParams, type IterateDevicesParams, type IterateWebhookDeliveriesParams, type IterateWebhooksParams, type ListBundlesParams, type ListDeploymentsParams, type ListDevicesParams, type ListWebhooksParams, type MetricDefinition, type MetricGroup, NetworkError, OrbitClient, type OrbitClientOptions, OrbitError, type OrbitErrorOptions, type OrbitWebhookEvent, type Page, type PageMeta, type Project, type ProjectAppToken, type ProjectListPage, RateLimitError, ResourceNotFoundError, ServerError, type TelemetryHistory, type TelemetryHistoryParams, type TelemetryManifest, type TelemetrySample, type TerminalTicketRequest, type TerminalTicketResponse, type UploadFirmwareParams, type UsbDeviceIdentifier, type UsbExportDefinition, type UsbExportList, type UsbTicketRequest, type UsbTicketResponse, ValidationError, type ValidationFieldError, type VerifyWebhookSignatureParams, WEBHOOK_REPLAY_TOLERANCE_SECONDS, type WebhookCreateRequest, type WebhookCreateResponse, type WebhookDeliveriesParams, type WebhookDelivery, type WebhookDeliveryPage, type WebhookEventType, type WebhookSubscription, type WebhookSubscriptionPage, type WebhookUpdateRequest, decodeSample, decodeSamples, normalizeError, paginate, parseRetryAfterSeconds, parseWebhookEvent, index as raw, signWebhookPayload, verifyWebhookSignature };